{"version":3,"names":[],"sources":["/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ptr.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/convert.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/alloc.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/str/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/vec.rs","./hey.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/result.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/macros.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/slice/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/mem.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/string.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/alloc.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/raw_vec.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/option.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/fmt/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/cmp.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/any.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/char/methods.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/alloc.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/sync/atomic.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/dlmalloc_shim/../../dlmalloc/src/lib.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/panicking.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/thread/local.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/cell.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/panic.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/rwlock.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/boxed.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libpanic_abort/lib.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/dlmalloc_shim/../../dlmalloc/src/dlmalloc.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/dlmalloc_shim/../../dlmalloc/src/wasm.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/iter/range.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/fmt.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ops/arith.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/panicking.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/iter/iterator.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/fmt/num.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ops/range.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/fmt/builders.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/slice/memchr.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/unicode/bool_trie.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/unicode/printable.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/unicode/tables.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/char/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/char/convert.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/str/pattern.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/clone.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/mem.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/time.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ops/function.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/hash/sip.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/iter/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/iter/traits.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/array.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/sync.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/collections/btree/map.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/collections/btree/node.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/slice.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/str.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc/borrow.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/error.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/stdio.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/buffered.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/lazy.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/impls.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/io/cursor.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/stdio.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/mutex.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/os_str.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/time.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/fs.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/process.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/os.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/net.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/condvar.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/args.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/path.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys/wasm/thread_local.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/error.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/remutex.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/poison.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/mutex.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/at_exit_imp.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/backtrace.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/thread.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/thread_local.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/rwlock.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/thread_info.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/condvar.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/process.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/util.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/wtf8.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sys_common/bytestring.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/ffi/os_str.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/ffi/c_str.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/path.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/time.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/thread/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/fs.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/mutex.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/once.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/condvar.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/mpsc/blocking.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/mpsc/select.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/sync/barrier.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/liballoc_system/lib.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/../stdsimd/stdsimd/arch/detect/cache.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/collections/hash/map.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/net/ip.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/net/addr.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/net/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/net/parser.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/future.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/memchr.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/env.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/panic.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libstd/rt.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/char/decode.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/flt2dec/strategy/dragon.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/flt2dec/strategy/grisu.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/flt2dec/decoder.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/flt2dec/estimator.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/flt2dec/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/dec2flt/parse.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/dec2flt/num.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/dec2flt/rawfp.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/dec2flt/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/bignum.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/diy_float.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/str/lossy.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/fmt/float.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/f32.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/num/f64.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ascii.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/exp2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/exp2f.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_tan.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fabs.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/scalbn.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/rem_pio2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/floor.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/acos.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/sqrt.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/asin.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/atan2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/cbrt.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/cosh.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_expo2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/hypot.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log1p.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/sinh.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/expo2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/tan.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/tanh.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/cos.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_cos.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_sin.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/cosf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_cosf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/k_sinf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/rem_pio2f.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/expf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/scalbnf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log2.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log2f.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log10.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log10f.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/log.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/logf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/round.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/roundf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/sin.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/sinf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/pow.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/powf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/sqrtf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fabsf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fmod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fmodf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fma.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/../libm/src/math/fmaf.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/cmp.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/add.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/pow.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/mul.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/div.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/float/extend.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/int/mod.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/int/addsub.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/macros.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/int/mul.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/int/sdiv.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/int/shift.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/rustc/compiler_builtins_shim/../../libcompiler_builtins/src/lib.rs","/rustc/653da4fd006c97625247acd7e076d0782cdc149b/src/libcore/ops/bit.rs"],"sourcesContent":["// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Manually manage memory through raw pointers.\n//!\n//! *[See also the pointer primitive types](../../std/primitive.pointer.html).*\n//!\n//! # Safety\n//!\n//! Many functions in this module take raw pointers as arguments and read from\n//! or write to them. For this to be safe, these pointers must be *valid*.\n//! Whether a pointer is valid depends on the operation it is used for\n//! (read or write), and the extent of the memory that is accessed (i.e.,\n//! how many bytes are read/written). Most functions use `*mut T` and `*const T`\n//! to access only a single value, in which case the documentation omits the size\n//! and implicitly assumes it to be `size_of::<T>()` bytes.\n//!\n//! The precise rules for validity are not determined yet.  The guarantees that are\n//! provided at this point are very minimal:\n//!\n//! * A [null] pointer is *never* valid, not even for accesses of [size zero][zst].\n//! * All pointers (except for the null pointer) are valid for all operations of\n//!   [size zero][zst].\n//! * All accesses performed by functions in this module are *non-atomic* in the sense\n//!   of [atomic operations] used to synchronize between threads. This means it is\n//!   undefined behavior to perform two concurrent accesses to the same location from different\n//!   threads unless both accesses only read from memory. Notice that this explicitly\n//!   includes [`read_volatile`] and [`write_volatile`]: Volatile accesses cannot\n//!   be used for inter-thread synchronization.\n//! * The result of casting a reference to a pointer is valid for as long as the\n//!   underlying object is live and no reference (just raw pointers) is used to\n//!   access the same memory.\n//!\n//! These axioms, along with careful use of [`offset`] for pointer arithmetic,\n//! are enough to correctly implement many useful things in unsafe code. Stronger guarantees\n//! will be provided eventually, as the [aliasing] rules are being determined. For more\n//! information, see the [book] as well as the section in the reference devoted\n//! to [undefined behavior][ub].\n//!\n//! ## Alignment\n//!\n//! Valid raw pointers as defined above are not necessarily properly aligned (where\n//! \"proper\" alignment is defined by the pointee type, i.e., `*const T` must be\n//! aligned to `mem::align_of::<T>()`). However, most functions require their\n//! arguments to be properly aligned, and will explicitly state\n//! this requirement in their documentation. Notable exceptions to this are\n//! [`read_unaligned`] and [`write_unaligned`].\n//!\n//! When a function requires proper alignment, it does so even if the access\n//! has size 0, i.e., even if memory is not actually touched. Consider using\n//! [`NonNull::dangling`] in such cases.\n//!\n//! [aliasing]: ../../nomicon/aliasing.html\n//! [book]: ../../book/second-edition/ch19-01-unsafe-rust.html#dereferencing-a-raw-pointer\n//! [ub]: ../../reference/behavior-considered-undefined.html\n//! [null]: ./fn.null.html\n//! [zst]: ../../nomicon/exotic-sizes.html#zero-sized-types-zsts\n//! [atomic operations]: ../../std/sync/atomic/index.html\n//! [`copy`]: ../../std/ptr/fn.copy.html\n//! [`offset`]: ../../std/primitive.pointer.html#method.offset\n//! [`read_unaligned`]: ./fn.read_unaligned.html\n//! [`write_unaligned`]: ./fn.write_unaligned.html\n//! [`read_volatile`]: ./fn.read_volatile.html\n//! [`write_volatile`]: ./fn.write_volatile.html\n//! [`NonNull::dangling`]: ./struct.NonNull.html#method.dangling\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse convert::From;\nuse intrinsics;\nuse ops::{CoerceUnsized, DispatchFromDyn};\nuse fmt;\nuse hash;\nuse marker::{PhantomData, Unsize};\nuse mem;\nuse nonzero::NonZero;\n\nuse cmp::Ordering::{self, Less, Equal, Greater};\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use intrinsics::copy_nonoverlapping;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use intrinsics::copy;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use intrinsics::write_bytes;\n\n/// Executes the destructor (if any) of the pointed-to value.\n///\n/// This is semantically equivalent to calling [`ptr::read`] and discarding\n/// the result, but has the following advantages:\n///\n/// * It is *required* to use `drop_in_place` to drop unsized types like\n///   trait objects, because they can't be read out onto the stack and\n///   dropped normally.\n///\n/// * It is friendlier to the optimizer to do this over [`ptr::read`] when\n///   dropping manually allocated memory (e.g. when writing Box/Rc/Vec),\n///   as the compiler doesn't need to prove that it's sound to elide the\n///   copy.\n///\n/// [`ptr::read`]: ../ptr/fn.read.html\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `to_drop` must be [valid] for reads.\n///\n/// * `to_drop` must be properly aligned.  See the example below for how to drop\n///   an unaligned pointer.\n///\n/// Additionally, if `T` is not [`Copy`], using the pointed-to value after\n/// calling `drop_in_place` can cause undefined behavior. Note that `*to_drop =\n/// foo` counts as a use because it will cause the the value to be dropped\n/// again. [`write`] can be used to overwrite data without causing it to be\n/// dropped.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n/// [`Copy`]: ../marker/trait.Copy.html\n/// [`write`]: ../ptr/fn.write.html\n///\n/// # Examples\n///\n/// Manually remove the last item from a vector:\n///\n/// ```\n/// use std::ptr;\n/// use std::rc::Rc;\n///\n/// let last = Rc::new(1);\n/// let weak = Rc::downgrade(&last);\n///\n/// let mut v = vec![Rc::new(0), last];\n///\n/// unsafe {\n///     // Get a raw pointer to the last element in `v`.\n///     let ptr = &mut v[1] as *mut _;\n///     // Shorten `v` to prevent the last item from being dropped.  We do that first,\n///     // to prevent issues if the `drop_in_place` below panics.\n///     v.set_len(1);\n///     // Without a call `drop_in_place`, the last item would never be dropped,\n///     // and the memory it manages would be leaked.\n///     ptr::drop_in_place(ptr);\n/// }\n///\n/// assert_eq!(v, &[0.into()]);\n///\n/// // Ensure that the last item was dropped.\n/// assert!(weak.upgrade().is_none());\n/// ```\n///\n/// Unaligned values cannot be dropped in place, they must be copied to an aligned\n/// location first:\n/// ```\n/// use std::ptr;\n/// use std::mem;\n///\n/// unsafe fn drop_after_copy<T>(to_drop: *mut T) {\n///     let mut copy: T = mem::uninitialized();\n///     ptr::copy(to_drop, &mut copy, 1);\n///     drop(copy);\n/// }\n///\n/// #[repr(packed, C)]\n/// struct Packed {\n///     _padding: u8,\n///     unaligned: Vec<i32>,\n/// }\n///\n/// let mut p = Packed { _padding: 0, unaligned: vec![42] };\n/// unsafe {\n///     drop_after_copy(&mut p.unaligned as *mut _);\n///     mem::forget(p);\n/// }\n/// ```\n///\n/// Notice that the compiler performs this copy automatically when dropping packed structs,\n/// i.e., you do not usually have to worry about such issues unless you call `drop_in_place`\n/// manually.\n#[stable(feature = \"drop_in_place\", since = \"1.8.0\")]\n#[lang = \"drop_in_place\"]\n#[allow(unconditional_recursion)]\npub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {\n    // Code here does not matter - this is replaced by the\n    // real drop glue by the compiler.\n    drop_in_place(to_drop);\n}\n\n/// Creates a null raw pointer.\n///\n/// # Examples\n///\n/// ```\n/// use std::ptr;\n///\n/// let p: *const i32 = ptr::null();\n/// assert!(p.is_null());\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_promotable]\npub const fn null<T>() -> *const T { 0 as *const T }\n\n/// Creates a null mutable raw pointer.\n///\n/// # Examples\n///\n/// ```\n/// use std::ptr;\n///\n/// let p: *mut i32 = ptr::null_mut();\n/// assert!(p.is_null());\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_promotable]\npub const fn null_mut<T>() -> *mut T { 0 as *mut T }\n\n/// Swaps the values at two mutable locations of the same type, without\n/// deinitializing either.\n///\n/// But for the following two exceptions, this function is semantically\n/// equivalent to [`mem::swap`]:\n///\n/// * It operates on raw pointers instead of references. When references are\n///   available, [`mem::swap`] should be preferred.\n///\n/// * The two pointed-to values may overlap. If the values do overlap, then the\n///   overlapping region of memory from `x` will be used. This is demonstrated\n///   in the second example below.\n///\n/// [`mem::swap`]: ../mem/fn.swap.html\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * Both `x` and `y` must be [valid] for reads and writes.\n///\n/// * Both `x` and `y` must be properly aligned.\n///\n/// Note that even if `T` has size `0`, the pointers must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n///\n/// # Examples\n///\n/// Swapping two non-overlapping regions:\n///\n/// ```\n/// use std::ptr;\n///\n/// let mut array = [0, 1, 2, 3];\n///\n/// let x = array[0..].as_mut_ptr() as *mut [u32; 2]; // this is `array[0..2]`\n/// let y = array[2..].as_mut_ptr() as *mut [u32; 2]; // this is `array[2..4]`\n///\n/// unsafe {\n///     ptr::swap(x, y);\n///     assert_eq!([2, 3, 0, 1], array);\n/// }\n/// ```\n///\n/// Swapping two overlapping regions:\n///\n/// ```\n/// use std::ptr;\n///\n/// let mut array = [0, 1, 2, 3];\n///\n/// let x = array[0..].as_mut_ptr() as *mut [u32; 3]; // this is `array[0..3]`\n/// let y = array[1..].as_mut_ptr() as *mut [u32; 3]; // this is `array[1..4]`\n///\n/// unsafe {\n///     ptr::swap(x, y);\n///     // The indices `1..3` of the slice overlap between `x` and `y`.\n///     // Reasonable results would be for to them be `[2, 3]`, so that indices `0..3` are\n///     // `[1, 2, 3]` (matching `y` before the `swap`); or for them to be `[0, 1]`\n///     // so that indices `1..4` are `[0, 1, 2]` (matching `x` before the `swap`).\n///     // This implementation is defined to make the latter choice.\n///     assert_eq!([1, 0, 1, 2], array);\n/// }\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn swap<T>(x: *mut T, y: *mut T) {\n    // Give ourselves some scratch space to work with\n    let mut tmp: T = mem::uninitialized();\n\n    // Perform the swap\n    copy_nonoverlapping(x, &mut tmp, 1);\n    copy(y, x, 1); // `x` and `y` may overlap\n    copy_nonoverlapping(&tmp, y, 1);\n\n    // y and t now point to the same thing, but we need to completely forget `tmp`\n    // because it's no longer relevant.\n    mem::forget(tmp);\n}\n\n/// Swaps `count * size_of::<T>()` bytes between the two regions of memory\n/// beginning at `x` and `y`. The two regions must *not* overlap.\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * Both `x` and `y` must be [valid] for reads and writes of `count *\n///   size_of::<T>()` bytes.\n///\n/// * Both `x` and `y` must be properly aligned.\n///\n/// * The region of memory beginning at `x` with a size of `count *\n///   size_of::<T>()` bytes must *not* overlap with the region of memory\n///   beginning at `y` with the same size.\n///\n/// Note that even if the effectively copied size (`count * size_of::<T>()`) is `0`,\n/// the pointers must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::ptr;\n///\n/// let mut x = [1, 2, 3, 4];\n/// let mut y = [7, 8, 9];\n///\n/// unsafe {\n///     ptr::swap_nonoverlapping(x.as_mut_ptr(), y.as_mut_ptr(), 2);\n/// }\n///\n/// assert_eq!(x, [7, 8, 3, 4]);\n/// assert_eq!(y, [1, 2, 9]);\n/// ```\n#[inline]\n#[stable(feature = \"swap_nonoverlapping\", since = \"1.27.0\")]\npub unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize) {\n    let x = x as *mut u8;\n    let y = y as *mut u8;\n    let len = mem::size_of::<T>() * count;\n    swap_nonoverlapping_bytes(x, y, len)\n}\n\n#[inline]\npub(crate) unsafe fn swap_nonoverlapping_one<T>(x: *mut T, y: *mut T) {\n    // For types smaller than the block optimization below,\n    // just swap directly to avoid pessimizing codegen.\n    if mem::size_of::<T>() < 32 {\n        let z = read(x);\n        copy_nonoverlapping(y, x, 1);\n        write(y, z);\n    } else {\n        swap_nonoverlapping(x, y, 1);\n    }\n}\n\n#[inline]\nunsafe fn swap_nonoverlapping_bytes(x: *mut u8, y: *mut u8, len: usize) {\n    // The approach here is to utilize simd to swap x & y efficiently. Testing reveals\n    // that swapping either 32 bytes or 64 bytes at a time is most efficient for intel\n    // Haswell E processors. LLVM is more able to optimize if we give a struct a\n    // #[repr(simd)], even if we don't actually use this struct directly.\n    //\n    // FIXME repr(simd) broken on emscripten and redox\n    // It's also broken on big-endian powerpc64 and s390x.  #42778\n    #[cfg_attr(not(any(target_os = \"emscripten\", target_os = \"redox\",\n                       target_endian = \"big\")),\n               repr(simd))]\n    struct Block(u64, u64, u64, u64);\n    struct UnalignedBlock(u64, u64, u64, u64);\n\n    let block_size = mem::size_of::<Block>();\n\n    // Loop through x & y, copying them `Block` at a time\n    // The optimizer should unroll the loop fully for most types\n    // N.B. We can't use a for loop as the `range` impl calls `mem::swap` recursively\n    let mut i = 0;\n    while i + block_size <= len {\n        // Create some uninitialized memory as scratch space\n        // Declaring `t` here avoids aligning the stack when this loop is unused\n        let mut t: Block = mem::uninitialized();\n        let t = &mut t as *mut _ as *mut u8;\n        let x = x.add(i);\n        let y = y.add(i);\n\n        // Swap a block of bytes of x & y, using t as a temporary buffer\n        // This should be optimized into efficient SIMD operations where available\n        copy_nonoverlapping(x, t, block_size);\n        copy_nonoverlapping(y, x, block_size);\n        copy_nonoverlapping(t, y, block_size);\n        i += block_size;\n    }\n\n    if i < len {\n        // Swap any remaining bytes\n        let mut t: UnalignedBlock = mem::uninitialized();\n        let rem = len - i;\n\n        let t = &mut t as *mut _ as *mut u8;\n        let x = x.add(i);\n        let y = y.add(i);\n\n        copy_nonoverlapping(x, t, rem);\n        copy_nonoverlapping(y, x, rem);\n        copy_nonoverlapping(t, y, rem);\n    }\n}\n\n/// Moves `src` into the pointed `dst`, returning the previous `dst` value.\n///\n/// Neither value is dropped.\n///\n/// This function is semantically equivalent to [`mem::replace`] except that it\n/// operates on raw pointers instead of references. When references are\n/// available, [`mem::replace`] should be preferred.\n///\n/// [`mem::replace`]: ../mem/fn.replace.html\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `dst` must be [valid] for writes.\n///\n/// * `dst` must be properly aligned.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n///\n/// # Examples\n///\n/// ```\n/// use std::ptr;\n///\n/// let mut rust = vec!['b', 'u', 's', 't'];\n///\n/// // `mem::replace` would have the same effect without requiring the unsafe\n/// // block.\n/// let b = unsafe {\n///     ptr::replace(&mut rust[0], 'r')\n/// };\n///\n/// assert_eq!(b, 'b');\n/// assert_eq!(rust, &['r', 'u', 's', 't']);\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn replace<T>(dst: *mut T, mut src: T) -> T {\n    mem::swap(&mut *dst, &mut src); // cannot overlap\n    src\n}\n\n/// Reads the value from `src` without moving it. This leaves the\n/// memory in `src` unchanged.\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `src` must be [valid] for reads.\n///\n/// * `src` must be properly aligned. Use [`read_unaligned`] if this is not the\n///   case.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let x = 12;\n/// let y = &x as *const i32;\n///\n/// unsafe {\n///     assert_eq!(std::ptr::read(y), 12);\n/// }\n/// ```\n///\n/// Manually implement [`mem::swap`]:\n///\n/// ```\n/// use std::ptr;\n///\n/// fn swap<T>(a: &mut T, b: &mut T) {\n///     unsafe {\n///         // Create a bitwise copy of the value at `a` in `tmp`.\n///         let tmp = ptr::read(a);\n///\n///         // Exiting at this point (either by explicitly returning or by\n///         // calling a function which panics) would cause the value in `tmp` to\n///         // be dropped while the same value is still referenced by `a`. This\n///         // could trigger undefined behavior if `T` is not `Copy`.\n///\n///         // Create a bitwise copy of the value at `b` in `a`.\n///         // This is safe because mutable references cannot alias.\n///         ptr::copy_nonoverlapping(b, a, 1);\n///\n///         // As above, exiting here could trigger undefined behavior because\n///         // the same value is referenced by `a` and `b`.\n///\n///         // Move `tmp` into `b`.\n///         ptr::write(b, tmp);\n///\n///         // `tmp` has been moved (`write` takes ownership of its second argument),\n///         // so nothing is dropped implicitly here.\n///     }\n/// }\n///\n/// let mut foo = \"foo\".to_owned();\n/// let mut bar = \"bar\".to_owned();\n///\n/// swap(&mut foo, &mut bar);\n///\n/// assert_eq!(foo, \"bar\");\n/// assert_eq!(bar, \"foo\");\n/// ```\n///\n/// ## Ownership of the Returned Value\n///\n/// `read` creates a bitwise copy of `T`, regardless of whether `T` is [`Copy`].\n/// If `T` is not [`Copy`], using both the returned value and the value at\n/// `*src` can violate memory safety.  Note that assigning to `*src` counts as a\n/// use because it will attempt to drop the value at `*src`.\n///\n/// [`write`] can be used to overwrite data without causing it to be dropped.\n///\n/// ```\n/// use std::ptr;\n///\n/// let mut s = String::from(\"foo\");\n/// unsafe {\n///     // `s2` now points to the same underlying memory as `s`.\n///     let mut s2: String = ptr::read(&s);\n///\n///     assert_eq!(s2, \"foo\");\n///\n///     // Assigning to `s2` causes its original value to be dropped. Beyond\n///     // this point, `s` must no longer be used, as the underlying memory has\n///     // been freed.\n///     s2 = String::default();\n///     assert_eq!(s2, \"\");\n///\n///     // Assigning to `s` would cause the old value to be dropped again,\n///     // resulting in undefined behavior.\n///     // s = String::from(\"bar\"); // ERROR\n///\n///     // `ptr::write` can be used to overwrite a value without dropping it.\n///     ptr::write(&mut s, String::from(\"bar\"));\n/// }\n///\n/// assert_eq!(s, \"bar\");\n/// ```\n///\n/// [`mem::swap`]: ../mem/fn.swap.html\n/// [valid]: ../ptr/index.html#safety\n/// [`Copy`]: ../marker/trait.Copy.html\n/// [`read_unaligned`]: ./fn.read_unaligned.html\n/// [`write`]: ./fn.write.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn read<T>(src: *const T) -> T {\n    let mut tmp: T = mem::uninitialized();\n    copy_nonoverlapping(src, &mut tmp, 1);\n    tmp\n}\n\n/// Reads the value from `src` without moving it. This leaves the\n/// memory in `src` unchanged.\n///\n/// Unlike [`read`], `read_unaligned` works with unaligned pointers.\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `src` must be [valid] for reads.\n///\n/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of\n/// whether `T` is [`Copy`].  If `T` is not [`Copy`], using both the returned\n/// value and the value at `*src` can [violate memory safety][read-ownership].\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [`Copy`]: ../marker/trait.Copy.html\n/// [`read`]: ./fn.read.html\n/// [`write_unaligned`]: ./fn.write_unaligned.html\n/// [read-ownership]: ./fn.read.html#ownership-of-the-returned-value\n/// [valid]: ../ptr/index.html#safety\n///\n/// # Examples\n///\n/// Access members of a packed struct by reference:\n///\n/// ```\n/// use std::ptr;\n///\n/// #[repr(packed, C)]\n/// struct Packed {\n///     _padding: u8,\n///     unaligned: u32,\n/// }\n///\n/// let x = Packed {\n///     _padding: 0x00,\n///     unaligned: 0x01020304,\n/// };\n///\n/// let v = unsafe {\n///     // Take the address of a 32-bit integer which is not aligned.\n///     // This must be done as a raw pointer; unaligned references are invalid.\n///     let unaligned = &x.unaligned as *const u32;\n///\n///     // Dereferencing normally will emit an aligned load instruction,\n///     // causing undefined behavior.\n///     // let v = *unaligned; // ERROR\n///\n///     // Instead, use `read_unaligned` to read improperly aligned values.\n///     let v = ptr::read_unaligned(unaligned);\n///\n///     v\n/// };\n///\n/// // Accessing unaligned values directly is safe.\n/// assert!(x.unaligned == v);\n/// ```\n#[inline]\n#[stable(feature = \"ptr_unaligned\", since = \"1.17.0\")]\npub unsafe fn read_unaligned<T>(src: *const T) -> T {\n    let mut tmp: T = mem::uninitialized();\n    copy_nonoverlapping(src as *const u8,\n                        &mut tmp as *mut T as *mut u8,\n                        mem::size_of::<T>());\n    tmp\n}\n\n/// Overwrites a memory location with the given value without reading or\n/// dropping the old value.\n///\n/// `write` does not drop the contents of `dst`. This is safe, but it could leak\n/// allocations or resources, so care should be taken not to overwrite an object\n/// that should be dropped.\n///\n/// Additionally, it does not drop `src`. Semantically, `src` is moved into the\n/// location pointed to by `dst`.\n///\n/// This is appropriate for initializing uninitialized memory, or overwriting\n/// memory that has previously been [`read`] from.\n///\n/// [`read`]: ./fn.read.html\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `dst` must be [valid] for writes.\n///\n/// * `dst` must be properly aligned. Use [`write_unaligned`] if this is not the\n///   case.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n/// [`write_unaligned`]: ./fn.write_unaligned.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let mut x = 0;\n/// let y = &mut x as *mut i32;\n/// let z = 12;\n///\n/// unsafe {\n///     std::ptr::write(y, z);\n///     assert_eq!(std::ptr::read(y), 12);\n/// }\n/// ```\n///\n/// Manually implement [`mem::swap`]:\n///\n/// ```\n/// use std::ptr;\n///\n/// fn swap<T>(a: &mut T, b: &mut T) {\n///     unsafe {\n///         // Create a bitwise copy of the value at `a` in `tmp`.\n///         let tmp = ptr::read(a);\n///\n///         // Exiting at this point (either by explicitly returning or by\n///         // calling a function which panics) would cause the value in `tmp` to\n///         // be dropped while the same value is still referenced by `a`. This\n///         // could trigger undefined behavior if `T` is not `Copy`.\n///\n///         // Create a bitwise copy of the value at `b` in `a`.\n///         // This is safe because mutable references cannot alias.\n///         ptr::copy_nonoverlapping(b, a, 1);\n///\n///         // As above, exiting here could trigger undefined behavior because\n///         // the same value is referenced by `a` and `b`.\n///\n///         // Move `tmp` into `b`.\n///         ptr::write(b, tmp);\n///\n///         // `tmp` has been moved (`write` takes ownership of its second argument),\n///         // so nothing is dropped implicitly here.\n///     }\n/// }\n///\n/// let mut foo = \"foo\".to_owned();\n/// let mut bar = \"bar\".to_owned();\n///\n/// swap(&mut foo, &mut bar);\n///\n/// assert_eq!(foo, \"bar\");\n/// assert_eq!(bar, \"foo\");\n/// ```\n///\n/// [`mem::swap`]: ../mem/fn.swap.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn write<T>(dst: *mut T, src: T) {\n    intrinsics::move_val_init(&mut *dst, src)\n}\n\n/// Overwrites a memory location with the given value without reading or\n/// dropping the old value.\n///\n/// Unlike [`write`], the pointer may be unaligned.\n///\n/// `write_unaligned` does not drop the contents of `dst`. This is safe, but it\n/// could leak allocations or resources, so care should be taken not to overwrite\n/// an object that should be dropped.\n///\n/// Additionally, it does not drop `src`. Semantically, `src` is moved into the\n/// location pointed to by `dst`.\n///\n/// This is appropriate for initializing uninitialized memory, or overwriting\n/// memory that has previously been read with [`read_unaligned`].\n///\n/// [`write`]: ./fn.write.html\n/// [`read_unaligned`]: ./fn.read_unaligned.html\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `dst` must be [valid] for writes.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n///\n/// # Examples\n///\n/// Access fields in a packed struct:\n///\n/// ```\n/// use std::{mem, ptr};\n///\n/// #[repr(packed, C)]\n/// #[derive(Default)]\n/// struct Packed {\n///     _padding: u8,\n///     unaligned: u32,\n/// }\n///\n/// let v = 0x01020304;\n/// let mut x: Packed = unsafe { mem::zeroed() };\n///\n/// unsafe {\n///     // Take a reference to a 32-bit integer which is not aligned.\n///     let unaligned = &mut x.unaligned as *mut u32;\n///\n///     // Dereferencing normally will emit an aligned store instruction,\n///     // causing undefined behavior because the pointer is not aligned.\n///     // *unaligned = v; // ERROR\n///\n///     // Instead, use `write_unaligned` to write improperly aligned values.\n///     ptr::write_unaligned(unaligned, v);\n/// }\n///\n/// // Accessing unaligned values directly is safe.\n/// assert!(x.unaligned == v);\n/// ```\n#[inline]\n#[stable(feature = \"ptr_unaligned\", since = \"1.17.0\")]\npub unsafe fn write_unaligned<T>(dst: *mut T, src: T) {\n    copy_nonoverlapping(&src as *const T as *const u8,\n                        dst as *mut u8,\n                        mem::size_of::<T>());\n    mem::forget(src);\n}\n\n/// Performs a volatile read of the value from `src` without moving it. This\n/// leaves the memory in `src` unchanged.\n///\n/// Volatile operations are intended to act on I/O memory, and are guaranteed\n/// to not be elided or reordered by the compiler across other volatile\n/// operations.\n///\n/// Memory accessed with `read_volatile` or [`write_volatile`] should not be\n/// accessed with non-volatile operations.\n///\n/// [`write_volatile`]: ./fn.write_volatile.html\n///\n/// # Notes\n///\n/// Rust does not currently have a rigorously and formally defined memory model,\n/// so the precise semantics of what \"volatile\" means here is subject to change\n/// over time. That being said, the semantics will almost always end up pretty\n/// similar to [C11's definition of volatile][c11].\n///\n/// The compiler shouldn't change the relative order or number of volatile\n/// memory operations. However, volatile memory operations on zero-sized types\n/// (e.g. if a zero-sized type is passed to `read_volatile`) are no-ops\n/// and may be ignored.\n///\n/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `src` must be [valid] for reads.\n///\n/// * `src` must be properly aligned.\n///\n/// Like [`read`], `read_unaligned` creates a bitwise copy of `T`, regardless of\n/// whether `T` is [`Copy`].  If `T` is not [`Copy`], using both the returned\n/// value and the value at `*src` can [violate memory safety][read-ownership].\n/// However, storing non-[`Copy`] types in volatile memory is almost certainly\n/// incorrect.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n/// [`Copy`]: ../marker/trait.Copy.html\n/// [`read`]: ./fn.read.html\n///\n/// Just like in C, whether an operation is volatile has no bearing whatsoever\n/// on questions involving concurrent access from multiple threads. Volatile\n/// accesses behave exactly like non-atomic accesses in that regard. In particular,\n/// a race between a `read_volatile` and any write operation to the same location\n/// is undefined behavior.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let x = 12;\n/// let y = &x as *const i32;\n///\n/// unsafe {\n///     assert_eq!(std::ptr::read_volatile(y), 12);\n/// }\n/// ```\n#[inline]\n#[stable(feature = \"volatile\", since = \"1.9.0\")]\npub unsafe fn read_volatile<T>(src: *const T) -> T {\n    intrinsics::volatile_load(src)\n}\n\n/// Performs a volatile write of a memory location with the given value without\n/// reading or dropping the old value.\n///\n/// Volatile operations are intended to act on I/O memory, and are guaranteed\n/// to not be elided or reordered by the compiler across other volatile\n/// operations.\n///\n/// Memory accessed with [`read_volatile`] or `write_volatile` should not be\n/// accessed with non-volatile operations.\n///\n/// `write_volatile` does not drop the contents of `dst`. This is safe, but it\n/// could leak allocations or resources, so care should be taken not to overwrite\n/// an object that should be dropped.\n///\n/// Additionally, it does not drop `src`. Semantically, `src` is moved into the\n/// location pointed to by `dst`.\n///\n/// [`read_volatile`]: ./fn.read_volatile.html\n///\n/// # Notes\n///\n/// Rust does not currently have a rigorously and formally defined memory model,\n/// so the precise semantics of what \"volatile\" means here is subject to change\n/// over time. That being said, the semantics will almost always end up pretty\n/// similar to [C11's definition of volatile][c11].\n///\n/// The compiler shouldn't change the relative order or number of volatile\n/// memory operations. However, volatile memory operations on zero-sized types\n/// (e.g. if a zero-sized type is passed to `write_volatile`) are no-ops\n/// and may be ignored.\n///\n/// [c11]: http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf\n///\n/// # Safety\n///\n/// Behavior is undefined if any of the following conditions are violated:\n///\n/// * `dst` must be [valid] for writes.\n///\n/// * `dst` must be properly aligned.\n///\n/// Note that even if `T` has size `0`, the pointer must be non-NULL and properly aligned.\n///\n/// [valid]: ../ptr/index.html#safety\n///\n/// Just like in C, whether an operation is volatile has no bearing whatsoever\n/// on questions involving concurrent access from multiple threads. Volatile\n/// accesses behave exactly like non-atomic accesses in that regard. In particular,\n/// a race between a `write_volatile` and any other operation (reading or writing)\n/// on the same location is undefined behavior.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let mut x = 0;\n/// let y = &mut x as *mut i32;\n/// let z = 12;\n///\n/// unsafe {\n///     std::ptr::write_volatile(y, z);\n///     assert_eq!(std::ptr::read_volatile(y), 12);\n/// }\n/// ```\n#[inline]\n#[stable(feature = \"volatile\", since = \"1.9.0\")]\npub unsafe fn write_volatile<T>(dst: *mut T, src: T) {\n    intrinsics::volatile_store(dst, src);\n}\n\n#[lang = \"const_ptr\"]\nimpl<T: ?Sized> *const T {\n    /// Returns `true` if the pointer is null.\n    ///\n    /// Note that unsized types have many possible null pointers, as only the\n    /// raw data pointer is considered, not their length, vtable, etc.\n    /// Therefore, two pointers that are null may still not compare equal to\n    /// each other.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"Follow the rabbit\";\n    /// let ptr: *const u8 = s.as_ptr();\n    /// assert!(!ptr.is_null());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_null(self) -> bool {\n        // Compare via a cast to a thin pointer, so fat pointers are only\n        // considering their \"data\" part for null-ness.\n        (self as *const u8) == null()\n    }\n\n    /// Returns `None` if the pointer is null, or else returns a reference to\n    /// the value wrapped in `Some`.\n    ///\n    /// # Safety\n    ///\n    /// While this method and its mutable counterpart are useful for\n    /// null-safety, it is important to note that this is still an unsafe\n    /// operation because the returned value could be pointing to invalid\n    /// memory.\n    ///\n    /// Additionally, the lifetime `'a` returned is arbitrarily chosen and does\n    /// not necessarily reflect the actual lifetime of the data.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let ptr: *const u8 = &10u8 as *const u8;\n    ///\n    /// unsafe {\n    ///     if let Some(val_back) = ptr.as_ref() {\n    ///         println!(\"We got back the value: {}!\", val_back);\n    ///     }\n    /// }\n    /// ```\n    ///\n    /// # Null-unchecked version\n    ///\n    /// If you are sure the pointer can never be null and are looking for some kind of\n    /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>, know that you can\n    /// dereference the pointer directly.\n    ///\n    /// ```\n    /// let ptr: *const u8 = &10u8 as *const u8;\n    ///\n    /// unsafe {\n    ///     let val_back = &*ptr;\n    ///     println!(\"We got back the value: {}!\", val_back);\n    /// }\n    /// ```\n    #[stable(feature = \"ptr_as_ref\", since = \"1.9.0\")]\n    #[inline]\n    pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {\n        if self.is_null() {\n            None\n        } else {\n            Some(&*self)\n        }\n    }\n\n    /// Calculates the offset from a pointer.\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum, **in bytes** must fit in a usize.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"123\";\n    /// let ptr: *const u8 = s.as_ptr();\n    ///\n    /// unsafe {\n    ///     println!(\"{}\", *ptr.offset(1) as char);\n    ///     println!(\"{}\", *ptr.offset(2) as char);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub unsafe fn offset(self, count: isize) -> *const T where T: Sized {\n        intrinsics::offset(self, count)\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    /// In particular, the resulting pointer may *not* be used to access a\n    /// different allocated object than the one `self` points to. In other\n    /// words, `x.wrapping_offset(y.wrapping_offset_from(x))` is\n    /// *not* the same as `y`, and dereferencing it is undefined behavior\n    /// unless `x` and `y` point into the same allocated object.\n    ///\n    /// Always use `.offset(count)` instead when possible, because `offset`\n    /// allows the compiler to optimize better.  If you need to cross object\n    /// boundaries, cast the pointer to an integer and do the arithmetic there.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements\n    /// let data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *const u8 = data.as_ptr();\n    /// let step = 2;\n    /// let end_rounded_up = ptr.wrapping_offset(6);\n    ///\n    /// // This loop prints \"1, 3, 5, \"\n    /// while ptr != end_rounded_up {\n    ///     unsafe {\n    ///         print!(\"{}, \", *ptr);\n    ///     }\n    ///     ptr = ptr.wrapping_offset(step);\n    /// }\n    /// ```\n    #[stable(feature = \"ptr_wrapping_offset\", since = \"1.16.0\")]\n    #[inline]\n    pub fn wrapping_offset(self, count: isize) -> *const T where T: Sized {\n        unsafe {\n            intrinsics::arith_offset(self, count)\n        }\n    }\n\n    /// Calculates the distance between two pointers. The returned value is in\n    /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.\n    ///\n    /// This function is the inverse of [`offset`].\n    ///\n    /// [`offset`]: #method.offset\n    /// [`wrapping_offset_from`]: #method.wrapping_offset_from\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and other pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The distance between the pointers, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The distance between the pointers, in bytes, must be an exact multiple\n    ///   of the size of `T`.\n    ///\n    /// * The distance being in bounds cannot rely on \"wrapping around\" the address space.\n    ///\n    /// The compiler and standard library generally try to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `ptr_into_vec.offset_from(vec.as_ptr())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using [`wrapping_offset_from`] instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Panics\n    ///\n    /// This function panics if `T` is a Zero-Sized Type (\"ZST\").\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(ptr_offset_from)]\n    ///\n    /// let a = [0; 5];\n    /// let ptr1: *const i32 = &a[1];\n    /// let ptr2: *const i32 = &a[3];\n    /// unsafe {\n    ///     assert_eq!(ptr2.offset_from(ptr1), 2);\n    ///     assert_eq!(ptr1.offset_from(ptr2), -2);\n    ///     assert_eq!(ptr1.offset(2), ptr2);\n    ///     assert_eq!(ptr2.offset(-2), ptr1);\n    /// }\n    /// ```\n    #[unstable(feature = \"ptr_offset_from\", issue = \"41079\")]\n    #[inline]\n    pub unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {\n        let pointee_size = mem::size_of::<T>();\n        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);\n\n        // This is the same sequence that Clang emits for pointer subtraction.\n        // It can be neither `nsw` nor `nuw` because the input is treated as\n        // unsigned but then the output is treated as signed, so neither works.\n        let d = isize::wrapping_sub(self as _, origin as _);\n        intrinsics::exact_div(d, pointee_size as _)\n    }\n\n    /// Calculates the distance between two pointers. The returned value is in\n    /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.\n    ///\n    /// If the address different between the two pointers is not a multiple of\n    /// `mem::size_of::<T>()` then the result of the division is rounded towards\n    /// zero.\n    ///\n    /// Though this method is safe for any two pointers, note that its result\n    /// will be mostly useless if the two pointers aren't into the same allocated\n    /// object, for example if they point to two different local variables.\n    ///\n    /// # Panics\n    ///\n    /// This function panics if `T` is a zero-sized type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(ptr_wrapping_offset_from)]\n    ///\n    /// let a = [0; 5];\n    /// let ptr1: *const i32 = &a[1];\n    /// let ptr2: *const i32 = &a[3];\n    /// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);\n    /// assert_eq!(ptr1.wrapping_offset_from(ptr2), -2);\n    /// assert_eq!(ptr1.wrapping_offset(2), ptr2);\n    /// assert_eq!(ptr2.wrapping_offset(-2), ptr1);\n    ///\n    /// let ptr1: *const i32 = 3 as _;\n    /// let ptr2: *const i32 = 13 as _;\n    /// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);\n    /// ```\n    #[unstable(feature = \"ptr_wrapping_offset_from\", issue = \"41079\")]\n    #[inline]\n    pub fn wrapping_offset_from(self, origin: *const T) -> isize where T: Sized {\n        let pointee_size = mem::size_of::<T>();\n        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);\n\n        let d = isize::wrapping_sub(self as _, origin as _);\n        d.wrapping_div(pointee_size as _)\n    }\n\n    /// Calculates the offset from a pointer (convenience for `.offset(count as isize)`).\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum must fit in a `usize`.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"123\";\n    /// let ptr: *const u8 = s.as_ptr();\n    ///\n    /// unsafe {\n    ///     println!(\"{}\", *ptr.add(1) as char);\n    ///     println!(\"{}\", *ptr.add(2) as char);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn add(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.offset(count as isize)\n    }\n\n    /// Calculates the offset from a pointer (convenience for\n    /// `.offset((count as isize).wrapping_neg())`).\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset cannot exceed `isize::MAX` **bytes**.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum must fit in a usize.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len()).sub(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"123\";\n    ///\n    /// unsafe {\n    ///     let end: *const u8 = s.as_ptr().add(3);\n    ///     println!(\"{}\", *end.sub(1) as char);\n    ///     println!(\"{}\", *end.sub(2) as char);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn sub(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.offset((count as isize).wrapping_neg())\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    /// (convenience for `.wrapping_offset(count as isize)`)\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    ///\n    /// Always use `.add(count)` instead when possible, because `add`\n    /// allows the compiler to optimize better.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements\n    /// let data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *const u8 = data.as_ptr();\n    /// let step = 2;\n    /// let end_rounded_up = ptr.wrapping_add(6);\n    ///\n    /// // This loop prints \"1, 3, 5, \"\n    /// while ptr != end_rounded_up {\n    ///     unsafe {\n    ///         print!(\"{}, \", *ptr);\n    ///     }\n    ///     ptr = ptr.wrapping_add(step);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub fn wrapping_add(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.wrapping_offset(count as isize)\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    /// (convenience for `.wrapping_offset((count as isize).wrapping_sub())`)\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    ///\n    /// Always use `.sub(count)` instead when possible, because `sub`\n    /// allows the compiler to optimize better.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements (backwards)\n    /// let data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *const u8 = data.as_ptr();\n    /// let start_rounded_down = ptr.wrapping_sub(2);\n    /// ptr = ptr.wrapping_add(4);\n    /// let step = 2;\n    /// // This loop prints \"5, 3, 1, \"\n    /// while ptr != start_rounded_down {\n    ///     unsafe {\n    ///         print!(\"{}, \", *ptr);\n    ///     }\n    ///     ptr = ptr.wrapping_sub(step);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub fn wrapping_sub(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.wrapping_offset((count as isize).wrapping_neg())\n    }\n\n    /// Reads the value from `self` without moving it. This leaves the\n    /// memory in `self` unchanged.\n    ///\n    /// See [`ptr::read`] for safety concerns and examples.\n    ///\n    /// [`ptr::read`]: ./ptr/fn.read.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read(self) -> T\n        where T: Sized,\n    {\n        read(self)\n    }\n\n    /// Performs a volatile read of the value from `self` without moving it. This\n    /// leaves the memory in `self` unchanged.\n    ///\n    /// Volatile operations are intended to act on I/O memory, and are guaranteed\n    /// to not be elided or reordered by the compiler across other volatile\n    /// operations.\n    ///\n    /// See [`ptr::read_volatile`] for safety concerns and examples.\n    ///\n    /// [`ptr::read_volatile`]: ./ptr/fn.read_volatile.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read_volatile(self) -> T\n        where T: Sized,\n    {\n        read_volatile(self)\n    }\n\n    /// Reads the value from `self` without moving it. This leaves the\n    /// memory in `self` unchanged.\n    ///\n    /// Unlike `read`, the pointer may be unaligned.\n    ///\n    /// See [`ptr::read_unaligned`] for safety concerns and examples.\n    ///\n    /// [`ptr::read_unaligned`]: ./ptr/fn.read_unaligned.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read_unaligned(self) -> T\n        where T: Sized,\n    {\n        read_unaligned(self)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source\n    /// and destination may overlap.\n    ///\n    /// NOTE: this has the *same* argument order as [`ptr::copy`].\n    ///\n    /// See [`ptr::copy`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy`]: ./ptr/fn.copy.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_to(self, dest: *mut T, count: usize)\n        where T: Sized,\n    {\n        copy(self, dest, count)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source\n    /// and destination may *not* overlap.\n    ///\n    /// NOTE: this has the *same* argument order as [`ptr::copy_nonoverlapping`].\n    ///\n    /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy_nonoverlapping`]: ./ptr/fn.copy_nonoverlapping.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize)\n        where T: Sized,\n    {\n        copy_nonoverlapping(self, dest, count)\n    }\n\n    /// Computes the offset that needs to be applied to the pointer in order to make it aligned to\n    /// `align`.\n    ///\n    /// If it is not possible to align the pointer, the implementation returns\n    /// `usize::max_value()`.\n    ///\n    /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be\n    /// used with the `offset` or `offset_to` methods.\n    ///\n    /// There are no guarantees whatsover that offsetting the pointer will not overflow or go\n    /// beyond the allocation that the pointer points into. It is up to the caller to ensure that\n    /// the returned offset is correct in all terms other than alignment.\n    ///\n    /// # Panics\n    ///\n    /// The function panics if `align` is not a power-of-two.\n    ///\n    /// # Examples\n    ///\n    /// Accessing adjacent `u8` as `u16`\n    ///\n    /// ```\n    /// # #![feature(align_offset)]\n    /// # fn foo(n: usize) {\n    /// # use std::mem::align_of;\n    /// # unsafe {\n    /// let x = [5u8, 6u8, 7u8, 8u8, 9u8];\n    /// let ptr = &x[n] as *const u8;\n    /// let offset = ptr.align_offset(align_of::<u16>());\n    /// if offset < x.len() - n - 1 {\n    ///     let u16_ptr = ptr.add(offset) as *const u16;\n    ///     assert_ne!(*u16_ptr, 500);\n    /// } else {\n    ///     // while the pointer can be aligned via `offset`, it would point\n    ///     // outside the allocation\n    /// }\n    /// # } }\n    /// ```\n    #[unstable(feature = \"align_offset\", issue = \"44488\")]\n    pub fn align_offset(self, align: usize) -> usize where T: Sized {\n        if !align.is_power_of_two() {\n            panic!(\"align_offset: align is not a power-of-two\");\n        }\n        unsafe {\n            align_offset(self, align)\n        }\n    }\n}\n\n\n#[lang = \"mut_ptr\"]\nimpl<T: ?Sized> *mut T {\n    /// Returns `true` if the pointer is null.\n    ///\n    /// Note that unsized types have many possible null pointers, as only the\n    /// raw data pointer is considered, not their length, vtable, etc.\n    /// Therefore, two pointers that are null may still not compare equal to\n    /// each other.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = [1, 2, 3];\n    /// let ptr: *mut u32 = s.as_mut_ptr();\n    /// assert!(!ptr.is_null());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_null(self) -> bool {\n        // Compare via a cast to a thin pointer, so fat pointers are only\n        // considering their \"data\" part for null-ness.\n        (self as *mut u8) == null_mut()\n    }\n\n    /// Returns `None` if the pointer is null, or else returns a reference to\n    /// the value wrapped in `Some`.\n    ///\n    /// # Safety\n    ///\n    /// While this method and its mutable counterpart are useful for\n    /// null-safety, it is important to note that this is still an unsafe\n    /// operation because the returned value could be pointing to invalid\n    /// memory.\n    ///\n    /// Additionally, the lifetime `'a` returned is arbitrarily chosen and does\n    /// not necessarily reflect the actual lifetime of the data.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let ptr: *mut u8 = &mut 10u8 as *mut u8;\n    ///\n    /// unsafe {\n    ///     if let Some(val_back) = ptr.as_ref() {\n    ///         println!(\"We got back the value: {}!\", val_back);\n    ///     }\n    /// }\n    /// ```\n    ///\n    /// # Null-unchecked version\n    ///\n    /// If you are sure the pointer can never be null and are looking for some kind of\n    /// `as_ref_unchecked` that returns the `&T` instead of `Option<&T>, know that you can\n    /// dereference the pointer directly.\n    ///\n    /// ```\n    /// let ptr: *mut u8 = &mut 10u8 as *mut u8;\n    ///\n    /// unsafe {\n    ///     let val_back = &*ptr;\n    ///     println!(\"We got back the value: {}!\", val_back);\n    /// }\n    /// ```\n    #[stable(feature = \"ptr_as_ref\", since = \"1.9.0\")]\n    #[inline]\n    pub unsafe fn as_ref<'a>(self) -> Option<&'a T> {\n        if self.is_null() {\n            None\n        } else {\n            Some(&*self)\n        }\n    }\n\n    /// Calculates the offset from a pointer.\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum, **in bytes** must fit in a usize.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = [1, 2, 3];\n    /// let ptr: *mut u32 = s.as_mut_ptr();\n    ///\n    /// unsafe {\n    ///     println!(\"{}\", *ptr.offset(1));\n    ///     println!(\"{}\", *ptr.offset(2));\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub unsafe fn offset(self, count: isize) -> *mut T where T: Sized {\n        intrinsics::offset(self, count) as *mut T\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    /// In particular, the resulting pointer may *not* be used to access a\n    /// different allocated object than the one `self` points to. In other\n    /// words, `x.wrapping_offset(y.wrapping_offset_from(x))` is\n    /// *not* the same as `y`, and dereferencing it is undefined behavior\n    /// unless `x` and `y` point into the same allocated object.\n    ///\n    /// Always use `.offset(count)` instead when possible, because `offset`\n    /// allows the compiler to optimize better.  If you need to cross object\n    /// boundaries, cast the pointer to an integer and do the arithmetic there.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements\n    /// let mut data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *mut u8 = data.as_mut_ptr();\n    /// let step = 2;\n    /// let end_rounded_up = ptr.wrapping_offset(6);\n    ///\n    /// while ptr != end_rounded_up {\n    ///     unsafe {\n    ///         *ptr = 0;\n    ///     }\n    ///     ptr = ptr.wrapping_offset(step);\n    /// }\n    /// assert_eq!(&data, &[0, 2, 0, 4, 0]);\n    /// ```\n    #[stable(feature = \"ptr_wrapping_offset\", since = \"1.16.0\")]\n    #[inline]\n    pub fn wrapping_offset(self, count: isize) -> *mut T where T: Sized {\n        unsafe {\n            intrinsics::arith_offset(self, count) as *mut T\n        }\n    }\n\n    /// Returns `None` if the pointer is null, or else returns a mutable\n    /// reference to the value wrapped in `Some`.\n    ///\n    /// # Safety\n    ///\n    /// As with `as_ref`, this is unsafe because it cannot verify the validity\n    /// of the returned pointer, nor can it ensure that the lifetime `'a`\n    /// returned is indeed a valid lifetime for the contained data.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = [1, 2, 3];\n    /// let ptr: *mut u32 = s.as_mut_ptr();\n    /// let first_value = unsafe { ptr.as_mut().unwrap() };\n    /// *first_value = 4;\n    /// println!(\"{:?}\", s); // It'll print: \"[4, 2, 3]\".\n    /// ```\n    #[stable(feature = \"ptr_as_ref\", since = \"1.9.0\")]\n    #[inline]\n    pub unsafe fn as_mut<'a>(self) -> Option<&'a mut T> {\n        if self.is_null() {\n            None\n        } else {\n            Some(&mut *self)\n        }\n    }\n\n    /// Calculates the distance between two pointers. The returned value is in\n    /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.\n    ///\n    /// This function is the inverse of [`offset`].\n    ///\n    /// [`offset`]: #method.offset-1\n    /// [`wrapping_offset_from`]: #method.wrapping_offset_from-1\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and other pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The distance between the pointers, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The distance between the pointers, in bytes, must be an exact multiple\n    ///   of the size of `T`.\n    ///\n    /// * The distance being in bounds cannot rely on \"wrapping around\" the address space.\n    ///\n    /// The compiler and standard library generally try to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `ptr_into_vec.offset_from(vec.as_ptr())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using [`wrapping_offset_from`] instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Panics\n    ///\n    /// This function panics if `T` is a Zero-Sized Type (\"ZST\").\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(ptr_offset_from)]\n    ///\n    /// let mut a = [0; 5];\n    /// let ptr1: *mut i32 = &mut a[1];\n    /// let ptr2: *mut i32 = &mut a[3];\n    /// unsafe {\n    ///     assert_eq!(ptr2.offset_from(ptr1), 2);\n    ///     assert_eq!(ptr1.offset_from(ptr2), -2);\n    ///     assert_eq!(ptr1.offset(2), ptr2);\n    ///     assert_eq!(ptr2.offset(-2), ptr1);\n    /// }\n    /// ```\n    #[unstable(feature = \"ptr_offset_from\", issue = \"41079\")]\n    #[inline]\n    pub unsafe fn offset_from(self, origin: *const T) -> isize where T: Sized {\n        (self as *const T).offset_from(origin)\n    }\n\n    /// Calculates the distance between two pointers. The returned value is in\n    /// units of T: the distance in bytes is divided by `mem::size_of::<T>()`.\n    ///\n    /// If the address different between the two pointers is not a multiple of\n    /// `mem::size_of::<T>()` then the result of the division is rounded towards\n    /// zero.\n    ///\n    /// Though this method is safe for any two pointers, note that its result\n    /// will be mostly useless if the two pointers aren't into the same allocated\n    /// object, for example if they point to two different local variables.\n    ///\n    /// # Panics\n    ///\n    /// This function panics if `T` is a zero-sized type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(ptr_wrapping_offset_from)]\n    ///\n    /// let mut a = [0; 5];\n    /// let ptr1: *mut i32 = &mut a[1];\n    /// let ptr2: *mut i32 = &mut a[3];\n    /// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);\n    /// assert_eq!(ptr1.wrapping_offset_from(ptr2), -2);\n    /// assert_eq!(ptr1.wrapping_offset(2), ptr2);\n    /// assert_eq!(ptr2.wrapping_offset(-2), ptr1);\n    ///\n    /// let ptr1: *mut i32 = 3 as _;\n    /// let ptr2: *mut i32 = 13 as _;\n    /// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);\n    /// ```\n    #[unstable(feature = \"ptr_wrapping_offset_from\", issue = \"41079\")]\n    #[inline]\n    pub fn wrapping_offset_from(self, origin: *const T) -> isize where T: Sized {\n        (self as *const T).wrapping_offset_from(origin)\n    }\n\n    /// Calculates the offset from a pointer (convenience for `.offset(count as isize)`).\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset, **in bytes**, cannot overflow an `isize`.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum must fit in a `usize`.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"123\";\n    /// let ptr: *const u8 = s.as_ptr();\n    ///\n    /// unsafe {\n    ///     println!(\"{}\", *ptr.add(1) as char);\n    ///     println!(\"{}\", *ptr.add(2) as char);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn add(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.offset(count as isize)\n    }\n\n    /// Calculates the offset from a pointer (convenience for\n    /// `.offset((count as isize).wrapping_neg())`).\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// If any of the following conditions are violated, the result is Undefined\n    /// Behavior:\n    ///\n    /// * Both the starting and resulting pointer must be either in bounds or one\n    ///   byte past the end of the same allocated object.\n    ///\n    /// * The computed offset cannot exceed `isize::MAX` **bytes**.\n    ///\n    /// * The offset being in bounds cannot rely on \"wrapping around\" the address\n    ///   space. That is, the infinite-precision sum must fit in a usize.\n    ///\n    /// The compiler and standard library generally tries to ensure allocations\n    /// never reach a size where an offset is a concern. For instance, `Vec`\n    /// and `Box` ensure they never allocate more than `isize::MAX` bytes, so\n    /// `vec.as_ptr().add(vec.len()).sub(vec.len())` is always safe.\n    ///\n    /// Most platforms fundamentally can't even construct such an allocation.\n    /// For instance, no known 64-bit platform can ever serve a request\n    /// for 2<sup>63</sup> bytes due to page-table limitations or splitting the address space.\n    /// However, some 32-bit and 16-bit platforms may successfully serve a request for\n    /// more than `isize::MAX` bytes with things like Physical Address\n    /// Extension. As such, memory acquired directly from allocators or memory\n    /// mapped files *may* be too large to handle with this function.\n    ///\n    /// Consider using `wrapping_offset` instead if these constraints are\n    /// difficult to satisfy. The only advantage of this method is that it\n    /// enables more aggressive compiler optimizations.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"123\";\n    ///\n    /// unsafe {\n    ///     let end: *const u8 = s.as_ptr().add(3);\n    ///     println!(\"{}\", *end.sub(1) as char);\n    ///     println!(\"{}\", *end.sub(2) as char);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn sub(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.offset((count as isize).wrapping_neg())\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    /// (convenience for `.wrapping_offset(count as isize)`)\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    ///\n    /// Always use `.add(count)` instead when possible, because `add`\n    /// allows the compiler to optimize better.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements\n    /// let data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *const u8 = data.as_ptr();\n    /// let step = 2;\n    /// let end_rounded_up = ptr.wrapping_add(6);\n    ///\n    /// // This loop prints \"1, 3, 5, \"\n    /// while ptr != end_rounded_up {\n    ///     unsafe {\n    ///         print!(\"{}, \", *ptr);\n    ///     }\n    ///     ptr = ptr.wrapping_add(step);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub fn wrapping_add(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.wrapping_offset(count as isize)\n    }\n\n    /// Calculates the offset from a pointer using wrapping arithmetic.\n    /// (convenience for `.wrapping_offset((count as isize).wrapping_sub())`)\n    ///\n    /// `count` is in units of T; e.g. a `count` of 3 represents a pointer\n    /// offset of `3 * size_of::<T>()` bytes.\n    ///\n    /// # Safety\n    ///\n    /// The resulting pointer does not need to be in bounds, but it is\n    /// potentially hazardous to dereference (which requires `unsafe`).\n    ///\n    /// Always use `.sub(count)` instead when possible, because `sub`\n    /// allows the compiler to optimize better.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // Iterate using a raw pointer in increments of two elements (backwards)\n    /// let data = [1u8, 2, 3, 4, 5];\n    /// let mut ptr: *const u8 = data.as_ptr();\n    /// let start_rounded_down = ptr.wrapping_sub(2);\n    /// ptr = ptr.wrapping_add(4);\n    /// let step = 2;\n    /// // This loop prints \"5, 3, 1, \"\n    /// while ptr != start_rounded_down {\n    ///     unsafe {\n    ///         print!(\"{}, \", *ptr);\n    ///     }\n    ///     ptr = ptr.wrapping_sub(step);\n    /// }\n    /// ```\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub fn wrapping_sub(self, count: usize) -> Self\n        where T: Sized,\n    {\n        self.wrapping_offset((count as isize).wrapping_neg())\n    }\n\n    /// Reads the value from `self` without moving it. This leaves the\n    /// memory in `self` unchanged.\n    ///\n    /// See [`ptr::read`] for safety concerns and examples.\n    ///\n    /// [`ptr::read`]: ./ptr/fn.read.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read(self) -> T\n        where T: Sized,\n    {\n        read(self)\n    }\n\n    /// Performs a volatile read of the value from `self` without moving it. This\n    /// leaves the memory in `self` unchanged.\n    ///\n    /// Volatile operations are intended to act on I/O memory, and are guaranteed\n    /// to not be elided or reordered by the compiler across other volatile\n    /// operations.\n    ///\n    /// See [`ptr::read_volatile`] for safety concerns and examples.\n    ///\n    /// [`ptr::read_volatile`]: ./ptr/fn.read_volatile.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read_volatile(self) -> T\n        where T: Sized,\n    {\n        read_volatile(self)\n    }\n\n    /// Reads the value from `self` without moving it. This leaves the\n    /// memory in `self` unchanged.\n    ///\n    /// Unlike `read`, the pointer may be unaligned.\n    ///\n    /// See [`ptr::read_unaligned`] for safety concerns and examples.\n    ///\n    /// [`ptr::read_unaligned`]: ./ptr/fn.read_unaligned.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn read_unaligned(self) -> T\n        where T: Sized,\n    {\n        read_unaligned(self)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source\n    /// and destination may overlap.\n    ///\n    /// NOTE: this has the *same* argument order as [`ptr::copy`].\n    ///\n    /// See [`ptr::copy`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy`]: ./ptr/fn.copy.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_to(self, dest: *mut T, count: usize)\n        where T: Sized,\n    {\n        copy(self, dest, count)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `self` to `dest`. The source\n    /// and destination may *not* overlap.\n    ///\n    /// NOTE: this has the *same* argument order as [`ptr::copy_nonoverlapping`].\n    ///\n    /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy_nonoverlapping`]: ./ptr/fn.copy_nonoverlapping.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize)\n        where T: Sized,\n    {\n        copy_nonoverlapping(self, dest, count)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `src` to `self`. The source\n    /// and destination may overlap.\n    ///\n    /// NOTE: this has the *opposite* argument order of [`ptr::copy`].\n    ///\n    /// See [`ptr::copy`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy`]: ./ptr/fn.copy.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_from(self, src: *const T, count: usize)\n        where T: Sized,\n    {\n        copy(src, self, count)\n    }\n\n    /// Copies `count * size_of<T>` bytes from `src` to `self`. The source\n    /// and destination may *not* overlap.\n    ///\n    /// NOTE: this has the *opposite* argument order of [`ptr::copy_nonoverlapping`].\n    ///\n    /// See [`ptr::copy_nonoverlapping`] for safety concerns and examples.\n    ///\n    /// [`ptr::copy_nonoverlapping`]: ./ptr/fn.copy_nonoverlapping.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn copy_from_nonoverlapping(self, src: *const T, count: usize)\n        where T: Sized,\n    {\n        copy_nonoverlapping(src, self, count)\n    }\n\n    /// Executes the destructor (if any) of the pointed-to value.\n    ///\n    /// See [`ptr::drop_in_place`] for safety concerns and examples.\n    ///\n    /// [`ptr::drop_in_place`]: ./ptr/fn.drop_in_place.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn drop_in_place(self) {\n        drop_in_place(self)\n    }\n\n    /// Overwrites a memory location with the given value without reading or\n    /// dropping the old value.\n    ///\n    /// See [`ptr::write`] for safety concerns and examples.\n    ///\n    /// [`ptr::write`]: ./ptr/fn.write.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn write(self, val: T)\n        where T: Sized,\n    {\n        write(self, val)\n    }\n\n    /// Invokes memset on the specified pointer, setting `count * size_of::<T>()`\n    /// bytes of memory starting at `self` to `val`.\n    ///\n    /// See [`ptr::write_bytes`] for safety concerns and examples.\n    ///\n    /// [`ptr::write_bytes`]: ./ptr/fn.write_bytes.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn write_bytes(self, val: u8, count: usize)\n        where T: Sized,\n    {\n        write_bytes(self, val, count)\n    }\n\n    /// Performs a volatile write of a memory location with the given value without\n    /// reading or dropping the old value.\n    ///\n    /// Volatile operations are intended to act on I/O memory, and are guaranteed\n    /// to not be elided or reordered by the compiler across other volatile\n    /// operations.\n    ///\n    /// See [`ptr::write_volatile`] for safety concerns and examples.\n    ///\n    /// [`ptr::write_volatile`]: ./ptr/fn.write_volatile.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn write_volatile(self, val: T)\n        where T: Sized,\n    {\n        write_volatile(self, val)\n    }\n\n    /// Overwrites a memory location with the given value without reading or\n    /// dropping the old value.\n    ///\n    /// Unlike `write`, the pointer may be unaligned.\n    ///\n    /// See [`ptr::write_unaligned`] for safety concerns and examples.\n    ///\n    /// [`ptr::write_unaligned`]: ./ptr/fn.write_unaligned.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn write_unaligned(self, val: T)\n        where T: Sized,\n    {\n        write_unaligned(self, val)\n    }\n\n    /// Replaces the value at `self` with `src`, returning the old\n    /// value, without dropping either.\n    ///\n    /// See [`ptr::replace`] for safety concerns and examples.\n    ///\n    /// [`ptr::replace`]: ./ptr/fn.replace.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn replace(self, src: T) -> T\n        where T: Sized,\n    {\n        replace(self, src)\n    }\n\n    /// Swaps the values at two mutable locations of the same type, without\n    /// deinitializing either. They may overlap, unlike `mem::swap` which is\n    /// otherwise equivalent.\n    ///\n    /// See [`ptr::swap`] for safety concerns and examples.\n    ///\n    /// [`ptr::swap`]: ./ptr/fn.swap.html\n    #[stable(feature = \"pointer_methods\", since = \"1.26.0\")]\n    #[inline]\n    pub unsafe fn swap(self, with: *mut T)\n        where T: Sized,\n    {\n        swap(self, with)\n    }\n\n    /// Computes the offset that needs to be applied to the pointer in order to make it aligned to\n    /// `align`.\n    ///\n    /// If it is not possible to align the pointer, the implementation returns\n    /// `usize::max_value()`.\n    ///\n    /// The offset is expressed in number of `T` elements, and not bytes. The value returned can be\n    /// used with the `offset` or `offset_to` methods.\n    ///\n    /// There are no guarantees whatsover that offsetting the pointer will not overflow or go\n    /// beyond the allocation that the pointer points into. It is up to the caller to ensure that\n    /// the returned offset is correct in all terms other than alignment.\n    ///\n    /// # Panics\n    ///\n    /// The function panics if `align` is not a power-of-two.\n    ///\n    /// # Examples\n    ///\n    /// Accessing adjacent `u8` as `u16`\n    ///\n    /// ```\n    /// # #![feature(align_offset)]\n    /// # fn foo(n: usize) {\n    /// # use std::mem::align_of;\n    /// # unsafe {\n    /// let x = [5u8, 6u8, 7u8, 8u8, 9u8];\n    /// let ptr = &x[n] as *const u8;\n    /// let offset = ptr.align_offset(align_of::<u16>());\n    /// if offset < x.len() - n - 1 {\n    ///     let u16_ptr = ptr.add(offset) as *const u16;\n    ///     assert_ne!(*u16_ptr, 500);\n    /// } else {\n    ///     // while the pointer can be aligned via `offset`, it would point\n    ///     // outside the allocation\n    /// }\n    /// # } }\n    /// ```\n    #[unstable(feature = \"align_offset\", issue = \"44488\")]\n    pub fn align_offset(self, align: usize) -> usize where T: Sized {\n        if !align.is_power_of_two() {\n            panic!(\"align_offset: align is not a power-of-two\");\n        }\n        unsafe {\n            align_offset(self, align)\n        }\n    }\n}\n\n/// Align pointer `p`.\n///\n/// Calculate offset (in terms of elements of `stride` stride) that has to be applied\n/// to pointer `p` so that pointer `p` would get aligned to `a`.\n///\n/// Note: This implementation has been carefully tailored to not panic. It is UB for this to panic.\n/// The only real change that can be made here is change of `INV_TABLE_MOD_16` and associated\n/// constants.\n///\n/// If we ever decide to make it possible to call the intrinsic with `a` that is not a\n/// power-of-two, it will probably be more prudent to just change to a naive implementation rather\n/// than trying to adapt this to accommodate that change.\n///\n/// Any questions go to @nagisa.\n#[lang=\"align_offset\"]\npub(crate) unsafe fn align_offset<T: Sized>(p: *const T, a: usize) -> usize {\n    /// Calculate multiplicative modular inverse of `x` modulo `m`.\n    ///\n    /// This implementation is tailored for align_offset and has following preconditions:\n    ///\n    /// * `m` is a power-of-two;\n    /// * `x < m`; (if `x \u2265 m`, pass in `x % m` instead)\n    ///\n    /// Implementation of this function shall not panic. Ever.\n    #[inline]\n    fn mod_inv(x: usize, m: usize) -> usize {\n        /// Multiplicative modular inverse table modulo 2\u2074 = 16.\n        ///\n        /// Note, that this table does not contain values where inverse does not exist (i.e. for\n        /// `0\u207b\u00b9 mod 16`, `2\u207b\u00b9 mod 16`, etc.)\n        const INV_TABLE_MOD_16: [u8; 8] = [1, 11, 13, 7, 9, 3, 5, 15];\n        /// Modulo for which the `INV_TABLE_MOD_16` is intended.\n        const INV_TABLE_MOD: usize = 16;\n        /// INV_TABLE_MOD\u00b2\n        const INV_TABLE_MOD_SQUARED: usize = INV_TABLE_MOD * INV_TABLE_MOD;\n\n        let table_inverse = INV_TABLE_MOD_16[(x & (INV_TABLE_MOD - 1)) >> 1] as usize;\n        if m <= INV_TABLE_MOD {\n            table_inverse & (m - 1)\n        } else {\n            // We iterate \"up\" using the following formula:\n            //\n            // $$ xy \u2261 1 (mod 2\u207f) \u2192 xy (2 - xy) \u2261 1 (mod 2\u00b2\u207f) $$\n            //\n            // until 2\u00b2\u207f \u2265 m. Then we can reduce to our desired `m` by taking the result `mod m`.\n            let mut inverse = table_inverse;\n            let mut going_mod = INV_TABLE_MOD_SQUARED;\n            loop {\n                // y = y * (2 - xy) mod n\n                //\n                // Note, that we use wrapping operations here intentionally \u2013 the original formula\n                // uses e.g. subtraction `mod n`. It is entirely fine to do them `mod\n                // usize::max_value()` instead, because we take the result `mod n` at the end\n                // anyway.\n                inverse = inverse.wrapping_mul(\n                    2usize.wrapping_sub(x.wrapping_mul(inverse))\n                ) & (going_mod - 1);\n                if going_mod > m {\n                    return inverse & (m - 1);\n                }\n                going_mod = going_mod.wrapping_mul(going_mod);\n            }\n        }\n    }\n\n    let stride = ::mem::size_of::<T>();\n    let a_minus_one = a.wrapping_sub(1);\n    let pmoda = p as usize & a_minus_one;\n\n    if pmoda == 0 {\n        // Already aligned. Yay!\n        return 0;\n    }\n\n    if stride <= 1 {\n        return if stride == 0 {\n            // If the pointer is not aligned, and the element is zero-sized, then no amount of\n            // elements will ever align the pointer.\n            !0\n        } else {\n            a.wrapping_sub(pmoda)\n        };\n    }\n\n    let smoda = stride & a_minus_one;\n    // a is power-of-two so cannot be 0. stride = 0 is handled above.\n    let gcdpow = intrinsics::cttz_nonzero(stride).min(intrinsics::cttz_nonzero(a));\n    let gcd = 1usize << gcdpow;\n\n    if p as usize & (gcd - 1) == 0 {\n        // This branch solves for the following linear congruence equation:\n        //\n        // $$ p + so \u2261 0 mod a $$\n        //\n        // $p$ here is the pointer value, $s$ \u2013 stride of `T`, $o$ offset in `T`s, and $a$ \u2013 the\n        // requested alignment.\n        //\n        // g = gcd(a, s)\n        // o = (a - (p mod a))/g * ((s/g)\u207b\u00b9 mod a)\n        //\n        // The first term is \u201cthe relative alignment of p to a\u201d, the second term is \u201chow does\n        // incrementing p by s bytes change the relative alignment of p\u201d. Division by `g` is\n        // necessary to make this equation well formed if $a$ and $s$ are not co-prime.\n        //\n        // Furthermore, the result produced by this solution is not \u201cminimal\u201d, so it is necessary\n        // to take the result $o mod lcm(s, a)$. We can replace $lcm(s, a)$ with just a $a / g$.\n        let j = a.wrapping_sub(pmoda) >> gcdpow;\n        let k = smoda >> gcdpow;\n        return intrinsics::unchecked_rem(j.wrapping_mul(mod_inv(k, a)), a >> gcdpow);\n    }\n\n    // Cannot be aligned at all.\n    usize::max_value()\n}\n\n\n\n// Equality for pointers\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> PartialEq for *const T {\n    #[inline]\n    fn eq(&self, other: &*const T) -> bool { *self == *other }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Eq for *const T {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> PartialEq for *mut T {\n    #[inline]\n    fn eq(&self, other: &*mut T) -> bool { *self == *other }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Eq for *mut T {}\n\n/// Compare raw pointers for equality.\n///\n/// This is the same as using the `==` operator, but less generic:\n/// the arguments have to be `*const T` raw pointers,\n/// not anything that implements `PartialEq`.\n///\n/// This can be used to compare `&T` references (which coerce to `*const T` implicitly)\n/// by their address rather than comparing the values they point to\n/// (which is what the `PartialEq for &T` implementation does).\n///\n/// # Examples\n///\n/// ```\n/// use std::ptr;\n///\n/// let five = 5;\n/// let other_five = 5;\n/// let five_ref = &five;\n/// let same_five_ref = &five;\n/// let other_five_ref = &other_five;\n///\n/// assert!(five_ref == same_five_ref);\n/// assert!(five_ref == other_five_ref);\n///\n/// assert!(ptr::eq(five_ref, same_five_ref));\n/// assert!(!ptr::eq(five_ref, other_five_ref));\n/// ```\n#[stable(feature = \"ptr_eq\", since = \"1.17.0\")]\n#[inline]\npub fn eq<T: ?Sized>(a: *const T, b: *const T) -> bool {\n    a == b\n}\n\n// Impls for function pointers\nmacro_rules! fnptr_impls_safety_abi {\n    ($FnTy: ty, $($Arg: ident),*) => {\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> PartialEq for $FnTy {\n            #[inline]\n            fn eq(&self, other: &Self) -> bool {\n                *self as usize == *other as usize\n            }\n        }\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> Eq for $FnTy {}\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> PartialOrd for $FnTy {\n            #[inline]\n            fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n                (*self as usize).partial_cmp(&(*other as usize))\n            }\n        }\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> Ord for $FnTy {\n            #[inline]\n            fn cmp(&self, other: &Self) -> Ordering {\n                (*self as usize).cmp(&(*other as usize))\n            }\n        }\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> hash::Hash for $FnTy {\n            fn hash<HH: hash::Hasher>(&self, state: &mut HH) {\n                state.write_usize(*self as usize)\n            }\n        }\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> fmt::Pointer for $FnTy {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                fmt::Pointer::fmt(&(*self as *const ()), f)\n            }\n        }\n\n        #[stable(feature = \"fnptr_impls\", since = \"1.4.0\")]\n        impl<Ret, $($Arg),*> fmt::Debug for $FnTy {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                fmt::Pointer::fmt(&(*self as *const ()), f)\n            }\n        }\n    }\n}\n\nmacro_rules! fnptr_impls_args {\n    ($($Arg: ident),+) => {\n        fnptr_impls_safety_abi! { extern \"Rust\" fn($($Arg),*) -> Ret, $($Arg),* }\n        fnptr_impls_safety_abi! { extern \"C\" fn($($Arg),*) -> Ret, $($Arg),* }\n        fnptr_impls_safety_abi! { extern \"C\" fn($($Arg),* , ...) -> Ret, $($Arg),* }\n        fnptr_impls_safety_abi! { unsafe extern \"Rust\" fn($($Arg),*) -> Ret, $($Arg),* }\n        fnptr_impls_safety_abi! { unsafe extern \"C\" fn($($Arg),*) -> Ret, $($Arg),* }\n        fnptr_impls_safety_abi! { unsafe extern \"C\" fn($($Arg),* , ...) -> Ret, $($Arg),* }\n    };\n    () => {\n        // No variadic functions with 0 parameters\n        fnptr_impls_safety_abi! { extern \"Rust\" fn() -> Ret, }\n        fnptr_impls_safety_abi! { extern \"C\" fn() -> Ret, }\n        fnptr_impls_safety_abi! { unsafe extern \"Rust\" fn() -> Ret, }\n        fnptr_impls_safety_abi! { unsafe extern \"C\" fn() -> Ret, }\n    };\n}\n\nfnptr_impls_args! { }\nfnptr_impls_args! { A }\nfnptr_impls_args! { A, B }\nfnptr_impls_args! { A, B, C }\nfnptr_impls_args! { A, B, C, D }\nfnptr_impls_args! { A, B, C, D, E }\nfnptr_impls_args! { A, B, C, D, E, F }\nfnptr_impls_args! { A, B, C, D, E, F, G }\nfnptr_impls_args! { A, B, C, D, E, F, G, H }\nfnptr_impls_args! { A, B, C, D, E, F, G, H, I }\nfnptr_impls_args! { A, B, C, D, E, F, G, H, I, J }\nfnptr_impls_args! { A, B, C, D, E, F, G, H, I, J, K }\nfnptr_impls_args! { A, B, C, D, E, F, G, H, I, J, K, L }\n\n// Comparison for pointers\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Ord for *const T {\n    #[inline]\n    fn cmp(&self, other: &*const T) -> Ordering {\n        if self < other {\n            Less\n        } else if self == other {\n            Equal\n        } else {\n            Greater\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> PartialOrd for *const T {\n    #[inline]\n    fn partial_cmp(&self, other: &*const T) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n\n    #[inline]\n    fn lt(&self, other: &*const T) -> bool { *self < *other }\n\n    #[inline]\n    fn le(&self, other: &*const T) -> bool { *self <= *other }\n\n    #[inline]\n    fn gt(&self, other: &*const T) -> bool { *self > *other }\n\n    #[inline]\n    fn ge(&self, other: &*const T) -> bool { *self >= *other }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Ord for *mut T {\n    #[inline]\n    fn cmp(&self, other: &*mut T) -> Ordering {\n        if self < other {\n            Less\n        } else if self == other {\n            Equal\n        } else {\n            Greater\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> PartialOrd for *mut T {\n    #[inline]\n    fn partial_cmp(&self, other: &*mut T) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n\n    #[inline]\n    fn lt(&self, other: &*mut T) -> bool { *self < *other }\n\n    #[inline]\n    fn le(&self, other: &*mut T) -> bool { *self <= *other }\n\n    #[inline]\n    fn gt(&self, other: &*mut T) -> bool { *self > *other }\n\n    #[inline]\n    fn ge(&self, other: &*mut T) -> bool { *self >= *other }\n}\n\n/// A wrapper around a raw non-null `*mut T` that indicates that the possessor\n/// of this wrapper owns the referent. Useful for building abstractions like\n/// `Box<T>`, `Vec<T>`, `String`, and `HashMap<K, V>`.\n///\n/// Unlike `*mut T`, `Unique<T>` behaves \"as if\" it were an instance of `T`.\n/// It implements `Send`/`Sync` if `T` is `Send`/`Sync`. It also implies\n/// the kind of strong aliasing guarantees an instance of `T` can expect:\n/// the referent of the pointer should not be modified without a unique path to\n/// its owning Unique.\n///\n/// If you're uncertain of whether it's correct to use `Unique` for your purposes,\n/// consider using `NonNull`, which has weaker semantics.\n///\n/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer\n/// is never dereferenced. This is so that enums may use this forbidden value\n/// as a discriminant -- `Option<Unique<T>>` has the same size as `Unique<T>`.\n/// However the pointer may still dangle if it isn't dereferenced.\n///\n/// Unlike `*mut T`, `Unique<T>` is covariant over `T`. This should always be correct\n/// for any type which upholds Unique's aliasing requirements.\n#[unstable(feature = \"ptr_internals\", issue = \"0\",\n           reason = \"use NonNull instead and consider PhantomData<T> \\\n                     (if you also use #[may_dangle]), Send, and/or Sync\")]\n#[doc(hidden)]\n#[repr(transparent)]\npub struct Unique<T: ?Sized> {\n    pointer: NonZero<*const T>,\n    // NOTE: this marker has no consequences for variance, but is necessary\n    // for dropck to understand that we logically own a `T`.\n    //\n    // For details, see:\n    // https://github.com/rust-lang/rfcs/blob/master/text/0769-sound-generic-drop.md#phantom-data\n    _marker: PhantomData<T>,\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> fmt::Debug for Unique<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&self.as_ptr(), f)\n    }\n}\n\n/// `Unique` pointers are `Send` if `T` is `Send` because the data they\n/// reference is unaliased. Note that this aliasing invariant is\n/// unenforced by the type system; the abstraction using the\n/// `Unique` must enforce it.\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nunsafe impl<T: Send + ?Sized> Send for Unique<T> { }\n\n/// `Unique` pointers are `Sync` if `T` is `Sync` because the data they\n/// reference is unaliased. Note that this aliasing invariant is\n/// unenforced by the type system; the abstraction using the\n/// `Unique` must enforce it.\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nunsafe impl<T: Sync + ?Sized> Sync for Unique<T> { }\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: Sized> Unique<T> {\n    /// Creates a new `Unique` that is dangling, but well-aligned.\n    ///\n    /// This is useful for initializing types which lazily allocate, like\n    /// `Vec::new` does.\n    ///\n    /// Note that the pointer value may potentially represent a valid pointer to\n    /// a `T`, which means this must not be used as a \"not yet initialized\"\n    /// sentinel value. Types that lazily allocate must track initialization by\n    /// some other means.\n    // FIXME: rename to dangling() to match NonNull?\n    pub const fn empty() -> Self {\n        unsafe {\n            Unique::new_unchecked(mem::align_of::<T>() as *mut T)\n        }\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> Unique<T> {\n    /// Creates a new `Unique`.\n    ///\n    /// # Safety\n    ///\n    /// `ptr` must be non-null.\n    pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {\n        Unique { pointer: NonZero(ptr as _), _marker: PhantomData }\n    }\n\n    /// Creates a new `Unique` if `ptr` is non-null.\n    pub fn new(ptr: *mut T) -> Option<Self> {\n        if !ptr.is_null() {\n            Some(Unique { pointer: NonZero(ptr as _), _marker: PhantomData })\n        } else {\n            None\n        }\n    }\n\n    /// Acquires the underlying `*mut` pointer.\n    pub fn as_ptr(self) -> *mut T {\n        self.pointer.0 as *mut T\n    }\n\n    /// Dereferences the content.\n    ///\n    /// The resulting lifetime is bound to self so this behaves \"as if\"\n    /// it were actually an instance of T that is getting borrowed. If a longer\n    /// (unbound) lifetime is needed, use `&*my_ptr.as_ptr()`.\n    pub unsafe fn as_ref(&self) -> &T {\n        &*self.as_ptr()\n    }\n\n    /// Mutably dereferences the content.\n    ///\n    /// The resulting lifetime is bound to self so this behaves \"as if\"\n    /// it were actually an instance of T that is getting borrowed. If a longer\n    /// (unbound) lifetime is needed, use `&mut *my_ptr.as_ptr()`.\n    pub unsafe fn as_mut(&mut self) -> &mut T {\n        &mut *self.as_ptr()\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> Clone for Unique<T> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> Copy for Unique<T> { }\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized, U: ?Sized> CoerceUnsized<Unique<U>> for Unique<T> where T: Unsize<U> { }\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized, U: ?Sized> DispatchFromDyn<Unique<U>> for Unique<T> where T: Unsize<U> { }\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> fmt::Pointer for Unique<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&self.as_ptr(), f)\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<'a, T: ?Sized> From<&'a mut T> for Unique<T> {\n    fn from(reference: &'a mut T) -> Self {\n        Unique { pointer: NonZero(reference as _), _marker: PhantomData }\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<'a, T: ?Sized> From<&'a T> for Unique<T> {\n    fn from(reference: &'a T) -> Self {\n        Unique { pointer: NonZero(reference as _), _marker: PhantomData }\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<'a, T: ?Sized> From<NonNull<T>> for Unique<T> {\n    fn from(p: NonNull<T>) -> Self {\n        Unique { pointer: p.pointer, _marker: PhantomData }\n    }\n}\n\n/// `*mut T` but non-zero and covariant.\n///\n/// This is often the correct thing to use when building data structures using\n/// raw pointers, but is ultimately more dangerous to use because of its additional\n/// properties. If you're not sure if you should use `NonNull<T>`, just use `*mut T`!\n///\n/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer\n/// is never dereferenced. This is so that enums may use this forbidden value\n/// as a discriminant -- `Option<NonNull<T>>` has the same size as `*mut T`.\n/// However the pointer may still dangle if it isn't dereferenced.\n///\n/// Unlike `*mut T`, `NonNull<T>` is covariant over `T`. If this is incorrect\n/// for your use case, you should include some PhantomData in your type to\n/// provide invariance, such as `PhantomData<Cell<T>>` or `PhantomData<&'a mut T>`.\n/// Usually this won't be necessary; covariance is correct for most safe abstractions,\n/// such as Box, Rc, Arc, Vec, and LinkedList. This is the case because they\n/// provide a public API that follows the normal shared XOR mutable rules of Rust.\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\n#[repr(transparent)]\npub struct NonNull<T: ?Sized> {\n    pointer: NonZero<*const T>,\n}\n\n/// `NonNull` pointers are not `Send` because the data they reference may be aliased.\n// NB: This impl is unnecessary, but should provide better error messages.\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> !Send for NonNull<T> { }\n\n/// `NonNull` pointers are not `Sync` because the data they reference may be aliased.\n// NB: This impl is unnecessary, but should provide better error messages.\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> !Sync for NonNull<T> { }\n\nimpl<T: Sized> NonNull<T> {\n    /// Creates a new `NonNull` that is dangling, but well-aligned.\n    ///\n    /// This is useful for initializing types which lazily allocate, like\n    /// `Vec::new` does.\n    ///\n    /// Note that the pointer value may potentially represent a valid pointer to\n    /// a `T`, which means this must not be used as a \"not yet initialized\"\n    /// sentinel value. Types that lazily allocate must track initialization by\n    /// some other means.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub fn dangling() -> Self {\n        unsafe {\n            let ptr = mem::align_of::<T>() as *mut T;\n            NonNull::new_unchecked(ptr)\n        }\n    }\n}\n\nimpl<T: ?Sized> NonNull<T> {\n    /// Creates a new `NonNull`.\n    ///\n    /// # Safety\n    ///\n    /// `ptr` must be non-null.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {\n        NonNull { pointer: NonZero(ptr as _) }\n    }\n\n    /// Creates a new `NonNull` if `ptr` is non-null.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub fn new(ptr: *mut T) -> Option<Self> {\n        if !ptr.is_null() {\n            Some(NonNull { pointer: NonZero(ptr as _) })\n        } else {\n            None\n        }\n    }\n\n    /// Acquires the underlying `*mut` pointer.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub fn as_ptr(self) -> *mut T {\n        self.pointer.0 as *mut T\n    }\n\n    /// Dereferences the content.\n    ///\n    /// The resulting lifetime is bound to self so this behaves \"as if\"\n    /// it were actually an instance of T that is getting borrowed. If a longer\n    /// (unbound) lifetime is needed, use `&*my_ptr.as_ptr()`.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub unsafe fn as_ref(&self) -> &T {\n        &*self.as_ptr()\n    }\n\n    /// Mutably dereferences the content.\n    ///\n    /// The resulting lifetime is bound to self so this behaves \"as if\"\n    /// it were actually an instance of T that is getting borrowed. If a longer\n    /// (unbound) lifetime is needed, use `&mut *my_ptr.as_ptr()`.\n    #[stable(feature = \"nonnull\", since = \"1.25.0\")]\n    #[inline]\n    pub unsafe fn as_mut(&mut self) -> &mut T {\n        &mut *self.as_ptr()\n    }\n\n    /// Cast to a pointer of another type\n    #[stable(feature = \"nonnull_cast\", since = \"1.27.0\")]\n    #[inline]\n    pub fn cast<U>(self) -> NonNull<U> {\n        unsafe {\n            NonNull::new_unchecked(self.as_ptr() as *mut U)\n        }\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> Clone for NonNull<T> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> Copy for NonNull<T> { }\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: ?Sized, U: ?Sized> CoerceUnsized<NonNull<U>> for NonNull<T> where T: Unsize<U> { }\n\n#[unstable(feature = \"dispatch_from_dyn\", issue = \"0\")]\nimpl<T: ?Sized, U: ?Sized> DispatchFromDyn<NonNull<U>> for NonNull<T> where T: Unsize<U> { }\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> fmt::Debug for NonNull<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&self.as_ptr(), f)\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> fmt::Pointer for NonNull<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&self.as_ptr(), f)\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> Eq for NonNull<T> {}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> PartialEq for NonNull<T> {\n    #[inline]\n    fn eq(&self, other: &Self) -> bool {\n        self.as_ptr() == other.as_ptr()\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> Ord for NonNull<T> {\n    #[inline]\n    fn cmp(&self, other: &Self) -> Ordering {\n        self.as_ptr().cmp(&other.as_ptr())\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> PartialOrd for NonNull<T> {\n    #[inline]\n    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {\n        self.as_ptr().partial_cmp(&other.as_ptr())\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: ?Sized> hash::Hash for NonNull<T> {\n    #[inline]\n    fn hash<H: hash::Hasher>(&self, state: &mut H) {\n        self.as_ptr().hash(state)\n    }\n}\n\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: ?Sized> From<Unique<T>> for NonNull<T> {\n    #[inline]\n    fn from(unique: Unique<T>) -> Self {\n        NonNull { pointer: unique.pointer }\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<'a, T: ?Sized> From<&'a mut T> for NonNull<T> {\n    #[inline]\n    fn from(reference: &'a mut T) -> Self {\n        NonNull { pointer: NonZero(reference as _) }\n    }\n}\n\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<'a, T: ?Sized> From<&'a T> for NonNull<T> {\n    #[inline]\n    fn from(reference: &'a T) -> Self {\n        NonNull { pointer: NonZero(reference as _) }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Traits for conversions between types.\n//!\n//! The traits in this module provide a general way to talk about conversions\n//! from one type to another. They follow the standard Rust conventions of\n//! `as`/`into`/`from`.\n//!\n//! Like many traits, these are often used as bounds for generic functions, to\n//! support arguments of multiple types.\n//!\n//! - Implement the `As*` traits for reference-to-reference conversions\n//! - Implement the [`Into`] trait when you want to consume the value in the conversion\n//! - The [`From`] trait is the most flexible, useful for value _and_ reference conversions\n//! - The [`TryFrom`] and [`TryInto`] traits behave like [`From`] and [`Into`], but allow for the\n//!   conversion to fail\n//!\n//! As a library author, you should prefer implementing [`From<T>`][`From`] or\n//! [`TryFrom<T>`][`TryFrom`] rather than [`Into<U>`][`Into`] or [`TryInto<U>`][`TryInto`],\n//! as [`From`] and [`TryFrom`] provide greater flexibility and offer\n//! equivalent [`Into`] or [`TryInto`] implementations for free, thanks to a\n//! blanket implementation in the standard library.\n//!\n//! # Generic Implementations\n//!\n//! - [`AsRef`] and [`AsMut`] auto-dereference if the inner type is a reference\n//! - [`From`]`<U> for T` implies [`Into`]`<T> for U`\n//! - [`TryFrom`]`<U> for T` implies [`TryInto`]`<T> for U`\n//! - [`From`] and [`Into`] are reflexive, which means that all types can\n//!   `into` themselves and `from` themselves\n//!\n//! See each trait for usage examples.\n//!\n//! [`Into`]: trait.Into.html\n//! [`From`]: trait.From.html\n//! [`TryFrom`]: trait.TryFrom.html\n//! [`TryInto`]: trait.TryInto.html\n//! [`AsRef`]: trait.AsRef.html\n//! [`AsMut`]: trait.AsMut.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n/// An identity function.\n///\n/// Two things are important to note about this function:\n///\n/// - It is not always equivalent to a closure like `|x| x` since the\n///   closure may coerce `x` into a different type.\n///\n/// - It moves the input `x` passed to the function.\n///\n/// While it might seem strange to have a function that just returns back the\n/// input, there are some interesting uses.\n///\n/// # Examples\n///\n/// Using `identity` to do nothing among other interesting functions:\n///\n/// ```rust\n/// #![feature(convert_id)]\n/// use std::convert::identity;\n///\n/// fn manipulation(x: u32) -> u32 {\n///     // Let's assume that this function does something interesting.\n///     x + 1\n/// }\n///\n/// let _arr = &[identity, manipulation];\n/// ```\n///\n/// Using `identity` to get a function that changes nothing in a conditional:\n///\n/// ```rust\n/// #![feature(convert_id)]\n/// use std::convert::identity;\n///\n/// # let condition = true;\n///\n/// # fn manipulation(x: u32) -> u32 { x + 1 }\n///\n/// let do_stuff = if condition { manipulation } else { identity };\n///\n/// // do more interesting stuff..\n///\n/// let _results = do_stuff(42);\n/// ```\n///\n/// Using `identity` to keep the `Some` variants of an iterator of `Option<T>`:\n///\n/// ```rust\n/// #![feature(convert_id)]\n/// use std::convert::identity;\n///\n/// let iter = vec![Some(1), None, Some(3)].into_iter();\n/// let filtered = iter.filter_map(identity).collect::<Vec<_>>();\n/// assert_eq!(vec![1, 3], filtered);\n/// ```\n#[unstable(feature = \"convert_id\", issue = \"53500\")]\n#[rustc_const_unstable(feature = \"const_convert_id\")]\n#[inline]\npub const fn identity<T>(x: T) -> T { x }\n\n/// A cheap reference-to-reference conversion. Used to convert a value to a\n/// reference value within generic code.\n///\n/// `AsRef` is very similar to, but serves a slightly different purpose than,\n/// [`Borrow`].\n///\n/// `AsRef` is to be used when wishing to convert to a reference of another\n/// type.\n/// `Borrow` is more related to the notion of taking the reference. It is\n/// useful when wishing to abstract over the type of reference\n/// (`&T`, `&mut T`) or allow both the referenced and owned type to be treated\n/// in the same manner.\n///\n/// The key difference between the two traits is the intention:\n///\n/// - Use `AsRef` when the goal is to simply convert into a reference\n/// - Use `Borrow` when the goal is related to writing code that is agnostic to\n///   the type of borrow and whether it is a reference or value\n///\n/// See [the book][book] for a more detailed comparison.\n///\n/// [book]: ../../book/first-edition/borrow-and-asref.html\n/// [`Borrow`]: ../../std/borrow/trait.Borrow.html\n///\n/// **Note: this trait must not fail**. If the conversion can fail, use a\n/// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].\n///\n/// [`Option<T>`]: ../../std/option/enum.Option.html\n/// [`Result<T, E>`]: ../../std/result/enum.Result.html\n///\n/// # Generic Implementations\n///\n/// - `AsRef` auto-dereferences if the inner type is a reference or a mutable\n///   reference (e.g.: `foo.as_ref()` will work the same if `foo` has type\n///   `&mut Foo` or `&&mut Foo`)\n///\n/// # Examples\n///\n/// Both [`String`] and `&str` implement `AsRef<str>`:\n///\n/// [`String`]: ../../std/string/struct.String.html\n///\n/// ```\n/// fn is_hello<T: AsRef<str>>(s: T) {\n///    assert_eq!(\"hello\", s.as_ref());\n/// }\n///\n/// let s = \"hello\";\n/// is_hello(s);\n///\n/// let s = \"hello\".to_string();\n/// is_hello(s);\n/// ```\n///\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait AsRef<T: ?Sized> {\n    /// Performs the conversion.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn as_ref(&self) -> &T;\n}\n\n/// A cheap, mutable reference-to-mutable reference conversion.\n///\n/// This trait is similar to `AsRef` but used for converting between mutable\n/// references.\n///\n/// **Note: this trait must not fail**. If the conversion can fail, use a\n/// dedicated method which returns an [`Option<T>`] or a [`Result<T, E>`].\n///\n/// [`Option<T>`]: ../../std/option/enum.Option.html\n/// [`Result<T, E>`]: ../../std/result/enum.Result.html\n///\n/// # Generic Implementations\n///\n/// - `AsMut` auto-dereferences if the inner type is a mutable reference\n///   (e.g.: `foo.as_mut()` will work the same if `foo` has type `&mut Foo`\n///   or `&mut &mut Foo`)\n///\n/// # Examples\n///\n/// [`Box<T>`] implements `AsMut<T>`:\n///\n/// [`Box<T>`]: ../../std/boxed/struct.Box.html\n///\n/// ```\n/// fn add_one<T: AsMut<u64>>(num: &mut T) {\n///     *num.as_mut() += 1;\n/// }\n///\n/// let mut boxed_num = Box::new(0);\n/// add_one(&mut boxed_num);\n/// assert_eq!(*boxed_num, 1);\n/// ```\n///\n///\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait AsMut<T: ?Sized> {\n    /// Performs the conversion.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn as_mut(&mut self) -> &mut T;\n}\n\n/// A conversion that consumes `self`, which may or may not be expensive. The\n/// reciprocal of [`From`][From].\n///\n/// **Note: this trait must not fail**. If the conversion can fail, use\n/// [`TryInto`] or a dedicated method which returns an [`Option<T>`] or a\n/// [`Result<T, E>`].\n///\n/// Library authors should not directly implement this trait, but should prefer\n/// implementing the [`From`][From] trait, which offers greater flexibility and\n/// provides an equivalent `Into` implementation for free, thanks to a blanket\n/// implementation in the standard library.\n///\n/// # Generic Implementations\n///\n/// - [`From<T>`][From]` for U` implies `Into<U> for T`\n/// - [`into`] is reflexive, which means that `Into<T> for T` is implemented\n///\n/// # Implementing `Into`\n///\n/// There is one exception to implementing `Into`, and it's kind of esoteric.\n/// If the destination type is not part of the current crate, and it uses a\n/// generic variable, then you can't implement `From` directly.  For example,\n/// take this crate:\n///\n/// ```compile_fail\n/// struct Wrapper<T>(Vec<T>);\n/// impl<T> From<Wrapper<T>> for Vec<T> {\n///     fn from(w: Wrapper<T>) -> Vec<T> {\n///         w.0\n///     }\n/// }\n/// ```\n///\n/// To fix this, you can implement `Into` directly:\n///\n/// ```\n/// struct Wrapper<T>(Vec<T>);\n/// impl<T> Into<Vec<T>> for Wrapper<T> {\n///     fn into(self) -> Vec<T> {\n///         self.0\n///     }\n/// }\n/// ```\n///\n/// This won't always allow the conversion: for example, `try!` and `?`\n/// always use `From`. However, in most cases, people use `Into` to do the\n/// conversions, and this will allow that.\n///\n/// In almost all cases, you should try to implement `From`, then fall back\n/// to `Into` if `From` can't be implemented.\n///\n/// # Examples\n///\n/// [`String`] implements `Into<Vec<u8>>`:\n///\n/// ```\n/// fn is_hello<T: Into<Vec<u8>>>(s: T) {\n///    let bytes = b\"hello\".to_vec();\n///    assert_eq!(bytes, s.into());\n/// }\n///\n/// let s = \"hello\".to_string();\n/// is_hello(s);\n/// ```\n///\n/// [`TryInto`]: trait.TryInto.html\n/// [`Option<T>`]: ../../std/option/enum.Option.html\n/// [`Result<T, E>`]: ../../std/result/enum.Result.html\n/// [`String`]: ../../std/string/struct.String.html\n/// [From]: trait.From.html\n/// [`into`]: trait.Into.html#tymethod.into\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Into<T>: Sized {\n    /// Performs the conversion.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn into(self) -> T;\n}\n\n/// Simple and safe type conversions in to `Self`. It is the reciprocal of\n/// `Into`.\n///\n/// This trait is useful when performing error handling as described by\n/// [the book][book] and is closely related to the `?` operator.\n///\n/// When constructing a function that is capable of failing the return type\n/// will generally be of the form `Result<T, E>`.\n///\n/// The `From` trait allows for simplification of error handling by providing a\n/// means of returning a single error type that encapsulates numerous possible\n/// erroneous situations.\n///\n/// This trait is not limited to error handling, rather the general case for\n/// this trait would be in any type conversions to have an explicit definition\n/// of how they are performed.\n///\n/// **Note: this trait must not fail**. If the conversion can fail, use\n/// [`TryFrom`] or a dedicated method which returns an [`Option<T>`] or a\n/// [`Result<T, E>`].\n///\n/// # Generic Implementations\n///\n/// - `From<T> for U` implies [`Into<U>`]` for T`\n/// - [`from`] is reflexive, which means that `From<T> for T` is implemented\n///\n/// # Examples\n///\n/// [`String`] implements `From<&str>`:\n///\n/// ```\n/// let string = \"hello\".to_string();\n/// let other_string = String::from(\"hello\");\n///\n/// assert_eq!(string, other_string);\n/// ```\n///\n/// An example usage for error handling:\n///\n/// ```\n/// use std::io::{self, Read};\n/// use std::num;\n///\n/// enum CliError {\n///     IoError(io::Error),\n///     ParseError(num::ParseIntError),\n/// }\n///\n/// impl From<io::Error> for CliError {\n///     fn from(error: io::Error) -> Self {\n///         CliError::IoError(error)\n///     }\n/// }\n///\n/// impl From<num::ParseIntError> for CliError {\n///     fn from(error: num::ParseIntError) -> Self {\n///         CliError::ParseError(error)\n///     }\n/// }\n///\n/// fn open_and_parse_file(file_name: &str) -> Result<i32, CliError> {\n///     let mut file = std::fs::File::open(\"test\")?;\n///     let mut contents = String::new();\n///     file.read_to_string(&mut contents)?;\n///     let num: i32 = contents.trim().parse()?;\n///     Ok(num)\n/// }\n/// ```\n///\n/// [`TryFrom`]: trait.TryFrom.html\n/// [`Option<T>`]: ../../std/option/enum.Option.html\n/// [`Result<T, E>`]: ../../std/result/enum.Result.html\n/// [`String`]: ../../std/string/struct.String.html\n/// [`Into<U>`]: trait.Into.html\n/// [`from`]: trait.From.html#tymethod.from\n/// [book]: ../../book/first-edition/error-handling.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait From<T>: Sized {\n    /// Performs the conversion.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn from(_: T) -> Self;\n}\n\n/// An attempted conversion that consumes `self`, which may or may not be\n/// expensive.\n///\n/// Library authors should not directly implement this trait, but should prefer\n/// implementing the [`TryFrom`] trait, which offers greater flexibility and\n/// provides an equivalent `TryInto` implementation for free, thanks to a\n/// blanket implementation in the standard library. For more information on this,\n/// see the documentation for [`Into`].\n///\n/// [`TryFrom`]: trait.TryFrom.html\n/// [`Into`]: trait.Into.html\n#[unstable(feature = \"try_from\", issue = \"33417\")]\npub trait TryInto<T>: Sized {\n    /// The type returned in the event of a conversion error.\n    type Error;\n\n    /// Performs the conversion.\n    fn try_into(self) -> Result<T, Self::Error>;\n}\n\n/// Attempt to construct `Self` via a conversion.\n#[unstable(feature = \"try_from\", issue = \"33417\")]\npub trait TryFrom<T>: Sized {\n    /// The type returned in the event of a conversion error.\n    type Error;\n\n    /// Performs the conversion.\n    fn try_from(value: T) -> Result<Self, Self::Error>;\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// GENERIC IMPLS\n////////////////////////////////////////////////////////////////////////////////\n\n// As lifts over &\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized, U: ?Sized> AsRef<U> for &T where T: AsRef<U>\n{\n    fn as_ref(&self) -> &U {\n        <T as AsRef<U>>::as_ref(*self)\n    }\n}\n\n// As lifts over &mut\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized, U: ?Sized> AsRef<U> for &mut T where T: AsRef<U>\n{\n    fn as_ref(&self) -> &U {\n        <T as AsRef<U>>::as_ref(*self)\n    }\n}\n\n// FIXME (#45742): replace the above impls for &/&mut with the following more general one:\n// // As lifts over Deref\n// impl<D: ?Sized + Deref, U: ?Sized> AsRef<U> for D where D::Target: AsRef<U> {\n//     fn as_ref(&self) -> &U {\n//         self.deref().as_ref()\n//     }\n// }\n\n// AsMut lifts over &mut\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized, U: ?Sized> AsMut<U> for &mut T where T: AsMut<U>\n{\n    fn as_mut(&mut self) -> &mut U {\n        (*self).as_mut()\n    }\n}\n\n// FIXME (#45742): replace the above impl for &mut with the following more general one:\n// // AsMut lifts over DerefMut\n// impl<D: ?Sized + Deref, U: ?Sized> AsMut<U> for D where D::Target: AsMut<U> {\n//     fn as_mut(&mut self) -> &mut U {\n//         self.deref_mut().as_mut()\n//     }\n// }\n\n// From implies Into\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T, U> Into<U> for T where U: From<T>\n{\n    fn into(self) -> U {\n        U::from(self)\n    }\n}\n\n// From (and thus Into) is reflexive\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> From<T> for T {\n    fn from(t: T) -> T { t }\n}\n\n\n// TryFrom implies TryInto\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl<T, U> TryInto<U> for T where U: TryFrom<T>\n{\n    type Error = U::Error;\n\n    fn try_into(self) -> Result<U, U::Error> {\n        U::try_from(self)\n    }\n}\n\n// Infallible conversions are semantically equivalent to fallible conversions\n// with an uninhabited error type.\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl<T, U> TryFrom<U> for T where T: From<U> {\n    type Error = !;\n\n    fn try_from(value: U) -> Result<Self, Self::Error> {\n        Ok(T::from(value))\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// CONCRETE IMPLS\n////////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> AsRef<[T]> for [T] {\n    fn as_ref(&self) -> &[T] {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> AsMut<[T]> for [T] {\n    fn as_mut(&mut self) -> &mut [T] {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<str> for str {\n    #[inline]\n    fn as_ref(&self) -> &str {\n        self\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Memory allocation APIs\n\n#![stable(feature = \"alloc_module\", since = \"1.28.0\")]\n\nuse cmp;\nuse fmt;\nuse mem;\nuse usize;\nuse ptr::{self, NonNull};\nuse num::NonZeroUsize;\n\n/// Represents the combination of a starting address and\n/// a total capacity of the returned block.\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\n#[derive(Debug)]\npub struct Excess(pub NonNull<u8>, pub usize);\n\nfn size_align<T>() -> (usize, usize) {\n    (mem::size_of::<T>(), mem::align_of::<T>())\n}\n\n/// Layout of a block of memory.\n///\n/// An instance of `Layout` describes a particular layout of memory.\n/// You build a `Layout` up as an input to give to an allocator.\n///\n/// All layouts have an associated non-negative size and a\n/// power-of-two alignment.\n///\n/// (Note however that layouts are *not* required to have positive\n/// size, even though many allocators require that all memory\n/// requests have positive size. A caller to the `Alloc::alloc`\n/// method must either ensure that conditions like this are met, or\n/// use specific allocators with looser requirements.)\n#[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\n#[lang = \"alloc_layout\"]\npub struct Layout {\n    // size of the requested block of memory, measured in bytes.\n    size_: usize,\n\n    // alignment of the requested block of memory, measured in bytes.\n    // we ensure that this is always a power-of-two, because API's\n    // like `posix_memalign` require it and it is a reasonable\n    // constraint to impose on Layout constructors.\n    //\n    // (However, we do not analogously require `align >= sizeof(void*)`,\n    //  even though that is *also* a requirement of `posix_memalign`.)\n    align_: NonZeroUsize,\n}\n\nimpl Layout {\n    /// Constructs a `Layout` from a given `size` and `align`,\n    /// or returns `LayoutErr` if either of the following conditions\n    /// are not met:\n    ///\n    /// * `align` must not be zero,\n    ///\n    /// * `align` must be a power of two,\n    ///\n    /// * `size`, when rounded up to the nearest multiple of `align`,\n    ///    must not overflow (i.e. the rounded value must be less than\n    ///    `usize::MAX`).\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub fn from_size_align(size: usize, align: usize) -> Result<Self, LayoutErr> {\n        if !align.is_power_of_two() {\n            return Err(LayoutErr { private: () });\n        }\n\n        // (power-of-two implies align != 0.)\n\n        // Rounded up size is:\n        //   size_rounded_up = (size + align - 1) & !(align - 1);\n        //\n        // We know from above that align != 0. If adding (align - 1)\n        // does not overflow, then rounding up will be fine.\n        //\n        // Conversely, &-masking with !(align - 1) will subtract off\n        // only low-order-bits. Thus if overflow occurs with the sum,\n        // the &-mask cannot subtract enough to undo that overflow.\n        //\n        // Above implies that checking for summation overflow is both\n        // necessary and sufficient.\n        if size > usize::MAX - (align - 1) {\n            return Err(LayoutErr { private: () });\n        }\n\n        unsafe {\n            Ok(Layout::from_size_align_unchecked(size, align))\n        }\n    }\n\n    /// Creates a layout, bypassing all checks.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe as it does not verify the preconditions from\n    /// [`Layout::from_size_align`](#method.from_size_align).\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Self {\n        Layout { size_: size, align_: NonZeroUsize::new_unchecked(align) }\n    }\n\n    /// The minimum size in bytes for a memory block of this layout.\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub fn size(&self) -> usize { self.size_ }\n\n    /// The minimum byte alignment for a memory block of this layout.\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub fn align(&self) -> usize { self.align_.get() }\n\n    /// Constructs a `Layout` suitable for holding a value of type `T`.\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub fn new<T>() -> Self {\n        let (size, align) = size_align::<T>();\n        // Note that the align is guaranteed by rustc to be a power of two and\n        // the size+align combo is guaranteed to fit in our address space. As a\n        // result use the unchecked constructor here to avoid inserting code\n        // that panics if it isn't optimized well enough.\n        debug_assert!(Layout::from_size_align(size, align).is_ok());\n        unsafe {\n            Layout::from_size_align_unchecked(size, align)\n        }\n    }\n\n    /// Produces layout describing a record that could be used to\n    /// allocate backing structure for `T` (which could be a trait\n    /// or other unsized type like a slice).\n    #[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n    #[inline]\n    pub fn for_value<T: ?Sized>(t: &T) -> Self {\n        let (size, align) = (mem::size_of_val(t), mem::align_of_val(t));\n        // See rationale in `new` for why this us using an unsafe variant below\n        debug_assert!(Layout::from_size_align(size, align).is_ok());\n        unsafe {\n            Layout::from_size_align_unchecked(size, align)\n        }\n    }\n\n    /// Creates a layout describing the record that can hold a value\n    /// of the same layout as `self`, but that also is aligned to\n    /// alignment `align` (measured in bytes).\n    ///\n    /// If `self` already meets the prescribed alignment, then returns\n    /// `self`.\n    ///\n    /// Note that this method does not add any padding to the overall\n    /// size, regardless of whether the returned layout has a different\n    /// alignment. In other words, if `K` has size 16, `K.align_to(32)`\n    /// will *still* have size 16.\n    ///\n    /// Returns an error if the combination of `self.size()` and the given\n    /// `align` violates the conditions listed in\n    /// [`Layout::from_size_align`](#method.from_size_align).\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn align_to(&self, align: usize) -> Result<Self, LayoutErr> {\n        Layout::from_size_align(self.size(), cmp::max(self.align(), align))\n    }\n\n    /// Returns the amount of padding we must insert after `self`\n    /// to ensure that the following address will satisfy `align`\n    /// (measured in bytes).\n    ///\n    /// E.g. if `self.size()` is 9, then `self.padding_needed_for(4)`\n    /// returns 3, because that is the minimum number of bytes of\n    /// padding required to get a 4-aligned address (assuming that the\n    /// corresponding memory block starts at a 4-aligned address).\n    ///\n    /// The return value of this function has no meaning if `align` is\n    /// not a power-of-two.\n    ///\n    /// Note that the utility of the returned value requires `align`\n    /// to be less than or equal to the alignment of the starting\n    /// address for the whole allocated block of memory. One way to\n    /// satisfy this constraint is to ensure `align <= self.align()`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn padding_needed_for(&self, align: usize) -> usize {\n        let len = self.size();\n\n        // Rounded up value is:\n        //   len_rounded_up = (len + align - 1) & !(align - 1);\n        // and then we return the padding difference: `len_rounded_up - len`.\n        //\n        // We use modular arithmetic throughout:\n        //\n        // 1. align is guaranteed to be > 0, so align - 1 is always\n        //    valid.\n        //\n        // 2. `len + align - 1` can overflow by at most `align - 1`,\n        //    so the &-mask wth `!(align - 1)` will ensure that in the\n        //    case of overflow, `len_rounded_up` will itself be 0.\n        //    Thus the returned padding, when added to `len`, yields 0,\n        //    which trivially satisfies the alignment `align`.\n        //\n        // (Of course, attempts to allocate blocks of memory whose\n        // size and padding overflow in the above manner should cause\n        // the allocator to yield an error anyway.)\n\n        let len_rounded_up = len.wrapping_add(align).wrapping_sub(1)\n            & !align.wrapping_sub(1);\n        len_rounded_up.wrapping_sub(len)\n    }\n\n    /// Creates a layout describing the record for `n` instances of\n    /// `self`, with a suitable amount of padding between each to\n    /// ensure that each instance is given its requested size and\n    /// alignment. On success, returns `(k, offs)` where `k` is the\n    /// layout of the array and `offs` is the distance between the start\n    /// of each element in the array.\n    ///\n    /// On arithmetic overflow, returns `LayoutErr`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn repeat(&self, n: usize) -> Result<(Self, usize), LayoutErr> {\n        let padded_size = self.size().checked_add(self.padding_needed_for(self.align()))\n            .ok_or(LayoutErr { private: () })?;\n        let alloc_size = padded_size.checked_mul(n)\n            .ok_or(LayoutErr { private: () })?;\n\n        unsafe {\n            // self.align is already known to be valid and alloc_size has been\n            // padded already.\n            Ok((Layout::from_size_align_unchecked(alloc_size, self.align()), padded_size))\n        }\n    }\n\n    /// Creates a layout describing the record for `self` followed by\n    /// `next`, including any necessary padding to ensure that `next`\n    /// will be properly aligned. Note that the result layout will\n    /// satisfy the alignment properties of both `self` and `next`.\n    ///\n    /// The resulting layout will be the same as that of a C struct containing\n    /// two fields with the layouts of `self` and `next`, in that order.\n    ///\n    /// Returns `Some((k, offset))`, where `k` is layout of the concatenated\n    /// record and `offset` is the relative location, in bytes, of the\n    /// start of the `next` embedded within the concatenated record\n    /// (assuming that the record itself starts at offset 0).\n    ///\n    /// On arithmetic overflow, returns `LayoutErr`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn extend(&self, next: Self) -> Result<(Self, usize), LayoutErr> {\n        let new_align = cmp::max(self.align(), next.align());\n        let pad = self.padding_needed_for(next.align());\n\n        let offset = self.size().checked_add(pad)\n            .ok_or(LayoutErr { private: () })?;\n        let new_size = offset.checked_add(next.size())\n            .ok_or(LayoutErr { private: () })?;\n\n        let layout = Layout::from_size_align(new_size, new_align)?;\n        Ok((layout, offset))\n    }\n\n    /// Creates a layout describing the record for `n` instances of\n    /// `self`, with no padding between each instance.\n    ///\n    /// Note that, unlike `repeat`, `repeat_packed` does not guarantee\n    /// that the repeated instances of `self` will be properly\n    /// aligned, even if a given instance of `self` is properly\n    /// aligned. In other words, if the layout returned by\n    /// `repeat_packed` is used to allocate an array, it is not\n    /// guaranteed that all elements in the array will be properly\n    /// aligned.\n    ///\n    /// On arithmetic overflow, returns `LayoutErr`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn repeat_packed(&self, n: usize) -> Result<Self, LayoutErr> {\n        let size = self.size().checked_mul(n).ok_or(LayoutErr { private: () })?;\n        Layout::from_size_align(size, self.align())\n    }\n\n    /// Creates a layout describing the record for `self` followed by\n    /// `next` with no additional padding between the two. Since no\n    /// padding is inserted, the alignment of `next` is irrelevant,\n    /// and is not incorporated *at all* into the resulting layout.\n    ///\n    /// On arithmetic overflow, returns `LayoutErr`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn extend_packed(&self, next: Self) -> Result<Self, LayoutErr> {\n        let new_size = self.size().checked_add(next.size())\n            .ok_or(LayoutErr { private: () })?;\n        let layout = Layout::from_size_align(new_size, self.align())?;\n        Ok(layout)\n    }\n\n    /// Creates a layout describing the record for a `[T; n]`.\n    ///\n    /// On arithmetic overflow, returns `LayoutErr`.\n    #[unstable(feature = \"alloc_layout_extra\", issue = \"55724\")]\n    #[inline]\n    pub fn array<T>(n: usize) -> Result<Self, LayoutErr> {\n        Layout::new::<T>()\n            .repeat(n)\n            .map(|(k, offs)| {\n                debug_assert!(offs == mem::size_of::<T>());\n                k\n            })\n    }\n}\n\n/// The parameters given to `Layout::from_size_align`\n/// or some other `Layout` constructor\n/// do not satisfy its documented constraints.\n#[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\n#[derive(Clone, PartialEq, Eq, Debug)]\npub struct LayoutErr {\n    private: ()\n}\n\n// (we need this for downstream impl of trait Error)\n#[stable(feature = \"alloc_layout\", since = \"1.28.0\")]\nimpl fmt::Display for LayoutErr {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.write_str(\"invalid parameters to Layout::from_size_align\")\n    }\n}\n\n/// The `AllocErr` error indicates an allocation failure\n/// that may be due to resource exhaustion or to\n/// something wrong when combining the given input arguments with this\n/// allocator.\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\n#[derive(Clone, PartialEq, Eq, Debug)]\npub struct AllocErr;\n\n// (we need this for downstream impl of trait Error)\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\nimpl fmt::Display for AllocErr {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.write_str(\"memory allocation failed\")\n    }\n}\n\n/// The `CannotReallocInPlace` error is used when `grow_in_place` or\n/// `shrink_in_place` were unable to reuse the given memory block for\n/// a requested layout.\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\n#[derive(Clone, PartialEq, Eq, Debug)]\npub struct CannotReallocInPlace;\n\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\nimpl CannotReallocInPlace {\n    pub fn description(&self) -> &str {\n        \"cannot reallocate allocator's memory in place\"\n    }\n}\n\n// (we need this for downstream impl of trait Error)\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\nimpl fmt::Display for CannotReallocInPlace {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"{}\", self.description())\n    }\n}\n\n/// A memory allocator that can be registered as the standard library\u2019s default\n/// though the `#[global_allocator]` attributes.\n///\n/// Some of the methods require that a memory block be *currently\n/// allocated* via an allocator. This means that:\n///\n/// * the starting address for that memory block was previously\n///   returned by a previous call to an allocation method\n///   such as `alloc`, and\n///\n/// * the memory block has not been subsequently deallocated, where\n///   blocks are deallocated either by being passed to a deallocation\n///   method such as `dealloc` or by being\n///   passed to a reallocation method that returns a non-null pointer.\n///\n///\n/// # Example\n///\n/// ```no_run\n/// use std::alloc::{GlobalAlloc, Layout, alloc};\n/// use std::ptr::null_mut;\n///\n/// struct MyAllocator;\n///\n/// unsafe impl GlobalAlloc for MyAllocator {\n///     unsafe fn alloc(&self, _layout: Layout) -> *mut u8 { null_mut() }\n///     unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}\n/// }\n///\n/// #[global_allocator]\n/// static A: MyAllocator = MyAllocator;\n///\n/// fn main() {\n///     unsafe {\n///         assert!(alloc(Layout::new::<u32>()).is_null())\n///     }\n/// }\n/// ```\n///\n/// # Unsafety\n///\n/// The `GlobalAlloc` trait is an `unsafe` trait for a number of reasons, and\n/// implementors must ensure that they adhere to these contracts:\n///\n/// * It's undefined behavior if global allocators unwind.  This restriction may\n///   be lifted in the future, but currently a panic from any of these\n///   functions may lead to memory unsafety.\n///\n/// * `Layout` queries and calculations in general must be correct. Callers of\n///   this trait are allowed to rely on the contracts defined on each method,\n///   and implementors must ensure such contracts remain true.\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\npub unsafe trait GlobalAlloc {\n    /// Allocate memory as described by the given `layout`.\n    ///\n    /// Returns a pointer to newly-allocated memory,\n    /// or null to indicate allocation failure.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure that `layout` has non-zero size.\n    ///\n    /// (Extension subtraits might provide more specific bounds on\n    /// behavior, e.g. guarantee a sentinel address or a null pointer\n    /// in response to a zero-size allocation request.)\n    ///\n    /// The allocated block of memory may or may not be initialized.\n    ///\n    /// # Errors\n    ///\n    /// Returning a null pointer indicates that either memory is exhausted\n    /// or `layout` does not meet allocator's size or alignment constraints.\n    ///\n    /// Implementations are encouraged to return null on memory\n    /// exhaustion rather than aborting, but this is not\n    /// a strict requirement. (Specifically: it is *legal* to\n    /// implement this trait atop an underlying native allocation\n    /// library that aborts on memory exhaustion.)\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    #[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n    unsafe fn alloc(&self, layout: Layout) -> *mut u8;\n\n    /// Deallocate the block of memory at the given `ptr` pointer with the given `layout`.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must denote a block of memory currently allocated via\n    ///   this allocator,\n    ///\n    /// * `layout` must be the same layout that was used\n    ///   to allocated that block of memory,\n    #[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);\n\n    /// Behaves like `alloc`, but also ensures that the contents\n    /// are set to zero before being returned.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe for the same reasons that `alloc` is.\n    /// However the allocated block of memory is guaranteed to be initialized.\n    ///\n    /// # Errors\n    ///\n    /// Returning a null pointer indicates that either memory is exhausted\n    /// or `layout` does not meet allocator's size or alignment constraints,\n    /// just as in `alloc`.\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    #[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n    unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {\n        let size = layout.size();\n        let ptr = self.alloc(layout);\n        if !ptr.is_null() {\n            ptr::write_bytes(ptr, 0, size);\n        }\n        ptr\n    }\n\n    /// Shink or grow a block of memory to the given `new_size`.\n    /// The block is described by the given `ptr` pointer and `layout`.\n    ///\n    /// If this returns a non-null pointer, then ownership of the memory block\n    /// referenced by `ptr` has been transferred to this allocator.\n    /// The memory may or may not have been deallocated,\n    /// and should be considered unusable (unless of course it was\n    /// transferred back to the caller again via the return value of\n    /// this method).\n    ///\n    /// If this method returns null, then ownership of the memory\n    /// block has not been transferred to this allocator, and the\n    /// contents of the memory block are unaltered.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must be currently allocated via this allocator,\n    ///\n    /// * `layout` must be the same layout that was used\n    ///   to allocated that block of memory,\n    ///\n    /// * `new_size` must be greater than zero.\n    ///\n    /// * `new_size`, when rounded up to the nearest multiple of `layout.align()`,\n    ///   must not overflow (i.e. the rounded value must be less than `usize::MAX`).\n    ///\n    /// (Extension subtraits might provide more specific bounds on\n    /// behavior, e.g. guarantee a sentinel address or a null pointer\n    /// in response to a zero-size allocation request.)\n    ///\n    /// # Errors\n    ///\n    /// Returns null if the new layout does not meet the size\n    /// and alignment constraints of the allocator, or if reallocation\n    /// otherwise fails.\n    ///\n    /// Implementations are encouraged to return null on memory\n    /// exhaustion rather than panicking or aborting, but this is not\n    /// a strict requirement. (Specifically: it is *legal* to\n    /// implement this trait atop an underlying native allocation\n    /// library that aborts on memory exhaustion.)\n    ///\n    /// Clients wishing to abort computation in response to a\n    /// reallocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    #[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n    unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {\n        let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());\n        let new_ptr = self.alloc(new_layout);\n        if !new_ptr.is_null() {\n            ptr::copy_nonoverlapping(\n                ptr,\n                new_ptr,\n                cmp::min(layout.size(), new_size),\n            );\n            self.dealloc(ptr, layout);\n        }\n        new_ptr\n    }\n}\n\n/// An implementation of `Alloc` can allocate, reallocate, and\n/// deallocate arbitrary blocks of data described via `Layout`.\n///\n/// Some of the methods require that a memory block be *currently\n/// allocated* via an allocator. This means that:\n///\n/// * the starting address for that memory block was previously\n///   returned by a previous call to an allocation method (`alloc`,\n///   `alloc_zeroed`, `alloc_excess`, `alloc_one`, `alloc_array`) or\n///   reallocation method (`realloc`, `realloc_excess`, or\n///   `realloc_array`), and\n///\n/// * the memory block has not been subsequently deallocated, where\n///   blocks are deallocated either by being passed to a deallocation\n///   method (`dealloc`, `dealloc_one`, `dealloc_array`) or by being\n///   passed to a reallocation method (see above) that returns `Ok`.\n///\n/// A note regarding zero-sized types and zero-sized layouts: many\n/// methods in the `Alloc` trait state that allocation requests\n/// must be non-zero size, or else undefined behavior can result.\n///\n/// * However, some higher-level allocation methods (`alloc_one`,\n///   `alloc_array`) are well-defined on zero-sized types and can\n///   optionally support them: it is left up to the implementor\n///   whether to return `Err`, or to return `Ok` with some pointer.\n///\n/// * If an `Alloc` implementation chooses to return `Ok` in this\n///   case (i.e. the pointer denotes a zero-sized inaccessible block)\n///   then that returned pointer must be considered \"currently\n///   allocated\". On such an allocator, *all* methods that take\n///   currently-allocated pointers as inputs must accept these\n///   zero-sized pointers, *without* causing undefined behavior.\n///\n/// * In other words, if a zero-sized pointer can flow out of an\n///   allocator, then that allocator must likewise accept that pointer\n///   flowing back into its deallocation and reallocation methods.\n///\n/// Some of the methods require that a layout *fit* a memory block.\n/// What it means for a layout to \"fit\" a memory block means (or\n/// equivalently, for a memory block to \"fit\" a layout) is that the\n/// following two conditions must hold:\n///\n/// 1. The block's starting address must be aligned to `layout.align()`.\n///\n/// 2. The block's size must fall in the range `[use_min, use_max]`, where:\n///\n///    * `use_min` is `self.usable_size(layout).0`, and\n///\n///    * `use_max` is the capacity that was (or would have been)\n///      returned when (if) the block was allocated via a call to\n///      `alloc_excess` or `realloc_excess`.\n///\n/// Note that:\n///\n///  * the size of the layout most recently used to allocate the block\n///    is guaranteed to be in the range `[use_min, use_max]`, and\n///\n///  * a lower-bound on `use_max` can be safely approximated by a call to\n///    `usable_size`.\n///\n///  * if a layout `k` fits a memory block (denoted by `ptr`)\n///    currently allocated via an allocator `a`, then it is legal to\n///    use that layout to deallocate it, i.e. `a.dealloc(ptr, k);`.\n///\n/// # Unsafety\n///\n/// The `Alloc` trait is an `unsafe` trait for a number of reasons, and\n/// implementors must ensure that they adhere to these contracts:\n///\n/// * Pointers returned from allocation functions must point to valid memory and\n///   retain their validity until at least the instance of `Alloc` is dropped\n///   itself.\n///\n/// * `Layout` queries and calculations in general must be correct. Callers of\n///   this trait are allowed to rely on the contracts defined on each method,\n///   and implementors must ensure such contracts remain true.\n///\n/// Note that this list may get tweaked over time as clarifications are made in\n/// the future.\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\npub unsafe trait Alloc {\n\n    // (Note: some existing allocators have unspecified but well-defined\n    // behavior in response to a zero size allocation request ;\n    // e.g. in C, `malloc` of 0 will either return a null pointer or a\n    // unique pointer, but will not have arbitrary undefined\n    // behavior.\n    // However in jemalloc for example,\n    // `mallocx(0)` is documented as undefined behavior.)\n\n    /// Returns a pointer meeting the size and alignment guarantees of\n    /// `layout`.\n    ///\n    /// If this method returns an `Ok(addr)`, then the `addr` returned\n    /// will be non-null address pointing to a block of storage\n    /// suitable for holding an instance of `layout`.\n    ///\n    /// The returned block of storage may or may not have its contents\n    /// initialized. (Extension subtraits might restrict this\n    /// behavior, e.g. to ensure initialization to particular sets of\n    /// bit patterns.)\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure that `layout` has non-zero size.\n    ///\n    /// (Extension subtraits might provide more specific bounds on\n    /// behavior, e.g. guarantee a sentinel address or a null pointer\n    /// in response to a zero-size allocation request.)\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `layout` does not meet allocator's size or alignment\n    /// constraints.\n    ///\n    /// Implementations are encouraged to return `Err` on memory\n    /// exhaustion rather than panicking or aborting, but this is not\n    /// a strict requirement. (Specifically: it is *legal* to\n    /// implement this trait atop an underlying native allocation\n    /// library that aborts on memory exhaustion.)\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr>;\n\n    /// Deallocate the memory referenced by `ptr`.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must denote a block of memory currently allocated via\n    ///   this allocator,\n    ///\n    /// * `layout` must *fit* that block of memory,\n    ///\n    /// * In addition to fitting the block of memory `layout`, the\n    ///   alignment of the `layout` must match the alignment used\n    ///   to allocate that block of memory.\n    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout);\n\n    // == ALLOCATOR-SPECIFIC QUANTITIES AND LIMITS ==\n    // usable_size\n\n    /// Returns bounds on the guaranteed usable size of a successful\n    /// allocation created with the specified `layout`.\n    ///\n    /// In particular, if one has a memory block allocated via a given\n    /// allocator `a` and layout `k` where `a.usable_size(k)` returns\n    /// `(l, u)`, then one can pass that block to `a.dealloc()` with a\n    /// layout in the size range [l, u].\n    ///\n    /// (All implementors of `usable_size` must ensure that\n    /// `l <= k.size() <= u`)\n    ///\n    /// Both the lower- and upper-bounds (`l` and `u` respectively)\n    /// are provided, because an allocator based on size classes could\n    /// misbehave if one attempts to deallocate a block without\n    /// providing a correct value for its size (i.e., one within the\n    /// range `[l, u]`).\n    ///\n    /// Clients who wish to make use of excess capacity are encouraged\n    /// to use the `alloc_excess` and `realloc_excess` instead, as\n    /// this method is constrained to report conservative values that\n    /// serve as valid bounds for *all possible* allocation method\n    /// calls.\n    ///\n    /// However, for clients that do not wish to track the capacity\n    /// returned by `alloc_excess` locally, this method is likely to\n    /// produce useful results.\n    #[inline]\n    fn usable_size(&self, layout: &Layout) -> (usize, usize) {\n        (layout.size(), layout.size())\n    }\n\n    // == METHODS FOR MEMORY REUSE ==\n    // realloc. alloc_excess, realloc_excess\n\n    /// Returns a pointer suitable for holding data described by\n    /// a new layout with `layout`\u2019s alginment and a size given\n    /// by `new_size`. To\n    /// accomplish this, this may extend or shrink the allocation\n    /// referenced by `ptr` to fit the new layout.\n    ///\n    /// If this returns `Ok`, then ownership of the memory block\n    /// referenced by `ptr` has been transferred to this\n    /// allocator. The memory may or may not have been freed, and\n    /// should be considered unusable (unless of course it was\n    /// transferred back to the caller again via the return value of\n    /// this method).\n    ///\n    /// If this method returns `Err`, then ownership of the memory\n    /// block has not been transferred to this allocator, and the\n    /// contents of the memory block are unaltered.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must be currently allocated via this allocator,\n    ///\n    /// * `layout` must *fit* the `ptr` (see above). (The `new_size`\n    ///   argument need not fit it.)\n    ///\n    /// * `new_size` must be greater than zero.\n    ///\n    /// * `new_size`, when rounded up to the nearest multiple of `layout.align()`,\n    ///   must not overflow (i.e. the rounded value must be less than `usize::MAX`).\n    ///\n    /// (Extension subtraits might provide more specific bounds on\n    /// behavior, e.g. guarantee a sentinel address or a null pointer\n    /// in response to a zero-size allocation request.)\n    ///\n    /// # Errors\n    ///\n    /// Returns `Err` only if the new layout\n    /// does not meet the allocator's size\n    /// and alignment constraints of the allocator, or if reallocation\n    /// otherwise fails.\n    ///\n    /// Implementations are encouraged to return `Err` on memory\n    /// exhaustion rather than panicking or aborting, but this is not\n    /// a strict requirement. (Specifically: it is *legal* to\n    /// implement this trait atop an underlying native allocation\n    /// library that aborts on memory exhaustion.)\n    ///\n    /// Clients wishing to abort computation in response to a\n    /// reallocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn realloc(&mut self,\n                      ptr: NonNull<u8>,\n                      layout: Layout,\n                      new_size: usize) -> Result<NonNull<u8>, AllocErr> {\n        let old_size = layout.size();\n\n        if new_size >= old_size {\n            if let Ok(()) = self.grow_in_place(ptr, layout.clone(), new_size) {\n                return Ok(ptr);\n            }\n        } else if new_size < old_size {\n            if let Ok(()) = self.shrink_in_place(ptr, layout.clone(), new_size) {\n                return Ok(ptr);\n            }\n        }\n\n        // otherwise, fall back on alloc + copy + dealloc.\n        let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());\n        let result = self.alloc(new_layout);\n        if let Ok(new_ptr) = result {\n            ptr::copy_nonoverlapping(ptr.as_ptr(),\n                                     new_ptr.as_ptr(),\n                                     cmp::min(old_size, new_size));\n            self.dealloc(ptr, layout);\n        }\n        result\n    }\n\n    /// Behaves like `alloc`, but also ensures that the contents\n    /// are set to zero before being returned.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe for the same reasons that `alloc` is.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `layout` does not meet allocator's size or alignment\n    /// constraints, just as in `alloc`.\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n        let size = layout.size();\n        let p = self.alloc(layout);\n        if let Ok(p) = p {\n            ptr::write_bytes(p.as_ptr(), 0, size);\n        }\n        p\n    }\n\n    /// Behaves like `alloc`, but also returns the whole size of\n    /// the returned block. For some `layout` inputs, like arrays, this\n    /// may include extra storage usable for additional data.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe for the same reasons that `alloc` is.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `layout` does not meet allocator's size or alignment\n    /// constraints, just as in `alloc`.\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn alloc_excess(&mut self, layout: Layout) -> Result<Excess, AllocErr> {\n        let usable_size = self.usable_size(&layout);\n        self.alloc(layout).map(|p| Excess(p, usable_size.1))\n    }\n\n    /// Behaves like `realloc`, but also returns the whole size of\n    /// the returned block. For some `layout` inputs, like arrays, this\n    /// may include extra storage usable for additional data.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe for the same reasons that `realloc` is.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `layout` does not meet allocator's size or alignment\n    /// constraints, just as in `realloc`.\n    ///\n    /// Clients wishing to abort computation in response to a\n    /// reallocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn realloc_excess(&mut self,\n                             ptr: NonNull<u8>,\n                             layout: Layout,\n                             new_size: usize) -> Result<Excess, AllocErr> {\n        let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());\n        let usable_size = self.usable_size(&new_layout);\n        self.realloc(ptr, layout, new_size)\n            .map(|p| Excess(p, usable_size.1))\n    }\n\n    /// Attempts to extend the allocation referenced by `ptr` to fit `new_size`.\n    ///\n    /// If this returns `Ok`, then the allocator has asserted that the\n    /// memory block referenced by `ptr` now fits `new_size`, and thus can\n    /// be used to carry data of a layout of that size and same alignment as\n    /// `layout`. (The allocator is allowed to\n    /// expend effort to accomplish this, such as extending the memory block to\n    /// include successor blocks, or virtual memory tricks.)\n    ///\n    /// Regardless of what this method returns, ownership of the\n    /// memory block referenced by `ptr` has not been transferred, and\n    /// the contents of the memory block are unaltered.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must be currently allocated via this allocator,\n    ///\n    /// * `layout` must *fit* the `ptr` (see above); note the\n    ///   `new_size` argument need not fit it,\n    ///\n    /// * `new_size` must not be less than `layout.size()`,\n    ///\n    /// # Errors\n    ///\n    /// Returns `Err(CannotReallocInPlace)` when the allocator is\n    /// unable to assert that the memory block referenced by `ptr`\n    /// could fit `layout`.\n    ///\n    /// Note that one cannot pass `CannotReallocInPlace` to the `handle_alloc_error`\n    /// function; clients are expected either to be able to recover from\n    /// `grow_in_place` failures without aborting, or to fall back on\n    /// another reallocation method before resorting to an abort.\n    unsafe fn grow_in_place(&mut self,\n                            ptr: NonNull<u8>,\n                            layout: Layout,\n                            new_size: usize) -> Result<(), CannotReallocInPlace> {\n        let _ = ptr; // this default implementation doesn't care about the actual address.\n        debug_assert!(new_size >= layout.size());\n        let (_l, u) = self.usable_size(&layout);\n        // _l <= layout.size()                       [guaranteed by usable_size()]\n        //       layout.size() <= new_layout.size()  [required by this method]\n        if new_size <= u {\n            Ok(())\n        } else {\n            Err(CannotReallocInPlace)\n        }\n    }\n\n    /// Attempts to shrink the allocation referenced by `ptr` to fit `new_size`.\n    ///\n    /// If this returns `Ok`, then the allocator has asserted that the\n    /// memory block referenced by `ptr` now fits `new_size`, and\n    /// thus can only be used to carry data of that smaller\n    /// layout. (The allocator is allowed to take advantage of this,\n    /// carving off portions of the block for reuse elsewhere.) The\n    /// truncated contents of the block within the smaller layout are\n    /// unaltered, and ownership of block has not been transferred.\n    ///\n    /// If this returns `Err`, then the memory block is considered to\n    /// still represent the original (larger) `layout`. None of the\n    /// block has been carved off for reuse elsewhere, ownership of\n    /// the memory block has not been transferred, and the contents of\n    /// the memory block are unaltered.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must be currently allocated via this allocator,\n    ///\n    /// * `layout` must *fit* the `ptr` (see above); note the\n    ///   `new_size` argument need not fit it,\n    ///\n    /// * `new_size` must not be greater than `layout.size()`\n    ///   (and must be greater than zero),\n    ///\n    /// # Errors\n    ///\n    /// Returns `Err(CannotReallocInPlace)` when the allocator is\n    /// unable to assert that the memory block referenced by `ptr`\n    /// could fit `layout`.\n    ///\n    /// Note that one cannot pass `CannotReallocInPlace` to the `handle_alloc_error`\n    /// function; clients are expected either to be able to recover from\n    /// `shrink_in_place` failures without aborting, or to fall back\n    /// on another reallocation method before resorting to an abort.\n    unsafe fn shrink_in_place(&mut self,\n                              ptr: NonNull<u8>,\n                              layout: Layout,\n                              new_size: usize) -> Result<(), CannotReallocInPlace> {\n        let _ = ptr; // this default implementation doesn't care about the actual address.\n        debug_assert!(new_size <= layout.size());\n        let (l, _u) = self.usable_size(&layout);\n        //                      layout.size() <= _u  [guaranteed by usable_size()]\n        // new_layout.size() <= layout.size()        [required by this method]\n        if l <= new_size {\n            Ok(())\n        } else {\n            Err(CannotReallocInPlace)\n        }\n    }\n\n\n    // == COMMON USAGE PATTERNS ==\n    // alloc_one, dealloc_one, alloc_array, realloc_array. dealloc_array\n\n    /// Allocates a block suitable for holding an instance of `T`.\n    ///\n    /// Captures a common usage pattern for allocators.\n    ///\n    /// The returned block is suitable for passing to the\n    /// `alloc`/`realloc` methods of this allocator.\n    ///\n    /// Note to implementors: If this returns `Ok(ptr)`, then `ptr`\n    /// must be considered \"currently allocated\" and must be\n    /// acceptable input to methods such as `realloc` or `dealloc`,\n    /// *even if* `T` is a zero-sized type. In other words, if your\n    /// `Alloc` implementation overrides this method in a manner\n    /// that can return a zero-sized `ptr`, then all reallocation and\n    /// deallocation methods need to be similarly overridden to accept\n    /// such values as input.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `T` does not meet allocator's size or alignment constraints.\n    ///\n    /// For zero-sized `T`, may return either of `Ok` or `Err`, but\n    /// will *not* yield undefined behavior.\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    fn alloc_one<T>(&mut self) -> Result<NonNull<T>, AllocErr>\n        where Self: Sized\n    {\n        let k = Layout::new::<T>();\n        if k.size() > 0 {\n            unsafe { self.alloc(k).map(|p| p.cast()) }\n        } else {\n            Err(AllocErr)\n        }\n    }\n\n    /// Deallocates a block suitable for holding an instance of `T`.\n    ///\n    /// The given block must have been produced by this allocator,\n    /// and must be suitable for storing a `T` (in terms of alignment\n    /// as well as minimum and maximum size); otherwise yields\n    /// undefined behavior.\n    ///\n    /// Captures a common usage pattern for allocators.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure both:\n    ///\n    /// * `ptr` must denote a block of memory currently allocated via this allocator\n    ///\n    /// * the layout of `T` must *fit* that block of memory.\n    unsafe fn dealloc_one<T>(&mut self, ptr: NonNull<T>)\n        where Self: Sized\n    {\n        let k = Layout::new::<T>();\n        if k.size() > 0 {\n            self.dealloc(ptr.cast(), k);\n        }\n    }\n\n    /// Allocates a block suitable for holding `n` instances of `T`.\n    ///\n    /// Captures a common usage pattern for allocators.\n    ///\n    /// The returned block is suitable for passing to the\n    /// `alloc`/`realloc` methods of this allocator.\n    ///\n    /// Note to implementors: If this returns `Ok(ptr)`, then `ptr`\n    /// must be considered \"currently allocated\" and must be\n    /// acceptable input to methods such as `realloc` or `dealloc`,\n    /// *even if* `T` is a zero-sized type. In other words, if your\n    /// `Alloc` implementation overrides this method in a manner\n    /// that can return a zero-sized `ptr`, then all reallocation and\n    /// deallocation methods need to be similarly overridden to accept\n    /// such values as input.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `[T; n]` does not meet allocator's size or alignment\n    /// constraints.\n    ///\n    /// For zero-sized `T` or `n == 0`, may return either of `Ok` or\n    /// `Err`, but will *not* yield undefined behavior.\n    ///\n    /// Always returns `Err` on arithmetic overflow.\n    ///\n    /// Clients wishing to abort computation in response to an\n    /// allocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    fn alloc_array<T>(&mut self, n: usize) -> Result<NonNull<T>, AllocErr>\n        where Self: Sized\n    {\n        match Layout::array::<T>(n) {\n            Ok(ref layout) if layout.size() > 0 => {\n                unsafe {\n                    self.alloc(layout.clone()).map(|p| p.cast())\n                }\n            }\n            _ => Err(AllocErr),\n        }\n    }\n\n    /// Reallocates a block previously suitable for holding `n_old`\n    /// instances of `T`, returning a block suitable for holding\n    /// `n_new` instances of `T`.\n    ///\n    /// Captures a common usage pattern for allocators.\n    ///\n    /// The returned block is suitable for passing to the\n    /// `alloc`/`realloc` methods of this allocator.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure all of the following:\n    ///\n    /// * `ptr` must be currently allocated via this allocator,\n    ///\n    /// * the layout of `[T; n_old]` must *fit* that block of memory.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either memory is exhausted or\n    /// `[T; n_new]` does not meet allocator's size or alignment\n    /// constraints.\n    ///\n    /// For zero-sized `T` or `n_new == 0`, may return either of `Ok` or\n    /// `Err`, but will *not* yield undefined behavior.\n    ///\n    /// Always returns `Err` on arithmetic overflow.\n    ///\n    /// Clients wishing to abort computation in response to a\n    /// reallocation error are encouraged to call the [`handle_alloc_error`] function,\n    /// rather than directly invoking `panic!` or similar.\n    ///\n    /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html\n    unsafe fn realloc_array<T>(&mut self,\n                               ptr: NonNull<T>,\n                               n_old: usize,\n                               n_new: usize) -> Result<NonNull<T>, AllocErr>\n        where Self: Sized\n    {\n        match (Layout::array::<T>(n_old), Layout::array::<T>(n_new)) {\n            (Ok(ref k_old), Ok(ref k_new)) if k_old.size() > 0 && k_new.size() > 0 => {\n                debug_assert!(k_old.align() == k_new.align());\n                self.realloc(ptr.cast(), k_old.clone(), k_new.size()).map(NonNull::cast)\n            }\n            _ => {\n                Err(AllocErr)\n            }\n        }\n    }\n\n    /// Deallocates a block suitable for holding `n` instances of `T`.\n    ///\n    /// Captures a common usage pattern for allocators.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because undefined behavior can result\n    /// if the caller does not ensure both:\n    ///\n    /// * `ptr` must denote a block of memory currently allocated via this allocator\n    ///\n    /// * the layout of `[T; n]` must *fit* that block of memory.\n    ///\n    /// # Errors\n    ///\n    /// Returning `Err` indicates that either `[T; n]` or the given\n    /// memory block does not meet allocator's size or alignment\n    /// constraints.\n    ///\n    /// Always returns `Err` on arithmetic overflow.\n    unsafe fn dealloc_array<T>(&mut self, ptr: NonNull<T>, n: usize) -> Result<(), AllocErr>\n        where Self: Sized\n    {\n        match Layout::array::<T>(n) {\n            Ok(ref k) if k.size() > 0 => {\n                Ok(self.dealloc(ptr.cast(), k.clone()))\n            }\n            _ => {\n                Err(AllocErr)\n            }\n        }\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! String manipulation\n//!\n//! For more details, see std::str\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse self::pattern::Pattern;\nuse self::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};\n\nuse char;\nuse fmt;\nuse iter::{Map, Cloned, FusedIterator, TrustedLen, Filter};\nuse iter_private::TrustedRandomAccess;\nuse slice::{self, SliceIndex, Split as SliceSplit};\nuse mem;\n\npub mod pattern;\n\n#[unstable(feature = \"str_internals\", issue = \"0\")]\n#[allow(missing_docs)]\npub mod lossy;\n\n/// A trait to abstract the idea of creating a new instance of a type from a\n/// string.\n///\n/// `FromStr`'s [`from_str`] method is often used implicitly, through\n/// [`str`]'s [`parse`] method. See [`parse`]'s documentation for examples.\n///\n/// [`from_str`]: #tymethod.from_str\n/// [`str`]: ../../std/primitive.str.html\n/// [`parse`]: ../../std/primitive.str.html#method.parse\n///\n/// # Examples\n///\n/// Basic implementation of `FromStr` on an example `Point` type:\n///\n/// ```\n/// use std::str::FromStr;\n/// use std::num::ParseIntError;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point {\n///     x: i32,\n///     y: i32\n/// }\n///\n/// impl FromStr for Point {\n///     type Err = ParseIntError;\n///\n///     fn from_str(s: &str) -> Result<Self, Self::Err> {\n///         let coords: Vec<&str> = s.trim_matches(|p| p == '(' || p == ')' )\n///                                  .split(',')\n///                                  .collect();\n///\n///         let x_fromstr = coords[0].parse::<i32>()?;\n///         let y_fromstr = coords[1].parse::<i32>()?;\n///\n///         Ok(Point { x: x_fromstr, y: y_fromstr })\n///     }\n/// }\n///\n/// let p = Point::from_str(\"(1,2)\");\n/// assert_eq!(p.unwrap(), Point{ x: 1, y: 2} )\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait FromStr: Sized {\n    /// The associated error which can be returned from parsing.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Err;\n\n    /// Parses a string `s` to return a value of this type.\n    ///\n    /// If parsing succeeds, return the value inside [`Ok`], otherwise\n    /// when the string is ill-formatted return an error specific to the\n    /// inside [`Err`]. The error type is specific to implementation of the trait.\n    ///\n    /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage with [`i32`][ithirtytwo], a type that implements `FromStr`:\n    ///\n    /// [ithirtytwo]: ../../std/primitive.i32.html\n    ///\n    /// ```\n    /// use std::str::FromStr;\n    ///\n    /// let s = \"5\";\n    /// let x = i32::from_str(s).unwrap();\n    ///\n    /// assert_eq!(5, x);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn from_str(s: &str) -> Result<Self, Self::Err>;\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromStr for bool {\n    type Err = ParseBoolError;\n\n    /// Parse a `bool` from a string.\n    ///\n    /// Yields a `Result<bool, ParseBoolError>`, because `s` may or may not\n    /// actually be parseable.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::str::FromStr;\n    ///\n    /// assert_eq!(FromStr::from_str(\"true\"), Ok(true));\n    /// assert_eq!(FromStr::from_str(\"false\"), Ok(false));\n    /// assert!(<bool as FromStr>::from_str(\"not even a boolean\").is_err());\n    /// ```\n    ///\n    /// Note, in many cases, the `.parse()` method on `str` is more proper.\n    ///\n    /// ```\n    /// assert_eq!(\"true\".parse(), Ok(true));\n    /// assert_eq!(\"false\".parse(), Ok(false));\n    /// assert!(\"not even a boolean\".parse::<bool>().is_err());\n    /// ```\n    #[inline]\n    fn from_str(s: &str) -> Result<bool, ParseBoolError> {\n        match s {\n            \"true\"  => Ok(true),\n            \"false\" => Ok(false),\n            _       => Err(ParseBoolError { _priv: () }),\n        }\n    }\n}\n\n/// An error returned when parsing a `bool` using [`from_str`] fails\n///\n/// [`from_str`]: ../../std/primitive.bool.html#method.from_str\n#[derive(Debug, Clone, PartialEq, Eq)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct ParseBoolError { _priv: () }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for ParseBoolError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        \"provided string was not `true` or `false`\".fmt(f)\n    }\n}\n\n/*\nSection: Creating a string\n*/\n\n/// Errors which can occur when attempting to interpret a sequence of [`u8`]\n/// as a string.\n///\n/// [`u8`]: ../../std/primitive.u8.html\n///\n/// As such, the `from_utf8` family of functions and methods for both [`String`]s\n/// and [`&str`]s make use of this error, for example.\n///\n/// [`String`]: ../../std/string/struct.String.html#method.from_utf8\n/// [`&str`]: ../../std/str/fn.from_utf8.html\n///\n/// # Examples\n///\n/// This error type\u2019s methods can be used to create functionality\n/// similar to `String::from_utf8_lossy` without allocating heap memory:\n///\n/// ```\n/// fn from_utf8_lossy<F>(mut input: &[u8], mut push: F) where F: FnMut(&str) {\n///     loop {\n///         match ::std::str::from_utf8(input) {\n///             Ok(valid) => {\n///                 push(valid);\n///                 break\n///             }\n///             Err(error) => {\n///                 let (valid, after_valid) = input.split_at(error.valid_up_to());\n///                 unsafe {\n///                     push(::std::str::from_utf8_unchecked(valid))\n///                 }\n///                 push(\"\\u{FFFD}\");\n///\n///                 if let Some(invalid_sequence_length) = error.error_len() {\n///                     input = &after_valid[invalid_sequence_length..]\n///                 } else {\n///                     break\n///                 }\n///             }\n///         }\n///     }\n/// }\n/// ```\n#[derive(Copy, Eq, PartialEq, Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Utf8Error {\n    valid_up_to: usize,\n    error_len: Option<u8>,\n}\n\nimpl Utf8Error {\n    /// Returns the index in the given string up to which valid UTF-8 was\n    /// verified.\n    ///\n    /// It is the maximum index such that `from_utf8(&input[..index])`\n    /// would return `Ok(_)`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::str;\n    ///\n    /// // some invalid bytes, in a vector\n    /// let sparkle_heart = vec![0, 159, 146, 150];\n    ///\n    /// // std::str::from_utf8 returns a Utf8Error\n    /// let error = str::from_utf8(&sparkle_heart).unwrap_err();\n    ///\n    /// // the second byte is invalid here\n    /// assert_eq!(1, error.valid_up_to());\n    /// ```\n    #[stable(feature = \"utf8_error\", since = \"1.5.0\")]\n    pub fn valid_up_to(&self) -> usize { self.valid_up_to }\n\n    /// Provide more information about the failure:\n    ///\n    /// * `None`: the end of the input was reached unexpectedly.\n    ///   `self.valid_up_to()` is 1 to 3 bytes from the end of the input.\n    ///   If a byte stream (such as a file or a network socket) is being decoded incrementally,\n    ///   this could be a valid `char` whose UTF-8 byte sequence is spanning multiple chunks.\n    ///\n    /// * `Some(len)`: an unexpected byte was encountered.\n    ///   The length provided is that of the invalid byte sequence\n    ///   that starts at the index given by `valid_up_to()`.\n    ///   Decoding should resume after that sequence\n    ///   (after inserting a [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD]) in case of\n    ///   lossy decoding.\n    ///\n    /// [U+FFFD]: ../../std/char/constant.REPLACEMENT_CHARACTER.html\n    #[stable(feature = \"utf8_error_error_len\", since = \"1.20.0\")]\n    pub fn error_len(&self) -> Option<usize> {\n        self.error_len.map(|len| len as usize)\n    }\n}\n\n/// Converts a slice of bytes to a string slice.\n///\n/// A string slice ([`&str`]) is made of bytes ([`u8`]), and a byte slice\n/// ([`&[u8]`][byteslice]) is made of bytes, so this function converts between\n/// the two. Not all byte slices are valid string slices, however: [`&str`] requires\n/// that it is valid UTF-8. `from_utf8()` checks to ensure that the bytes are valid\n/// UTF-8, and then does the conversion.\n///\n/// [`&str`]: ../../std/primitive.str.html\n/// [`u8`]: ../../std/primitive.u8.html\n/// [byteslice]: ../../std/primitive.slice.html\n///\n/// If you are sure that the byte slice is valid UTF-8, and you don't want to\n/// incur the overhead of the validity check, there is an unsafe version of\n/// this function, [`from_utf8_unchecked`][fromutf8u], which has the same\n/// behavior but skips the check.\n///\n/// [fromutf8u]: fn.from_utf8_unchecked.html\n///\n/// If you need a `String` instead of a `&str`, consider\n/// [`String::from_utf8`][string].\n///\n/// [string]: ../../std/string/struct.String.html#method.from_utf8\n///\n/// Because you can stack-allocate a `[u8; N]`, and you can take a\n/// [`&[u8]`][byteslice] of it, this function is one way to have a\n/// stack-allocated string. There is an example of this in the\n/// examples section below.\n///\n/// [byteslice]: ../../std/primitive.slice.html\n///\n/// # Errors\n///\n/// Returns `Err` if the slice is not UTF-8 with a description as to why the\n/// provided slice is not UTF-8.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::str;\n///\n/// // some bytes, in a vector\n/// let sparkle_heart = vec![240, 159, 146, 150];\n///\n/// // We know these bytes are valid, so just use `unwrap()`.\n/// let sparkle_heart = str::from_utf8(&sparkle_heart).unwrap();\n///\n/// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n/// ```\n///\n/// Incorrect bytes:\n///\n/// ```\n/// use std::str;\n///\n/// // some invalid bytes, in a vector\n/// let sparkle_heart = vec![0, 159, 146, 150];\n///\n/// assert!(str::from_utf8(&sparkle_heart).is_err());\n/// ```\n///\n/// See the docs for [`Utf8Error`][error] for more details on the kinds of\n/// errors that can be returned.\n///\n/// [error]: struct.Utf8Error.html\n///\n/// A \"stack allocated string\":\n///\n/// ```\n/// use std::str;\n///\n/// // some bytes, in a stack-allocated array\n/// let sparkle_heart = [240, 159, 146, 150];\n///\n/// // We know these bytes are valid, so just use `unwrap()`.\n/// let sparkle_heart = str::from_utf8(&sparkle_heart).unwrap();\n///\n/// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {\n    run_utf8_validation(v)?;\n    Ok(unsafe { from_utf8_unchecked(v) })\n}\n\n/// Converts a mutable slice of bytes to a mutable string slice.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::str;\n///\n/// // \"Hello, Rust!\" as a mutable vector\n/// let mut hellorust = vec![72, 101, 108, 108, 111, 44, 32, 82, 117, 115, 116, 33];\n///\n/// // As we know these bytes are valid, we can use `unwrap()`\n/// let outstr = str::from_utf8_mut(&mut hellorust).unwrap();\n///\n/// assert_eq!(\"Hello, Rust!\", outstr);\n/// ```\n///\n/// Incorrect bytes:\n///\n/// ```\n/// use std::str;\n///\n/// // Some invalid bytes in a mutable vector\n/// let mut invalid = vec![128, 223];\n///\n/// assert!(str::from_utf8_mut(&mut invalid).is_err());\n/// ```\n/// See the docs for [`Utf8Error`][error] for more details on the kinds of\n/// errors that can be returned.\n///\n/// [error]: struct.Utf8Error.html\n#[stable(feature = \"str_mut_extras\", since = \"1.20.0\")]\npub fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {\n    run_utf8_validation(v)?;\n    Ok(unsafe { from_utf8_unchecked_mut(v) })\n}\n\n/// Converts a slice of bytes to a string slice without checking\n/// that the string contains valid UTF-8.\n///\n/// See the safe version, [`from_utf8`][fromutf8], for more information.\n///\n/// [fromutf8]: fn.from_utf8.html\n///\n/// # Safety\n///\n/// This function is unsafe because it does not check that the bytes passed to\n/// it are valid UTF-8. If this constraint is violated, undefined behavior\n/// results, as the rest of Rust assumes that [`&str`]s are valid UTF-8.\n///\n/// [`&str`]: ../../std/primitive.str.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::str;\n///\n/// // some bytes, in a vector\n/// let sparkle_heart = vec![240, 159, 146, 150];\n///\n/// let sparkle_heart = unsafe {\n///     str::from_utf8_unchecked(&sparkle_heart)\n/// };\n///\n/// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn from_utf8_unchecked(v: &[u8]) -> &str {\n    &*(v as *const [u8] as *const str)\n}\n\n/// Converts a slice of bytes to a string slice without checking\n/// that the string contains valid UTF-8; mutable version.\n///\n/// See the immutable version, [`from_utf8_unchecked()`][fromutf8], for more information.\n///\n/// [fromutf8]: fn.from_utf8_unchecked.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::str;\n///\n/// let mut heart = vec![240, 159, 146, 150];\n/// let heart = unsafe { str::from_utf8_unchecked_mut(&mut heart) };\n///\n/// assert_eq!(\"\ud83d\udc96\", heart);\n/// ```\n#[inline]\n#[stable(feature = \"str_mut_extras\", since = \"1.20.0\")]\npub unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str {\n    &mut *(v as *mut [u8] as *mut str)\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for Utf8Error {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        if let Some(error_len) = self.error_len {\n            write!(f, \"invalid utf-8 sequence of {} bytes from index {}\",\n                   error_len, self.valid_up_to)\n        } else {\n            write!(f, \"incomplete utf-8 byte sequence from index {}\", self.valid_up_to)\n        }\n    }\n}\n\n/*\nSection: Iterators\n*/\n\n/// An iterator over the [`char`]s of a string slice.\n///\n/// [`char`]: ../../std/primitive.char.html\n///\n/// This struct is created by the [`chars`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`chars`]: ../../std/primitive.str.html#method.chars\n/// [`str`]: ../../std/primitive.str.html\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Chars<'a> {\n    iter: slice::Iter<'a, u8>\n}\n\n/// Returns the initial codepoint accumulator for the first byte.\n/// The first byte is special, only want bottom 5 bits for width 2, 4 bits\n/// for width 3, and 3 bits for width 4.\n#[inline]\nfn utf8_first_byte(byte: u8, width: u32) -> u32 { (byte & (0x7F >> width)) as u32 }\n\n/// Returns the value of `ch` updated with continuation byte `byte`.\n#[inline]\nfn utf8_acc_cont_byte(ch: u32, byte: u8) -> u32 { (ch << 6) | (byte & CONT_MASK) as u32 }\n\n/// Checks whether the byte is a UTF-8 continuation byte (i.e. starts with the\n/// bits `10`).\n#[inline]\nfn utf8_is_cont_byte(byte: u8) -> bool { (byte & !CONT_MASK) == TAG_CONT_U8 }\n\n#[inline]\nfn unwrap_or_0(opt: Option<&u8>) -> u8 {\n    match opt {\n        Some(&byte) => byte,\n        None => 0,\n    }\n}\n\n/// Reads the next code point out of a byte iterator (assuming a\n/// UTF-8-like encoding).\n#[unstable(feature = \"str_internals\", issue = \"0\")]\n#[inline]\npub fn next_code_point<'a, I: Iterator<Item = &'a u8>>(bytes: &mut I) -> Option<u32> {\n    // Decode UTF-8\n    let x = *bytes.next()?;\n    if x < 128 {\n        return Some(x as u32)\n    }\n\n    // Multibyte case follows\n    // Decode from a byte combination out of: [[[x y] z] w]\n    // NOTE: Performance is sensitive to the exact formulation here\n    let init = utf8_first_byte(x, 2);\n    let y = unwrap_or_0(bytes.next());\n    let mut ch = utf8_acc_cont_byte(init, y);\n    if x >= 0xE0 {\n        // [[x y z] w] case\n        // 5th bit in 0xE0 .. 0xEF is always clear, so `init` is still valid\n        let z = unwrap_or_0(bytes.next());\n        let y_z = utf8_acc_cont_byte((y & CONT_MASK) as u32, z);\n        ch = init << 12 | y_z;\n        if x >= 0xF0 {\n            // [x y z w] case\n            // use only the lower 3 bits of `init`\n            let w = unwrap_or_0(bytes.next());\n            ch = (init & 7) << 18 | utf8_acc_cont_byte(y_z, w);\n        }\n    }\n\n    Some(ch)\n}\n\n/// Reads the last code point out of a byte iterator (assuming a\n/// UTF-8-like encoding).\n#[inline]\nfn next_code_point_reverse<'a, I>(bytes: &mut I) -> Option<u32>\n    where I: DoubleEndedIterator<Item = &'a u8>,\n{\n    // Decode UTF-8\n    let w = match bytes.next_back() {\n        None => return None,\n        Some(&next_byte) if next_byte < 128 => return Some(next_byte as u32),\n        Some(&back_byte) => back_byte,\n    };\n\n    // Multibyte case follows\n    // Decode from a byte combination out of: [x [y [z w]]]\n    let mut ch;\n    let z = unwrap_or_0(bytes.next_back());\n    ch = utf8_first_byte(z, 2);\n    if utf8_is_cont_byte(z) {\n        let y = unwrap_or_0(bytes.next_back());\n        ch = utf8_first_byte(y, 3);\n        if utf8_is_cont_byte(y) {\n            let x = unwrap_or_0(bytes.next_back());\n            ch = utf8_first_byte(x, 4);\n            ch = utf8_acc_cont_byte(ch, y);\n        }\n        ch = utf8_acc_cont_byte(ch, z);\n    }\n    ch = utf8_acc_cont_byte(ch, w);\n\n    Some(ch)\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for Chars<'a> {\n    type Item = char;\n\n    #[inline]\n    fn next(&mut self) -> Option<char> {\n        next_code_point(&mut self.iter).map(|ch| {\n            // str invariant says `ch` is a valid Unicode Scalar Value\n            unsafe {\n                char::from_u32_unchecked(ch)\n            }\n        })\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        // length in `char` is equal to the number of non-continuation bytes\n        let bytes_len = self.iter.len();\n        let mut cont_bytes = 0;\n        for &byte in self.iter {\n            cont_bytes += utf8_is_cont_byte(byte) as usize;\n        }\n        bytes_len - cont_bytes\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let len = self.iter.len();\n        // `(len + 3)` can't overflow, because we know that the `slice::Iter`\n        // belongs to a slice in memory which has a maximum length of\n        // `isize::MAX` (that's well below `usize::MAX`).\n        ((len + 3) / 4, Some(len))\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<char> {\n        // No need to go through the entire string.\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> DoubleEndedIterator for Chars<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<char> {\n        next_code_point_reverse(&mut self.iter).map(|ch| {\n            // str invariant says `ch` is a valid Unicode Scalar Value\n            unsafe {\n                char::from_u32_unchecked(ch)\n            }\n        })\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for Chars<'_> {}\n\nimpl<'a> Chars<'a> {\n    /// View the underlying data as a subslice of the original data.\n    ///\n    /// This has the same lifetime as the original slice, and so the\n    /// iterator can continue to be used while this exists.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut chars = \"abc\".chars();\n    ///\n    /// assert_eq!(chars.as_str(), \"abc\");\n    /// chars.next();\n    /// assert_eq!(chars.as_str(), \"bc\");\n    /// chars.next();\n    /// chars.next();\n    /// assert_eq!(chars.as_str(), \"\");\n    /// ```\n    #[stable(feature = \"iter_to_slice\", since = \"1.4.0\")]\n    #[inline]\n    pub fn as_str(&self) -> &'a str {\n        unsafe { from_utf8_unchecked(self.iter.as_slice()) }\n    }\n}\n\n/// An iterator over the [`char`]s of a string slice, and their positions.\n///\n/// [`char`]: ../../std/primitive.char.html\n///\n/// This struct is created by the [`char_indices`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`char_indices`]: ../../std/primitive.str.html#method.char_indices\n/// [`str`]: ../../std/primitive.str.html\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct CharIndices<'a> {\n    front_offset: usize,\n    iter: Chars<'a>,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for CharIndices<'a> {\n    type Item = (usize, char);\n\n    #[inline]\n    fn next(&mut self) -> Option<(usize, char)> {\n        let pre_len = self.iter.iter.len();\n        match self.iter.next() {\n            None => None,\n            Some(ch) => {\n                let index = self.front_offset;\n                let len = self.iter.iter.len();\n                self.front_offset += pre_len - len;\n                Some((index, ch))\n            }\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.iter.count()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<(usize, char)> {\n        // No need to go through the entire string.\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> DoubleEndedIterator for CharIndices<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<(usize, char)> {\n        self.iter.next_back().map(|ch| {\n            let index = self.front_offset + self.iter.iter.len();\n            (index, ch)\n        })\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for CharIndices<'_> {}\n\nimpl<'a> CharIndices<'a> {\n    /// View the underlying data as a subslice of the original data.\n    ///\n    /// This has the same lifetime as the original slice, and so the\n    /// iterator can continue to be used while this exists.\n    #[stable(feature = \"iter_to_slice\", since = \"1.4.0\")]\n    #[inline]\n    pub fn as_str(&self) -> &'a str {\n        self.iter.as_str()\n    }\n}\n\n/// An iterator over the bytes of a string slice.\n///\n/// This struct is created by the [`bytes`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`bytes`]: ../../std/primitive.str.html#method.bytes\n/// [`str`]: ../../std/primitive.str.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone, Debug)]\npub struct Bytes<'a>(Cloned<slice::Iter<'a, u8>>);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for Bytes<'_> {\n    type Item = u8;\n\n    #[inline]\n    fn next(&mut self) -> Option<u8> {\n        self.0.next()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.0.size_hint()\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.0.count()\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        self.0.last()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        self.0.nth(n)\n    }\n\n    #[inline]\n    fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool {\n        self.0.all(f)\n    }\n\n    #[inline]\n    fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool {\n        self.0.any(f)\n    }\n\n    #[inline]\n    fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where\n        P: FnMut(&Self::Item) -> bool\n    {\n        self.0.find(predicate)\n    }\n\n    #[inline]\n    fn position<P>(&mut self, predicate: P) -> Option<usize> where\n        P: FnMut(Self::Item) -> bool\n    {\n        self.0.position(predicate)\n    }\n\n    #[inline]\n    fn rposition<P>(&mut self, predicate: P) -> Option<usize> where\n        P: FnMut(Self::Item) -> bool\n    {\n        self.0.rposition(predicate)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl DoubleEndedIterator for Bytes<'_> {\n    #[inline]\n    fn next_back(&mut self) -> Option<u8> {\n        self.0.next_back()\n    }\n\n    #[inline]\n    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where\n        P: FnMut(&Self::Item) -> bool\n    {\n        self.0.rfind(predicate)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ExactSizeIterator for Bytes<'_> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.0.len()\n    }\n\n    #[inline]\n    fn is_empty(&self) -> bool {\n        self.0.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for Bytes<'_> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl TrustedLen for Bytes<'_> {}\n\n#[doc(hidden)]\nunsafe impl<'a> TrustedRandomAccess for Bytes<'a> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> u8 {\n        self.0.get_unchecked(i)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// This macro generates a Clone impl for string pattern API\n/// wrapper types of the form X<'a, P>\nmacro_rules! derive_pattern_clone {\n    (clone $t:ident with |$s:ident| $e:expr) => {\n        impl<'a, P: Pattern<'a>> Clone for $t<'a, P>\n            where P::Searcher: Clone\n        {\n            fn clone(&self) -> Self {\n                let $s = self;\n                $e\n            }\n        }\n    }\n}\n\n/// This macro generates two public iterator structs\n/// wrapping a private internal one that makes use of the `Pattern` API.\n///\n/// For all patterns `P: Pattern<'a>` the following items will be\n/// generated (generics omitted):\n///\n/// struct $forward_iterator($internal_iterator);\n/// struct $reverse_iterator($internal_iterator);\n///\n/// impl Iterator for $forward_iterator\n/// { /* internal ends up calling Searcher::next_match() */ }\n///\n/// impl DoubleEndedIterator for $forward_iterator\n///       where P::Searcher: DoubleEndedSearcher\n/// { /* internal ends up calling Searcher::next_match_back() */ }\n///\n/// impl Iterator for $reverse_iterator\n///       where P::Searcher: ReverseSearcher\n/// { /* internal ends up calling Searcher::next_match_back() */ }\n///\n/// impl DoubleEndedIterator for $reverse_iterator\n///       where P::Searcher: DoubleEndedSearcher\n/// { /* internal ends up calling Searcher::next_match() */ }\n///\n/// The internal one is defined outside the macro, and has almost the same\n/// semantic as a DoubleEndedIterator by delegating to `pattern::Searcher` and\n/// `pattern::ReverseSearcher` for both forward and reverse iteration.\n///\n/// \"Almost\", because a `Searcher` and a `ReverseSearcher` for a given\n/// `Pattern` might not return the same elements, so actually implementing\n/// `DoubleEndedIterator` for it would be incorrect.\n/// (See the docs in `str::pattern` for more details)\n///\n/// However, the internal struct still represents a single ended iterator from\n/// either end, and depending on pattern is also a valid double ended iterator,\n/// so the two wrapper structs implement `Iterator`\n/// and `DoubleEndedIterator` depending on the concrete pattern type, leading\n/// to the complex impls seen above.\nmacro_rules! generate_pattern_iterators {\n    {\n        // Forward iterator\n        forward:\n            $(#[$forward_iterator_attribute:meta])*\n            struct $forward_iterator:ident;\n\n        // Reverse iterator\n        reverse:\n            $(#[$reverse_iterator_attribute:meta])*\n            struct $reverse_iterator:ident;\n\n        // Stability of all generated items\n        stability:\n            $(#[$common_stability_attribute:meta])*\n\n        // Internal almost-iterator that is being delegated to\n        internal:\n            $internal_iterator:ident yielding ($iterty:ty);\n\n        // Kind of delegation - either single ended or double ended\n        delegate $($t:tt)*\n    } => {\n        $(#[$forward_iterator_attribute])*\n        $(#[$common_stability_attribute])*\n        pub struct $forward_iterator<'a, P: Pattern<'a>>($internal_iterator<'a, P>);\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> fmt::Debug for $forward_iterator<'a, P>\n            where P::Searcher: fmt::Debug\n        {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                f.debug_tuple(stringify!($forward_iterator))\n                    .field(&self.0)\n                    .finish()\n            }\n        }\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> Iterator for $forward_iterator<'a, P> {\n            type Item = $iterty;\n\n            #[inline]\n            fn next(&mut self) -> Option<$iterty> {\n                self.0.next()\n            }\n        }\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> Clone for $forward_iterator<'a, P>\n            where P::Searcher: Clone\n        {\n            fn clone(&self) -> Self {\n                $forward_iterator(self.0.clone())\n            }\n        }\n\n        $(#[$reverse_iterator_attribute])*\n        $(#[$common_stability_attribute])*\n        pub struct $reverse_iterator<'a, P: Pattern<'a>>($internal_iterator<'a, P>);\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> fmt::Debug for $reverse_iterator<'a, P>\n            where P::Searcher: fmt::Debug\n        {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                f.debug_tuple(stringify!($reverse_iterator))\n                    .field(&self.0)\n                    .finish()\n            }\n        }\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> Iterator for $reverse_iterator<'a, P>\n            where P::Searcher: ReverseSearcher<'a>\n        {\n            type Item = $iterty;\n\n            #[inline]\n            fn next(&mut self) -> Option<$iterty> {\n                self.0.next_back()\n            }\n        }\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> Clone for $reverse_iterator<'a, P>\n            where P::Searcher: Clone\n        {\n            fn clone(&self) -> Self {\n                $reverse_iterator(self.0.clone())\n            }\n        }\n\n        #[stable(feature = \"fused\", since = \"1.26.0\")]\n        impl<'a, P: Pattern<'a>> FusedIterator for $forward_iterator<'a, P> {}\n\n        #[stable(feature = \"fused\", since = \"1.26.0\")]\n        impl<'a, P: Pattern<'a>> FusedIterator for $reverse_iterator<'a, P>\n            where P::Searcher: ReverseSearcher<'a> {}\n\n        generate_pattern_iterators!($($t)* with $(#[$common_stability_attribute])*,\n                                                $forward_iterator,\n                                                $reverse_iterator, $iterty);\n    };\n    {\n        double ended; with $(#[$common_stability_attribute:meta])*,\n                           $forward_iterator:ident,\n                           $reverse_iterator:ident, $iterty:ty\n    } => {\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> DoubleEndedIterator for $forward_iterator<'a, P>\n            where P::Searcher: DoubleEndedSearcher<'a>\n        {\n            #[inline]\n            fn next_back(&mut self) -> Option<$iterty> {\n                self.0.next_back()\n            }\n        }\n\n        $(#[$common_stability_attribute])*\n        impl<'a, P: Pattern<'a>> DoubleEndedIterator for $reverse_iterator<'a, P>\n            where P::Searcher: DoubleEndedSearcher<'a>\n        {\n            #[inline]\n            fn next_back(&mut self) -> Option<$iterty> {\n                self.0.next()\n            }\n        }\n    };\n    {\n        single ended; with $(#[$common_stability_attribute:meta])*,\n                           $forward_iterator:ident,\n                           $reverse_iterator:ident, $iterty:ty\n    } => {}\n}\n\nderive_pattern_clone!{\n    clone SplitInternal\n    with |s| SplitInternal { matcher: s.matcher.clone(), ..*s }\n}\n\nstruct SplitInternal<'a, P: Pattern<'a>> {\n    start: usize,\n    end: usize,\n    matcher: P::Searcher,\n    allow_trailing_empty: bool,\n    finished: bool,\n}\n\nimpl<'a, P: Pattern<'a>> fmt::Debug for SplitInternal<'a, P> where P::Searcher: fmt::Debug {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SplitInternal\")\n            .field(\"start\", &self.start)\n            .field(\"end\", &self.end)\n            .field(\"matcher\", &self.matcher)\n            .field(\"allow_trailing_empty\", &self.allow_trailing_empty)\n            .field(\"finished\", &self.finished)\n            .finish()\n    }\n}\n\nimpl<'a, P: Pattern<'a>> SplitInternal<'a, P> {\n    #[inline]\n    fn get_end(&mut self) -> Option<&'a str> {\n        if !self.finished && (self.allow_trailing_empty || self.end - self.start > 0) {\n            self.finished = true;\n            unsafe {\n                let string = self.matcher.haystack().get_unchecked(self.start..self.end);\n                Some(string)\n            }\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        if self.finished { return None }\n\n        let haystack = self.matcher.haystack();\n        match self.matcher.next_match() {\n            Some((a, b)) => unsafe {\n                let elt = haystack.get_unchecked(self.start..a);\n                self.start = b;\n                Some(elt)\n            },\n            None => self.get_end(),\n        }\n    }\n\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        if self.finished { return None }\n\n        if !self.allow_trailing_empty {\n            self.allow_trailing_empty = true;\n            match self.next_back() {\n                Some(elt) if !elt.is_empty() => return Some(elt),\n                _ => if self.finished { return None }\n            }\n        }\n\n        let haystack = self.matcher.haystack();\n        match self.matcher.next_match_back() {\n            Some((a, b)) => unsafe {\n                let elt = haystack.get_unchecked(b..self.end);\n                self.end = a;\n                Some(elt)\n            },\n            None => unsafe {\n                self.finished = true;\n                Some(haystack.get_unchecked(self.start..self.end))\n            },\n        }\n    }\n}\n\ngenerate_pattern_iterators! {\n    forward:\n        /// Created with the method [`split`].\n        ///\n        /// [`split`]: ../../std/primitive.str.html#method.split\n        struct Split;\n    reverse:\n        /// Created with the method [`rsplit`].\n        ///\n        /// [`rsplit`]: ../../std/primitive.str.html#method.rsplit\n        struct RSplit;\n    stability:\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    internal:\n        SplitInternal yielding (&'a str);\n    delegate double ended;\n}\n\ngenerate_pattern_iterators! {\n    forward:\n        /// Created with the method [`split_terminator`].\n        ///\n        /// [`split_terminator`]: ../../std/primitive.str.html#method.split_terminator\n        struct SplitTerminator;\n    reverse:\n        /// Created with the method [`rsplit_terminator`].\n        ///\n        /// [`rsplit_terminator`]: ../../std/primitive.str.html#method.rsplit_terminator\n        struct RSplitTerminator;\n    stability:\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    internal:\n        SplitInternal yielding (&'a str);\n    delegate double ended;\n}\n\nderive_pattern_clone!{\n    clone SplitNInternal\n    with |s| SplitNInternal { iter: s.iter.clone(), ..*s }\n}\n\nstruct SplitNInternal<'a, P: Pattern<'a>> {\n    iter: SplitInternal<'a, P>,\n    /// The number of splits remaining\n    count: usize,\n}\n\nimpl<'a, P: Pattern<'a>> fmt::Debug for SplitNInternal<'a, P> where P::Searcher: fmt::Debug {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SplitNInternal\")\n            .field(\"iter\", &self.iter)\n            .field(\"count\", &self.count)\n            .finish()\n    }\n}\n\nimpl<'a, P: Pattern<'a>> SplitNInternal<'a, P> {\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        match self.count {\n            0 => None,\n            1 => { self.count = 0; self.iter.get_end() }\n            _ => { self.count -= 1; self.iter.next() }\n        }\n    }\n\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        match self.count {\n            0 => None,\n            1 => { self.count = 0; self.iter.get_end() }\n            _ => { self.count -= 1; self.iter.next_back() }\n        }\n    }\n}\n\ngenerate_pattern_iterators! {\n    forward:\n        /// Created with the method [`splitn`].\n        ///\n        /// [`splitn`]: ../../std/primitive.str.html#method.splitn\n        struct SplitN;\n    reverse:\n        /// Created with the method [`rsplitn`].\n        ///\n        /// [`rsplitn`]: ../../std/primitive.str.html#method.rsplitn\n        struct RSplitN;\n    stability:\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    internal:\n        SplitNInternal yielding (&'a str);\n    delegate single ended;\n}\n\nderive_pattern_clone!{\n    clone MatchIndicesInternal\n    with |s| MatchIndicesInternal(s.0.clone())\n}\n\nstruct MatchIndicesInternal<'a, P: Pattern<'a>>(P::Searcher);\n\nimpl<'a, P: Pattern<'a>> fmt::Debug for MatchIndicesInternal<'a, P> where P::Searcher: fmt::Debug {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"MatchIndicesInternal\")\n            .field(&self.0)\n            .finish()\n    }\n}\n\nimpl<'a, P: Pattern<'a>> MatchIndicesInternal<'a, P> {\n    #[inline]\n    fn next(&mut self) -> Option<(usize, &'a str)> {\n        self.0.next_match().map(|(start, end)| unsafe {\n            (start, self.0.haystack().get_unchecked(start..end))\n        })\n    }\n\n    #[inline]\n    fn next_back(&mut self) -> Option<(usize, &'a str)>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        self.0.next_match_back().map(|(start, end)| unsafe {\n            (start, self.0.haystack().get_unchecked(start..end))\n        })\n    }\n}\n\ngenerate_pattern_iterators! {\n    forward:\n        /// Created with the method [`match_indices`].\n        ///\n        /// [`match_indices`]: ../../std/primitive.str.html#method.match_indices\n        struct MatchIndices;\n    reverse:\n        /// Created with the method [`rmatch_indices`].\n        ///\n        /// [`rmatch_indices`]: ../../std/primitive.str.html#method.rmatch_indices\n        struct RMatchIndices;\n    stability:\n        #[stable(feature = \"str_match_indices\", since = \"1.5.0\")]\n    internal:\n        MatchIndicesInternal yielding ((usize, &'a str));\n    delegate double ended;\n}\n\nderive_pattern_clone!{\n    clone MatchesInternal\n    with |s| MatchesInternal(s.0.clone())\n}\n\nstruct MatchesInternal<'a, P: Pattern<'a>>(P::Searcher);\n\nimpl<'a, P: Pattern<'a>> fmt::Debug for MatchesInternal<'a, P> where P::Searcher: fmt::Debug {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"MatchesInternal\")\n            .field(&self.0)\n            .finish()\n    }\n}\n\nimpl<'a, P: Pattern<'a>> MatchesInternal<'a, P> {\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        self.0.next_match().map(|(a, b)| unsafe {\n            // Indices are known to be on utf8 boundaries\n            self.0.haystack().get_unchecked(a..b)\n        })\n    }\n\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        self.0.next_match_back().map(|(a, b)| unsafe {\n            // Indices are known to be on utf8 boundaries\n            self.0.haystack().get_unchecked(a..b)\n        })\n    }\n}\n\ngenerate_pattern_iterators! {\n    forward:\n        /// Created with the method [`matches`].\n        ///\n        /// [`matches`]: ../../std/primitive.str.html#method.matches\n        struct Matches;\n    reverse:\n        /// Created with the method [`rmatches`].\n        ///\n        /// [`rmatches`]: ../../std/primitive.str.html#method.rmatches\n        struct RMatches;\n    stability:\n        #[stable(feature = \"str_matches\", since = \"1.2.0\")]\n    internal:\n        MatchesInternal yielding (&'a str);\n    delegate double ended;\n}\n\n/// An iterator over the lines of a string, as string slices.\n///\n/// This struct is created with the [`lines`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`lines`]: ../../std/primitive.str.html#method.lines\n/// [`str`]: ../../std/primitive.str.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone, Debug)]\npub struct Lines<'a>(Map<SplitTerminator<'a, char>, LinesAnyMap>);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for Lines<'a> {\n    type Item = &'a str;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        self.0.next()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.0.size_hint()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> DoubleEndedIterator for Lines<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str> {\n        self.0.next_back()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for Lines<'_> {}\n\n/// Created with the method [`lines_any`].\n///\n/// [`lines_any`]: ../../std/primitive.str.html#method.lines_any\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(since = \"1.4.0\", reason = \"use lines()/Lines instead now\")]\n#[derive(Clone, Debug)]\n#[allow(deprecated)]\npub struct LinesAny<'a>(Lines<'a>);\n\n/// A nameable, cloneable fn type\n#[derive(Clone)]\nstruct LinesAnyMap;\n\nimpl<'a> Fn<(&'a str,)> for LinesAnyMap {\n    #[inline]\n    extern \"rust-call\" fn call(&self, (line,): (&'a str,)) -> &'a str {\n        let l = line.len();\n        if l > 0 && line.as_bytes()[l - 1] == b'\\r' { &line[0 .. l - 1] }\n        else { line }\n    }\n}\n\nimpl<'a> FnMut<(&'a str,)> for LinesAnyMap {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, (line,): (&'a str,)) -> &'a str {\n        Fn::call(&*self, (line,))\n    }\n}\n\nimpl<'a> FnOnce<(&'a str,)> for LinesAnyMap {\n    type Output = &'a str;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(self, (line,): (&'a str,)) -> &'a str {\n        Fn::call(&self, (line,))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow(deprecated)]\nimpl<'a> Iterator for LinesAny<'a> {\n    type Item = &'a str;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        self.0.next()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.0.size_hint()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow(deprecated)]\nimpl<'a> DoubleEndedIterator for LinesAny<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str> {\n        self.0.next_back()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\n#[allow(deprecated)]\nimpl FusedIterator for LinesAny<'_> {}\n\n/*\nSection: UTF-8 validation\n*/\n\n// use truncation to fit u64 into usize\nconst NONASCII_MASK: usize = 0x80808080_80808080u64 as usize;\n\n/// Returns `true` if any byte in the word `x` is nonascii (>= 128).\n#[inline]\nfn contains_nonascii(x: usize) -> bool {\n    (x & NONASCII_MASK) != 0\n}\n\n/// Walks through `iter` checking that it's a valid UTF-8 sequence,\n/// returning `true` in that case, or, if it is invalid, `false` with\n/// `iter` reset such that it is pointing at the first byte in the\n/// invalid sequence.\n#[inline]\nfn run_utf8_validation(v: &[u8]) -> Result<(), Utf8Error> {\n    let mut index = 0;\n    let len = v.len();\n\n    let usize_bytes = mem::size_of::<usize>();\n    let ascii_block_size = 2 * usize_bytes;\n    let blocks_end = if len >= ascii_block_size { len - ascii_block_size + 1 } else { 0 };\n\n    while index < len {\n        let old_offset = index;\n        macro_rules! err {\n            ($error_len: expr) => {\n                return Err(Utf8Error {\n                    valid_up_to: old_offset,\n                    error_len: $error_len,\n                })\n            }\n        }\n\n        macro_rules! next { () => {{\n            index += 1;\n            // we needed data, but there was none: error!\n            if index >= len {\n                err!(None)\n            }\n            v[index]\n        }}}\n\n        let first = v[index];\n        if first >= 128 {\n            let w = UTF8_CHAR_WIDTH[first as usize];\n            // 2-byte encoding is for codepoints  \\u{0080} to  \\u{07ff}\n            //        first  C2 80        last DF BF\n            // 3-byte encoding is for codepoints  \\u{0800} to  \\u{ffff}\n            //        first  E0 A0 80     last EF BF BF\n            //   excluding surrogates codepoints  \\u{d800} to  \\u{dfff}\n            //               ED A0 80 to       ED BF BF\n            // 4-byte encoding is for codepoints \\u{1000}0 to \\u{10ff}ff\n            //        first  F0 90 80 80  last F4 8F BF BF\n            //\n            // Use the UTF-8 syntax from the RFC\n            //\n            // https://tools.ietf.org/html/rfc3629\n            // UTF8-1      = %x00-7F\n            // UTF8-2      = %xC2-DF UTF8-tail\n            // UTF8-3      = %xE0 %xA0-BF UTF8-tail / %xE1-EC 2( UTF8-tail ) /\n            //               %xED %x80-9F UTF8-tail / %xEE-EF 2( UTF8-tail )\n            // UTF8-4      = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /\n            //               %xF4 %x80-8F 2( UTF8-tail )\n            match w {\n                2 => if next!() & !CONT_MASK != TAG_CONT_U8 {\n                    err!(Some(1))\n                },\n                3 => {\n                    match (first, next!()) {\n                        (0xE0         , 0xA0 ..= 0xBF) |\n                        (0xE1 ..= 0xEC, 0x80 ..= 0xBF) |\n                        (0xED         , 0x80 ..= 0x9F) |\n                        (0xEE ..= 0xEF, 0x80 ..= 0xBF) => {}\n                        _ => err!(Some(1))\n                    }\n                    if next!() & !CONT_MASK != TAG_CONT_U8 {\n                        err!(Some(2))\n                    }\n                }\n                4 => {\n                    match (first, next!()) {\n                        (0xF0         , 0x90 ..= 0xBF) |\n                        (0xF1 ..= 0xF3, 0x80 ..= 0xBF) |\n                        (0xF4         , 0x80 ..= 0x8F) => {}\n                        _ => err!(Some(1))\n                    }\n                    if next!() & !CONT_MASK != TAG_CONT_U8 {\n                        err!(Some(2))\n                    }\n                    if next!() & !CONT_MASK != TAG_CONT_U8 {\n                        err!(Some(3))\n                    }\n                }\n                _ => err!(Some(1))\n            }\n            index += 1;\n        } else {\n            // Ascii case, try to skip forward quickly.\n            // When the pointer is aligned, read 2 words of data per iteration\n            // until we find a word containing a non-ascii byte.\n            let ptr = v.as_ptr();\n            let align = unsafe {\n                // the offset is safe, because `index` is guaranteed inbounds\n                ptr.add(index).align_offset(usize_bytes)\n            };\n            if align == 0 {\n                while index < blocks_end {\n                    unsafe {\n                        let block = ptr.add(index) as *const usize;\n                        // break if there is a nonascii byte\n                        let zu = contains_nonascii(*block);\n                        let zv = contains_nonascii(*block.offset(1));\n                        if zu | zv {\n                            break;\n                        }\n                    }\n                    index += ascii_block_size;\n                }\n                // step from the point where the wordwise loop stopped\n                while index < len && v[index] < 128 {\n                    index += 1;\n                }\n            } else {\n                index += 1;\n            }\n        }\n    }\n\n    Ok(())\n}\n\n// https://tools.ietf.org/html/rfc3629\nstatic UTF8_CHAR_WIDTH: [u8; 256] = [\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x3F\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x5F\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,\n1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x7F\n0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0x9F\n0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,\n0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xBF\n0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,\n2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // 0xDF\n3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, // 0xEF\n4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF\n];\n\n/// Given a first byte, determines how many bytes are in this UTF-8 character.\n#[unstable(feature = \"str_internals\", issue = \"0\")]\n#[inline]\npub fn utf8_char_width(b: u8) -> usize {\n    UTF8_CHAR_WIDTH[b as usize] as usize\n}\n\n/// Mask of the value bits of a continuation byte.\nconst CONT_MASK: u8 = 0b0011_1111;\n/// Value of the tag bits (tag mask is !CONT_MASK) of a continuation byte.\nconst TAG_CONT_U8: u8 = 0b1000_0000;\n\n/*\nSection: Trait implementations\n*/\n\nmod traits {\n    use cmp::Ordering;\n    use ops;\n    use slice::{self, SliceIndex};\n\n    /// Implements ordering of strings.\n    ///\n    /// Strings are ordered  lexicographically by their byte values.  This orders Unicode code\n    /// points based on their positions in the code charts.  This is not necessarily the same as\n    /// \"alphabetical\" order, which varies by language and locale.  Sorting strings according to\n    /// culturally-accepted standards requires locale-specific data that is outside the scope of\n    /// the `str` type.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl Ord for str {\n        #[inline]\n        fn cmp(&self, other: &str) -> Ordering {\n            self.as_bytes().cmp(other.as_bytes())\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl PartialEq for str {\n        #[inline]\n        fn eq(&self, other: &str) -> bool {\n            self.as_bytes() == other.as_bytes()\n        }\n        #[inline]\n        fn ne(&self, other: &str) -> bool { !(*self).eq(other) }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl Eq for str {}\n\n    /// Implements comparison operations on strings.\n    ///\n    /// Strings are compared lexicographically by their byte values.  This compares Unicode code\n    /// points based on their positions in the code charts.  This is not necessarily the same as\n    /// \"alphabetical\" order, which varies by language and locale.  Comparing strings according to\n    /// culturally-accepted standards requires locale-specific data that is outside the scope of\n    /// the `str` type.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl PartialOrd for str {\n        #[inline]\n        fn partial_cmp(&self, other: &str) -> Option<Ordering> {\n            Some(self.cmp(other))\n        }\n    }\n\n    /// Implements substring slicing with syntax `&self[begin .. end]`.\n    ///\n    /// Returns a slice of the given string from the byte range\n    /// [`begin`..`end`).\n    ///\n    /// This operation is `O(1)`.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `begin` or `end` does not point to the starting\n    /// byte offset of a character (as defined by `is_char_boundary`).\n    /// Requires that `begin <= end` and `end <= len` where `len` is the\n    /// length of the string.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    /// assert_eq!(&s[0 .. 1], \"L\");\n    ///\n    /// assert_eq!(&s[1 .. 9], \"\u00f6we \u8001\");\n    ///\n    /// // these will panic:\n    /// // byte 2 lies within `\u00f6`:\n    /// // &s[2 ..3];\n    ///\n    /// // byte 8 lies within `\u8001`\n    /// // &s[1 .. 8];\n    ///\n    /// // byte 100 is outside the string\n    /// // &s[3 .. 100];\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl ops::Index<ops::Range<usize>> for str {\n        type Output = str;\n        #[inline]\n        fn index(&self, index: ops::Range<usize>) -> &str {\n            index.index(self)\n        }\n    }\n\n    /// Implements mutable substring slicing with syntax\n    /// `&mut self[begin .. end]`.\n    ///\n    /// Returns a mutable slice of the given string from the byte range\n    /// [`begin`..`end`).\n    ///\n    /// This operation is `O(1)`.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `begin` or `end` does not point to the starting\n    /// byte offset of a character (as defined by `is_char_boundary`).\n    /// Requires that `begin <= end` and `end <= len` where `len` is the\n    /// length of the string.\n    #[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\n    impl ops::IndexMut<ops::Range<usize>> for str {\n        #[inline]\n        fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {\n            index.index_mut(self)\n        }\n    }\n\n    /// Implements substring slicing with syntax `&self[.. end]`.\n    ///\n    /// Returns a slice of the string from the beginning to byte offset\n    /// `end`.\n    ///\n    /// Equivalent to `&self[0 .. end]`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl ops::Index<ops::RangeTo<usize>> for str {\n        type Output = str;\n\n        #[inline]\n        fn index(&self, index: ops::RangeTo<usize>) -> &str {\n            index.index(self)\n        }\n    }\n\n    /// Implements mutable substring slicing with syntax `&mut self[.. end]`.\n    ///\n    /// Returns a mutable slice of the string from the beginning to byte offset\n    /// `end`.\n    ///\n    /// Equivalent to `&mut self[0 .. end]`.\n    #[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\n    impl ops::IndexMut<ops::RangeTo<usize>> for str {\n        #[inline]\n        fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {\n            index.index_mut(self)\n        }\n    }\n\n    /// Implements substring slicing with syntax `&self[begin ..]`.\n    ///\n    /// Returns a slice of the string from byte offset `begin`\n    /// to the end of the string.\n    ///\n    /// Equivalent to `&self[begin .. len]`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl ops::Index<ops::RangeFrom<usize>> for str {\n        type Output = str;\n\n        #[inline]\n        fn index(&self, index: ops::RangeFrom<usize>) -> &str {\n            index.index(self)\n        }\n    }\n\n    /// Implements mutable substring slicing with syntax `&mut self[begin ..]`.\n    ///\n    /// Returns a mutable slice of the string from byte offset `begin`\n    /// to the end of the string.\n    ///\n    /// Equivalent to `&mut self[begin .. len]`.\n    #[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\n    impl ops::IndexMut<ops::RangeFrom<usize>> for str {\n        #[inline]\n        fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {\n            index.index_mut(self)\n        }\n    }\n\n    /// Implements substring slicing with syntax `&self[..]`.\n    ///\n    /// Returns a slice of the whole string. This operation can\n    /// never panic.\n    ///\n    /// Equivalent to `&self[0 .. len]`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl ops::Index<ops::RangeFull> for str {\n        type Output = str;\n\n        #[inline]\n        fn index(&self, _index: ops::RangeFull) -> &str {\n            self\n        }\n    }\n\n    /// Implements mutable substring slicing with syntax `&mut self[..]`.\n    ///\n    /// Returns a mutable slice of the whole string. This operation can\n    /// never panic.\n    ///\n    /// Equivalent to `&mut self[0 .. len]`.\n    #[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\n    impl ops::IndexMut<ops::RangeFull> for str {\n        #[inline]\n        fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {\n            self\n        }\n    }\n\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl ops::Index<ops::RangeInclusive<usize>> for str {\n        type Output = str;\n\n        #[inline]\n        fn index(&self, index: ops::RangeInclusive<usize>) -> &str {\n            index.index(self)\n        }\n    }\n\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl ops::Index<ops::RangeToInclusive<usize>> for str {\n        type Output = str;\n\n        #[inline]\n        fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {\n            index.index(self)\n        }\n    }\n\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl ops::IndexMut<ops::RangeInclusive<usize>> for str {\n        #[inline]\n        fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {\n            index.index_mut(self)\n        }\n    }\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl ops::IndexMut<ops::RangeToInclusive<usize>> for str {\n        #[inline]\n        fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {\n            index.index_mut(self)\n        }\n    }\n\n    #[inline(never)]\n    #[cold]\n    fn str_index_overflow_fail() -> ! {\n        panic!(\"attempted to index str up to maximum usize\");\n    }\n\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    impl SliceIndex<str> for ops::RangeFull {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            Some(slice)\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            Some(slice)\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            slice\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            slice\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            slice\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            slice\n        }\n    }\n\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    impl SliceIndex<str> for ops::Range<usize> {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            if self.start <= self.end &&\n               slice.is_char_boundary(self.start) &&\n               slice.is_char_boundary(self.end) {\n                Some(unsafe { self.get_unchecked(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            if self.start <= self.end &&\n               slice.is_char_boundary(self.start) &&\n               slice.is_char_boundary(self.end) {\n                Some(unsafe { self.get_unchecked_mut(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            let ptr = slice.as_ptr().add(self.start);\n            let len = self.end - self.start;\n            super::from_utf8_unchecked(slice::from_raw_parts(ptr, len))\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            let ptr = slice.as_ptr().add(self.start);\n            let len = self.end - self.start;\n            super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, len))\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            let (start, end) = (self.start, self.end);\n            self.get(slice).unwrap_or_else(|| super::slice_error_fail(slice, start, end))\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            // is_char_boundary checks that the index is in [0, .len()]\n            // canot reuse `get` as above, because of NLL trouble\n            if self.start <= self.end &&\n               slice.is_char_boundary(self.start) &&\n               slice.is_char_boundary(self.end) {\n                unsafe { self.get_unchecked_mut(slice) }\n            } else {\n                super::slice_error_fail(slice, self.start, self.end)\n            }\n        }\n    }\n\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    impl SliceIndex<str> for ops::RangeTo<usize> {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            if slice.is_char_boundary(self.end) {\n                Some(unsafe { self.get_unchecked(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            if slice.is_char_boundary(self.end) {\n                Some(unsafe { self.get_unchecked_mut(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            let ptr = slice.as_ptr();\n            super::from_utf8_unchecked(slice::from_raw_parts(ptr, self.end))\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            let ptr = slice.as_ptr();\n            super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, self.end))\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            let end = self.end;\n            self.get(slice).unwrap_or_else(|| super::slice_error_fail(slice, 0, end))\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            // is_char_boundary checks that the index is in [0, .len()]\n            if slice.is_char_boundary(self.end) {\n                unsafe { self.get_unchecked_mut(slice) }\n            } else {\n                super::slice_error_fail(slice, 0, self.end)\n            }\n        }\n    }\n\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    impl SliceIndex<str> for ops::RangeFrom<usize> {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            if slice.is_char_boundary(self.start) {\n                Some(unsafe { self.get_unchecked(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            if slice.is_char_boundary(self.start) {\n                Some(unsafe { self.get_unchecked_mut(slice) })\n            } else {\n                None\n            }\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            let ptr = slice.as_ptr().add(self.start);\n            let len = slice.len() - self.start;\n            super::from_utf8_unchecked(slice::from_raw_parts(ptr, len))\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            let ptr = slice.as_ptr().add(self.start);\n            let len = slice.len() - self.start;\n            super::from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr as *mut u8, len))\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            let (start, end) = (self.start, slice.len());\n            self.get(slice).unwrap_or_else(|| super::slice_error_fail(slice, start, end))\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            // is_char_boundary checks that the index is in [0, .len()]\n            if slice.is_char_boundary(self.start) {\n                unsafe { self.get_unchecked_mut(slice) }\n            } else {\n                super::slice_error_fail(slice, self.start, slice.len())\n            }\n        }\n    }\n\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl SliceIndex<str> for ops::RangeInclusive<usize> {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            if *self.end() == usize::max_value() { None }\n            else { (*self.start()..self.end()+1).get(slice) }\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            if *self.end() == usize::max_value() { None }\n            else { (*self.start()..self.end()+1).get_mut(slice) }\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            (*self.start()..self.end()+1).get_unchecked(slice)\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            (*self.start()..self.end()+1).get_unchecked_mut(slice)\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            if *self.end() == usize::max_value() { str_index_overflow_fail(); }\n            (*self.start()..self.end()+1).index(slice)\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            if *self.end() == usize::max_value() { str_index_overflow_fail(); }\n            (*self.start()..self.end()+1).index_mut(slice)\n        }\n    }\n\n\n\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    impl SliceIndex<str> for ops::RangeToInclusive<usize> {\n        type Output = str;\n        #[inline]\n        fn get(self, slice: &str) -> Option<&Self::Output> {\n            if self.end == usize::max_value() { None }\n            else { (..self.end+1).get(slice) }\n        }\n        #[inline]\n        fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output> {\n            if self.end == usize::max_value() { None }\n            else { (..self.end+1).get_mut(slice) }\n        }\n        #[inline]\n        unsafe fn get_unchecked(self, slice: &str) -> &Self::Output {\n            (..self.end+1).get_unchecked(slice)\n        }\n        #[inline]\n        unsafe fn get_unchecked_mut(self, slice: &mut str) -> &mut Self::Output {\n            (..self.end+1).get_unchecked_mut(slice)\n        }\n        #[inline]\n        fn index(self, slice: &str) -> &Self::Output {\n            if self.end == usize::max_value() { str_index_overflow_fail(); }\n            (..self.end+1).index(slice)\n        }\n        #[inline]\n        fn index_mut(self, slice: &mut str) -> &mut Self::Output {\n            if self.end == usize::max_value() { str_index_overflow_fail(); }\n            (..self.end+1).index_mut(slice)\n        }\n    }\n}\n\n// truncate `&str` to length at most equal to `max`\n// return `true` if it were truncated, and the new str.\nfn truncate_to_char_boundary(s: &str, mut max: usize) -> (bool, &str) {\n    if max >= s.len() {\n        (false, s)\n    } else {\n        while !s.is_char_boundary(max) {\n            max -= 1;\n        }\n        (true, &s[..max])\n    }\n}\n\n#[inline(never)]\n#[cold]\nfn slice_error_fail(s: &str, begin: usize, end: usize) -> ! {\n    const MAX_DISPLAY_LENGTH: usize = 256;\n    let (truncated, s_trunc) = truncate_to_char_boundary(s, MAX_DISPLAY_LENGTH);\n    let ellipsis = if truncated { \"[...]\" } else { \"\" };\n\n    // 1. out of bounds\n    if begin > s.len() || end > s.len() {\n        let oob_index = if begin > s.len() { begin } else { end };\n        panic!(\"byte index {} is out of bounds of `{}`{}\", oob_index, s_trunc, ellipsis);\n    }\n\n    // 2. begin <= end\n    assert!(begin <= end, \"begin <= end ({} <= {}) when slicing `{}`{}\",\n            begin, end, s_trunc, ellipsis);\n\n    // 3. character boundary\n    let index = if !s.is_char_boundary(begin) { begin } else { end };\n    // find the character\n    let mut char_start = index;\n    while !s.is_char_boundary(char_start) {\n        char_start -= 1;\n    }\n    // `char_start` must be less than len and a char boundary\n    let ch = s[char_start..].chars().next().unwrap();\n    let char_range = char_start .. char_start + ch.len_utf8();\n    panic!(\"byte index {} is not a char boundary; it is inside {:?} (bytes {:?}) of `{}`{}\",\n           index, ch, char_range, s_trunc, ellipsis);\n}\n\n#[lang = \"str\"]\n#[cfg(not(test))]\nimpl str {\n    /// Returns the length of `self`.\n    ///\n    /// This length is in bytes, not [`char`]s or graphemes. In other words,\n    /// it may not be what a human considers the length of the string.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let len = \"foo\".len();\n    /// assert_eq!(3, len);\n    ///\n    /// let len = \"\u0192oo\".len(); // fancy f!\n    /// assert_eq!(4, len);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    #[rustc_const_unstable(feature = \"const_str_len\")]\n    pub const fn len(&self) -> usize {\n        self.as_bytes().len()\n    }\n\n    /// Returns `true` if `self` has a length of zero bytes.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"\";\n    /// assert!(s.is_empty());\n    ///\n    /// let s = \"not empty\";\n    /// assert!(!s.is_empty());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature = \"const_str_len\")]\n    pub const fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n\n    /// Checks that `index`-th byte lies at the start and/or end of a\n    /// UTF-8 code point sequence.\n    ///\n    /// The start and end of the string (when `index == self.len()`) are\n    /// considered to be\n    /// boundaries.\n    ///\n    /// Returns `false` if `index` is greater than `self.len()`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    /// assert!(s.is_char_boundary(0));\n    /// // start of `\u8001`\n    /// assert!(s.is_char_boundary(6));\n    /// assert!(s.is_char_boundary(s.len()));\n    ///\n    /// // second byte of `\u00f6`\n    /// assert!(!s.is_char_boundary(2));\n    ///\n    /// // third byte of `\u8001`\n    /// assert!(!s.is_char_boundary(8));\n    /// ```\n    #[stable(feature = \"is_char_boundary\", since = \"1.9.0\")]\n    #[inline]\n    pub fn is_char_boundary(&self, index: usize) -> bool {\n        // 0 and len are always ok.\n        // Test for 0 explicitly so that it can optimize out the check\n        // easily and skip reading string data for that case.\n        if index == 0 || index == self.len() { return true; }\n        match self.as_bytes().get(index) {\n            None => false,\n            // This is bit magic equivalent to: b < 128 || b >= 192\n            Some(&b) => (b as i8) >= -0x40,\n        }\n    }\n\n    /// Converts a string slice to a byte slice. To convert the byte slice back\n    /// into a string slice, use the [`str::from_utf8`] function.\n    ///\n    /// [`str::from_utf8`]: ./str/fn.from_utf8.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let bytes = \"bors\".as_bytes();\n    /// assert_eq!(b\"bors\", bytes);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline(always)]\n    #[rustc_const_unstable(feature=\"const_str_as_bytes\")]\n    pub const fn as_bytes(&self) -> &[u8] {\n        union Slices<'a> {\n            str: &'a str,\n            slice: &'a [u8],\n        }\n        unsafe { Slices { str: self }.slice }\n    }\n\n    /// Converts a mutable string slice to a mutable byte slice. To convert the\n    /// mutable byte slice back into a mutable string slice, use the\n    /// [`str::from_utf8_mut`] function.\n    ///\n    /// [`str::from_utf8_mut`]: ./str/fn.from_utf8_mut.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"Hello\");\n    /// let bytes = unsafe { s.as_bytes_mut() };\n    ///\n    /// assert_eq!(b\"Hello\", bytes);\n    /// ```\n    ///\n    /// Mutability:\n    ///\n    /// ```\n    /// let mut s = String::from(\"\ud83d\uddfb\u2208\ud83c\udf0f\");\n    ///\n    /// unsafe {\n    ///     let bytes = s.as_bytes_mut();\n    ///\n    ///     bytes[0] = 0xF0;\n    ///     bytes[1] = 0x9F;\n    ///     bytes[2] = 0x8D;\n    ///     bytes[3] = 0x94;\n    /// }\n    ///\n    /// assert_eq!(\"\ud83c\udf54\u2208\ud83c\udf0f\", s);\n    /// ```\n    #[stable(feature = \"str_mut_extras\", since = \"1.20.0\")]\n    #[inline(always)]\n    pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] {\n        &mut *(self as *mut str as *mut [u8])\n    }\n\n    /// Converts a string slice to a raw pointer.\n    ///\n    /// As string slices are a slice of bytes, the raw pointer points to a\n    /// [`u8`]. This pointer will be pointing to the first byte of the string\n    /// slice.\n    ///\n    /// [`u8`]: primitive.u8.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"Hello\";\n    /// let ptr = s.as_ptr();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    #[rustc_const_unstable(feature = \"const_str_as_ptr\")]\n    pub const fn as_ptr(&self) -> *const u8 {\n        self as *const str as *const u8\n    }\n\n    /// Returns a subslice of `str`.\n    ///\n    /// This is the non-panicking alternative to indexing the `str`. Returns\n    /// [`None`] whenever equivalent indexing operation would panic.\n    ///\n    /// [`None`]: option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = String::from(\"\ud83d\uddfb\u2208\ud83c\udf0f\");\n    ///\n    /// assert_eq!(Some(\"\ud83d\uddfb\"), v.get(0..4));\n    ///\n    /// // indices not on UTF-8 sequence boundaries\n    /// assert!(v.get(1..).is_none());\n    /// assert!(v.get(..8).is_none());\n    ///\n    /// // out of bounds\n    /// assert!(v.get(..42).is_none());\n    /// ```\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    #[inline]\n    pub fn get<I: SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {\n        i.get(self)\n    }\n\n    /// Returns a mutable subslice of `str`.\n    ///\n    /// This is the non-panicking alternative to indexing the `str`. Returns\n    /// [`None`] whenever equivalent indexing operation would panic.\n    ///\n    /// [`None`]: option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = String::from(\"hello\");\n    /// // correct length\n    /// assert!(v.get_mut(0..5).is_some());\n    /// // out of bounds\n    /// assert!(v.get_mut(..42).is_none());\n    /// assert_eq!(Some(\"he\"), v.get_mut(0..2).map(|v| &*v));\n    ///\n    /// assert_eq!(\"hello\", v);\n    /// {\n    ///     let s = v.get_mut(0..2);\n    ///     let s = s.map(|s| {\n    ///         s.make_ascii_uppercase();\n    ///         &*s\n    ///     });\n    ///     assert_eq!(Some(\"HE\"), s);\n    /// }\n    /// assert_eq!(\"HEllo\", v);\n    /// ```\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    #[inline]\n    pub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {\n        i.get_mut(self)\n    }\n\n    /// Returns a unchecked subslice of `str`.\n    ///\n    /// This is the unchecked alternative to indexing the `str`.\n    ///\n    /// # Safety\n    ///\n    /// Callers of this function are responsible that these preconditions are\n    /// satisfied:\n    ///\n    /// * The starting index must come before the ending index;\n    /// * Indexes must be within bounds of the original slice;\n    /// * Indexes must lie on UTF-8 sequence boundaries.\n    ///\n    /// Failing that, the returned string slice may reference invalid memory or\n    /// violate the invariants communicated by the `str` type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = \"\ud83d\uddfb\u2208\ud83c\udf0f\";\n    /// unsafe {\n    ///     assert_eq!(\"\ud83d\uddfb\", v.get_unchecked(0..4));\n    ///     assert_eq!(\"\u2208\", v.get_unchecked(4..7));\n    ///     assert_eq!(\"\ud83c\udf0f\", v.get_unchecked(7..11));\n    /// }\n    /// ```\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    #[inline]\n    pub unsafe fn get_unchecked<I: SliceIndex<str>>(&self, i: I) -> &I::Output {\n        i.get_unchecked(self)\n    }\n\n    /// Returns a mutable, unchecked subslice of `str`.\n    ///\n    /// This is the unchecked alternative to indexing the `str`.\n    ///\n    /// # Safety\n    ///\n    /// Callers of this function are responsible that these preconditions are\n    /// satisfied:\n    ///\n    /// * The starting index must come before the ending index;\n    /// * Indexes must be within bounds of the original slice;\n    /// * Indexes must lie on UTF-8 sequence boundaries.\n    ///\n    /// Failing that, the returned string slice may reference invalid memory or\n    /// violate the invariants communicated by the `str` type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = String::from(\"\ud83d\uddfb\u2208\ud83c\udf0f\");\n    /// unsafe {\n    ///     assert_eq!(\"\ud83d\uddfb\", v.get_unchecked_mut(0..4));\n    ///     assert_eq!(\"\u2208\", v.get_unchecked_mut(4..7));\n    ///     assert_eq!(\"\ud83c\udf0f\", v.get_unchecked_mut(7..11));\n    /// }\n    /// ```\n    #[stable(feature = \"str_checked_slicing\", since = \"1.20.0\")]\n    #[inline]\n    pub unsafe fn get_unchecked_mut<I: SliceIndex<str>>(&mut self, i: I) -> &mut I::Output {\n        i.get_unchecked_mut(self)\n    }\n\n    /// Creates a string slice from another string slice, bypassing safety\n    /// checks.\n    ///\n    /// This is generally not recommended, use with caution! For a safe\n    /// alternative see [`str`] and [`Index`].\n    ///\n    /// [`str`]: primitive.str.html\n    /// [`Index`]: ops/trait.Index.html\n    ///\n    /// This new slice goes from `begin` to `end`, including `begin` but\n    /// excluding `end`.\n    ///\n    /// To get a mutable string slice instead, see the\n    /// [`slice_mut_unchecked`] method.\n    ///\n    /// [`slice_mut_unchecked`]: #method.slice_mut_unchecked\n    ///\n    /// # Safety\n    ///\n    /// Callers of this function are responsible that three preconditions are\n    /// satisfied:\n    ///\n    /// * `begin` must come before `end`.\n    /// * `begin` and `end` must be byte positions within the string slice.\n    /// * `begin` and `end` must lie on UTF-8 sequence boundaries.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    ///\n    /// unsafe {\n    ///     assert_eq!(\"L\u00f6we \u8001\u864e L\u00e9opard\", s.slice_unchecked(0, 21));\n    /// }\n    ///\n    /// let s = \"Hello, world!\";\n    ///\n    /// unsafe {\n    ///     assert_eq!(\"world\", s.slice_unchecked(7, 12));\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.29.0\", reason = \"use `get_unchecked(begin..end)` instead\")]\n    #[inline]\n    pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {\n        (begin..end).get_unchecked(self)\n    }\n\n    /// Creates a string slice from another string slice, bypassing safety\n    /// checks.\n    /// This is generally not recommended, use with caution! For a safe\n    /// alternative see [`str`] and [`IndexMut`].\n    ///\n    /// [`str`]: primitive.str.html\n    /// [`IndexMut`]: ops/trait.IndexMut.html\n    ///\n    /// This new slice goes from `begin` to `end`, including `begin` but\n    /// excluding `end`.\n    ///\n    /// To get an immutable string slice instead, see the\n    /// [`slice_unchecked`] method.\n    ///\n    /// [`slice_unchecked`]: #method.slice_unchecked\n    ///\n    /// # Safety\n    ///\n    /// Callers of this function are responsible that three preconditions are\n    /// satisfied:\n    ///\n    /// * `begin` must come before `end`.\n    /// * `begin` and `end` must be byte positions within the string slice.\n    /// * `begin` and `end` must lie on UTF-8 sequence boundaries.\n    #[stable(feature = \"str_slice_mut\", since = \"1.5.0\")]\n    #[rustc_deprecated(since = \"1.29.0\", reason = \"use `get_unchecked_mut(begin..end)` instead\")]\n    #[inline]\n    pub unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str {\n        (begin..end).get_unchecked_mut(self)\n    }\n\n    /// Divide one string slice into two at an index.\n    ///\n    /// The argument, `mid`, should be a byte offset from the start of the\n    /// string. It must also be on the boundary of a UTF-8 code point.\n    ///\n    /// The two slices returned go from the start of the string slice to `mid`,\n    /// and from `mid` to the end of the string slice.\n    ///\n    /// To get mutable string slices instead, see the [`split_at_mut`]\n    /// method.\n    ///\n    /// [`split_at_mut`]: #method.split_at_mut\n    ///\n    /// # Panics\n    ///\n    /// Panics if `mid` is not on a UTF-8 code point boundary, or if it is\n    /// beyond the last code point of the string slice.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"Per Martin-L\u00f6f\";\n    ///\n    /// let (first, last) = s.split_at(3);\n    ///\n    /// assert_eq!(\"Per\", first);\n    /// assert_eq!(\" Martin-L\u00f6f\", last);\n    /// ```\n    #[inline]\n    #[stable(feature = \"str_split_at\", since = \"1.4.0\")]\n    pub fn split_at(&self, mid: usize) -> (&str, &str) {\n        // is_char_boundary checks that the index is in [0, .len()]\n        if self.is_char_boundary(mid) {\n            unsafe {\n                (self.get_unchecked(0..mid),\n                 self.get_unchecked(mid..self.len()))\n            }\n        } else {\n            slice_error_fail(self, 0, mid)\n        }\n    }\n\n    /// Divide one mutable string slice into two at an index.\n    ///\n    /// The argument, `mid`, should be a byte offset from the start of the\n    /// string. It must also be on the boundary of a UTF-8 code point.\n    ///\n    /// The two slices returned go from the start of the string slice to `mid`,\n    /// and from `mid` to the end of the string slice.\n    ///\n    /// To get immutable string slices instead, see the [`split_at`] method.\n    ///\n    /// [`split_at`]: #method.split_at\n    ///\n    /// # Panics\n    ///\n    /// Panics if `mid` is not on a UTF-8 code point boundary, or if it is\n    /// beyond the last code point of the string slice.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = \"Per Martin-L\u00f6f\".to_string();\n    /// {\n    ///     let (first, last) = s.split_at_mut(3);\n    ///     first.make_ascii_uppercase();\n    ///     assert_eq!(\"PER\", first);\n    ///     assert_eq!(\" Martin-L\u00f6f\", last);\n    /// }\n    /// assert_eq!(\"PER Martin-L\u00f6f\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"str_split_at\", since = \"1.4.0\")]\n    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str) {\n        // is_char_boundary checks that the index is in [0, .len()]\n        if self.is_char_boundary(mid) {\n            let len = self.len();\n            let ptr = self.as_ptr() as *mut u8;\n            unsafe {\n                (from_utf8_unchecked_mut(slice::from_raw_parts_mut(ptr, mid)),\n                 from_utf8_unchecked_mut(slice::from_raw_parts_mut(\n                    ptr.add(mid),\n                    len - mid\n                 )))\n            }\n        } else {\n            slice_error_fail(self, 0, mid)\n        }\n    }\n\n    /// Returns an iterator over the [`char`]s of a string slice.\n    ///\n    /// As a string slice consists of valid UTF-8, we can iterate through a\n    /// string slice by [`char`]. This method returns such an iterator.\n    ///\n    /// It's important to remember that [`char`] represents a Unicode Scalar\n    /// Value, and may not match your idea of what a 'character' is. Iteration\n    /// over grapheme clusters may be what you actually want.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let word = \"goodbye\";\n    ///\n    /// let count = word.chars().count();\n    /// assert_eq!(7, count);\n    ///\n    /// let mut chars = word.chars();\n    ///\n    /// assert_eq!(Some('g'), chars.next());\n    /// assert_eq!(Some('o'), chars.next());\n    /// assert_eq!(Some('o'), chars.next());\n    /// assert_eq!(Some('d'), chars.next());\n    /// assert_eq!(Some('b'), chars.next());\n    /// assert_eq!(Some('y'), chars.next());\n    /// assert_eq!(Some('e'), chars.next());\n    ///\n    /// assert_eq!(None, chars.next());\n    /// ```\n    ///\n    /// Remember, [`char`]s may not match your human intuition about characters:\n    ///\n    /// ```\n    /// let y = \"y\u0306\";\n    ///\n    /// let mut chars = y.chars();\n    ///\n    /// assert_eq!(Some('y'), chars.next()); // not 'y\u0306'\n    /// assert_eq!(Some('\\u{0306}'), chars.next());\n    ///\n    /// assert_eq!(None, chars.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn chars(&self) -> Chars {\n        Chars{iter: self.as_bytes().iter()}\n    }\n\n    /// Returns an iterator over the [`char`]s of a string slice, and their\n    /// positions.\n    ///\n    /// As a string slice consists of valid UTF-8, we can iterate through a\n    /// string slice by [`char`]. This method returns an iterator of both\n    /// these [`char`]s, as well as their byte positions.\n    ///\n    /// The iterator yields tuples. The position is first, the [`char`] is\n    /// second.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let word = \"goodbye\";\n    ///\n    /// let count = word.char_indices().count();\n    /// assert_eq!(7, count);\n    ///\n    /// let mut char_indices = word.char_indices();\n    ///\n    /// assert_eq!(Some((0, 'g')), char_indices.next());\n    /// assert_eq!(Some((1, 'o')), char_indices.next());\n    /// assert_eq!(Some((2, 'o')), char_indices.next());\n    /// assert_eq!(Some((3, 'd')), char_indices.next());\n    /// assert_eq!(Some((4, 'b')), char_indices.next());\n    /// assert_eq!(Some((5, 'y')), char_indices.next());\n    /// assert_eq!(Some((6, 'e')), char_indices.next());\n    ///\n    /// assert_eq!(None, char_indices.next());\n    /// ```\n    ///\n    /// Remember, [`char`]s may not match your human intuition about characters:\n    ///\n    /// ```\n    /// let yes = \"y\u0306es\";\n    ///\n    /// let mut char_indices = yes.char_indices();\n    ///\n    /// assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y\u0306')\n    /// assert_eq!(Some((1, '\\u{0306}')), char_indices.next());\n    ///\n    /// // note the 3 here - the last character took up two bytes\n    /// assert_eq!(Some((3, 'e')), char_indices.next());\n    /// assert_eq!(Some((4, 's')), char_indices.next());\n    ///\n    /// assert_eq!(None, char_indices.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn char_indices(&self) -> CharIndices {\n        CharIndices { front_offset: 0, iter: self.chars() }\n    }\n\n    /// An iterator over the bytes of a string slice.\n    ///\n    /// As a string slice consists of a sequence of bytes, we can iterate\n    /// through a string slice by byte. This method returns such an iterator.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut bytes = \"bors\".bytes();\n    ///\n    /// assert_eq!(Some(b'b'), bytes.next());\n    /// assert_eq!(Some(b'o'), bytes.next());\n    /// assert_eq!(Some(b'r'), bytes.next());\n    /// assert_eq!(Some(b's'), bytes.next());\n    ///\n    /// assert_eq!(None, bytes.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn bytes(&self) -> Bytes {\n        Bytes(self.as_bytes().iter().cloned())\n    }\n\n    /// Split a string slice by whitespace.\n    ///\n    /// The iterator returned will return string slices that are sub-slices of\n    /// the original string slice, separated by any amount of whitespace.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`. If you only want to split on ASCII whitespace\n    /// instead, use [`split_ascii_whitespace`].\n    ///\n    /// [`split_ascii_whitespace`]: #method.split_ascii_whitespace\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut iter = \"A few words\".split_whitespace();\n    ///\n    /// assert_eq!(Some(\"A\"), iter.next());\n    /// assert_eq!(Some(\"few\"), iter.next());\n    /// assert_eq!(Some(\"words\"), iter.next());\n    ///\n    /// assert_eq!(None, iter.next());\n    /// ```\n    ///\n    /// All kinds of whitespace are considered:\n    ///\n    /// ```\n    /// let mut iter = \" Mary   had\\ta\\u{2009}little  \\n\\t lamb\".split_whitespace();\n    /// assert_eq!(Some(\"Mary\"), iter.next());\n    /// assert_eq!(Some(\"had\"), iter.next());\n    /// assert_eq!(Some(\"a\"), iter.next());\n    /// assert_eq!(Some(\"little\"), iter.next());\n    /// assert_eq!(Some(\"lamb\"), iter.next());\n    ///\n    /// assert_eq!(None, iter.next());\n    /// ```\n    #[stable(feature = \"split_whitespace\", since = \"1.1.0\")]\n    #[inline]\n    pub fn split_whitespace(&self) -> SplitWhitespace {\n        SplitWhitespace { inner: self.split(IsWhitespace).filter(IsNotEmpty) }\n    }\n\n    /// Split a string slice by ASCII whitespace.\n    ///\n    /// The iterator returned will return string slices that are sub-slices of\n    /// the original string slice, separated by any amount of ASCII whitespace.\n    ///\n    /// To split by Unicode `Whitespace` instead, use [`split_whitespace`].\n    ///\n    /// [`split_whitespace`]: #method.split_whitespace\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(split_ascii_whitespace)]\n    /// let mut iter = \"A few words\".split_ascii_whitespace();\n    ///\n    /// assert_eq!(Some(\"A\"), iter.next());\n    /// assert_eq!(Some(\"few\"), iter.next());\n    /// assert_eq!(Some(\"words\"), iter.next());\n    ///\n    /// assert_eq!(None, iter.next());\n    /// ```\n    ///\n    /// All kinds of ASCII whitespace are considered:\n    ///\n    /// ```\n    /// let mut iter = \" Mary   had\\ta little  \\n\\t lamb\".split_whitespace();\n    /// assert_eq!(Some(\"Mary\"), iter.next());\n    /// assert_eq!(Some(\"had\"), iter.next());\n    /// assert_eq!(Some(\"a\"), iter.next());\n    /// assert_eq!(Some(\"little\"), iter.next());\n    /// assert_eq!(Some(\"lamb\"), iter.next());\n    ///\n    /// assert_eq!(None, iter.next());\n    /// ```\n    #[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\n    #[inline]\n    pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace {\n        let inner = self\n            .as_bytes()\n            .split(IsAsciiWhitespace)\n            .filter(IsNotEmpty)\n            .map(UnsafeBytesToStr);\n        SplitAsciiWhitespace { inner }\n    }\n\n    /// An iterator over the lines of a string, as string slices.\n    ///\n    /// Lines are ended with either a newline (`\\n`) or a carriage return with\n    /// a line feed (`\\r\\n`).\n    ///\n    /// The final line ending is optional.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let text = \"foo\\r\\nbar\\n\\nbaz\\n\";\n    /// let mut lines = text.lines();\n    ///\n    /// assert_eq!(Some(\"foo\"), lines.next());\n    /// assert_eq!(Some(\"bar\"), lines.next());\n    /// assert_eq!(Some(\"\"), lines.next());\n    /// assert_eq!(Some(\"baz\"), lines.next());\n    ///\n    /// assert_eq!(None, lines.next());\n    /// ```\n    ///\n    /// The final line ending isn't required:\n    ///\n    /// ```\n    /// let text = \"foo\\nbar\\n\\r\\nbaz\";\n    /// let mut lines = text.lines();\n    ///\n    /// assert_eq!(Some(\"foo\"), lines.next());\n    /// assert_eq!(Some(\"bar\"), lines.next());\n    /// assert_eq!(Some(\"\"), lines.next());\n    /// assert_eq!(Some(\"baz\"), lines.next());\n    ///\n    /// assert_eq!(None, lines.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn lines(&self) -> Lines {\n        Lines(self.split_terminator('\\n').map(LinesAnyMap))\n    }\n\n    /// An iterator over the lines of a string.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.4.0\", reason = \"use lines() instead now\")]\n    #[inline]\n    #[allow(deprecated)]\n    pub fn lines_any(&self) -> LinesAny {\n        LinesAny(self.lines())\n    }\n\n    /// Returns an iterator of `u16` over the string encoded as UTF-16.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let text = \"Za\u017c\u00f3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144\";\n    ///\n    /// let utf8_len = text.len();\n    /// let utf16_len = text.encode_utf16().count();\n    ///\n    /// assert!(utf16_len <= utf8_len);\n    /// ```\n    #[stable(feature = \"encode_utf16\", since = \"1.8.0\")]\n    pub fn encode_utf16(&self) -> EncodeUtf16 {\n        EncodeUtf16 { chars: self.chars(), extra: 0 }\n    }\n\n    /// Returns `true` if the given pattern matches a sub-slice of\n    /// this string slice.\n    ///\n    /// Returns `false` if it does not.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let bananas = \"bananas\";\n    ///\n    /// assert!(bananas.contains(\"nana\"));\n    /// assert!(!bananas.contains(\"apples\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {\n        pat.is_contained_in(self)\n    }\n\n    /// Returns `true` if the given pattern matches a prefix of this\n    /// string slice.\n    ///\n    /// Returns `false` if it does not.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let bananas = \"bananas\";\n    ///\n    /// assert!(bananas.starts_with(\"bana\"));\n    /// assert!(!bananas.starts_with(\"nana\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {\n        pat.is_prefix_of(self)\n    }\n\n    /// Returns `true` if the given pattern matches a suffix of this\n    /// string slice.\n    ///\n    /// Returns `false` if it does not.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let bananas = \"bananas\";\n    ///\n    /// assert!(bananas.ends_with(\"anas\"));\n    /// assert!(!bananas.ends_with(\"nana\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        pat.is_suffix_of(self)\n    }\n\n    /// Returns the byte index of the first character of this string slice that\n    /// matches the pattern.\n    ///\n    /// Returns [`None`] if the pattern doesn't match.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if\n    /// a character matches.\n    ///\n    /// [`None`]: option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    ///\n    /// assert_eq!(s.find('L'), Some(0));\n    /// assert_eq!(s.find('\u00e9'), Some(14));\n    /// assert_eq!(s.find(\"L\u00e9opard\"), Some(13));\n    /// ```\n    ///\n    /// More complex patterns using point-free style and closures:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    ///\n    /// assert_eq!(s.find(char::is_whitespace), Some(5));\n    /// assert_eq!(s.find(char::is_lowercase), Some(1));\n    /// assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));\n    /// assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));\n    /// ```\n    ///\n    /// Not finding the pattern:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    /// let x: &[_] = &['1', '2'];\n    ///\n    /// assert_eq!(s.find(x), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {\n        pat.into_searcher(self).next_match().map(|(i, _)| i)\n    }\n\n    /// Returns the byte index of the last character of this string slice that\n    /// matches the pattern.\n    ///\n    /// Returns [`None`] if the pattern doesn't match.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if\n    /// a character matches.\n    ///\n    /// [`None`]: option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    ///\n    /// assert_eq!(s.rfind('L'), Some(13));\n    /// assert_eq!(s.rfind('\u00e9'), Some(14));\n    /// ```\n    ///\n    /// More complex patterns with closures:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    ///\n    /// assert_eq!(s.rfind(char::is_whitespace), Some(12));\n    /// assert_eq!(s.rfind(char::is_lowercase), Some(20));\n    /// ```\n    ///\n    /// Not finding the pattern:\n    ///\n    /// ```\n    /// let s = \"L\u00f6we \u8001\u864e L\u00e9opard\";\n    /// let x: &[_] = &['1', '2'];\n    ///\n    /// assert_eq!(s.rfind(x), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        pat.into_searcher(self).next_match_back().map(|(i, _)| i)\n    }\n\n    /// An iterator over substrings of this string slice, separated by\n    /// characters matched by a pattern.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines the\n    /// split.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern\n    /// allows a reverse search and forward/reverse search yields the same\n    /// elements. This is true for, eg, [`char`] but not for `&str`.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// If the pattern allows a reverse search but its results might differ\n    /// from a forward search, the [`rsplit`] method can be used.\n    ///\n    /// [`rsplit`]: #method.rsplit\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"Mary had a little lamb\".split(' ').collect();\n    /// assert_eq!(v, [\"Mary\", \"had\", \"a\", \"little\", \"lamb\"]);\n    ///\n    /// let v: Vec<&str> = \"\".split('X').collect();\n    /// assert_eq!(v, [\"\"]);\n    ///\n    /// let v: Vec<&str> = \"lionXXtigerXleopard\".split('X').collect();\n    /// assert_eq!(v, [\"lion\", \"\", \"tiger\", \"leopard\"]);\n    ///\n    /// let v: Vec<&str> = \"lion::tiger::leopard\".split(\"::\").collect();\n    /// assert_eq!(v, [\"lion\", \"tiger\", \"leopard\"]);\n    ///\n    /// let v: Vec<&str> = \"abc1def2ghi\".split(char::is_numeric).collect();\n    /// assert_eq!(v, [\"abc\", \"def\", \"ghi\"]);\n    ///\n    /// let v: Vec<&str> = \"lionXtigerXleopard\".split(char::is_uppercase).collect();\n    /// assert_eq!(v, [\"lion\", \"tiger\", \"leopard\"]);\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abc1defXghi\".split(|c| c == '1' || c == 'X').collect();\n    /// assert_eq!(v, [\"abc\", \"def\", \"ghi\"]);\n    /// ```\n    ///\n    /// If a string contains multiple contiguous separators, you will end up\n    /// with empty strings in the output:\n    ///\n    /// ```\n    /// let x = \"||||a||b|c\".to_string();\n    /// let d: Vec<_> = x.split('|').collect();\n    ///\n    /// assert_eq!(d, &[\"\", \"\", \"\", \"\", \"a\", \"\", \"b\", \"c\"]);\n    /// ```\n    ///\n    /// Contiguous separators are separated by the empty string.\n    ///\n    /// ```\n    /// let x = \"(///)\".to_string();\n    /// let d: Vec<_> = x.split('/').collect();\n    ///\n    /// assert_eq!(d, &[\"(\", \"\", \"\", \")\"]);\n    /// ```\n    ///\n    /// Separators at the start or end of a string are neighbored\n    /// by empty strings.\n    ///\n    /// ```\n    /// let d: Vec<_> = \"010\".split(\"0\").collect();\n    /// assert_eq!(d, &[\"\", \"1\", \"\"]);\n    /// ```\n    ///\n    /// When the empty string is used as a separator, it separates\n    /// every character in the string, along with the beginning\n    /// and end of the string.\n    ///\n    /// ```\n    /// let f: Vec<_> = \"rust\".split(\"\").collect();\n    /// assert_eq!(f, &[\"\", \"r\", \"u\", \"s\", \"t\", \"\"]);\n    /// ```\n    ///\n    /// Contiguous separators can lead to possibly surprising behavior\n    /// when whitespace is used as the separator. This code is correct:\n    ///\n    /// ```\n    /// let x = \"    a  b c\".to_string();\n    /// let d: Vec<_> = x.split(' ').collect();\n    ///\n    /// assert_eq!(d, &[\"\", \"\", \"\", \"\", \"a\", \"\", \"b\", \"c\"]);\n    /// ```\n    ///\n    /// It does _not_ give you:\n    ///\n    /// ```,ignore\n    /// assert_eq!(d, &[\"a\", \"b\", \"c\"]);\n    /// ```\n    ///\n    /// Use [`split_whitespace`] for this behavior.\n    ///\n    /// [`split_whitespace`]: #method.split_whitespace\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> {\n        Split(SplitInternal {\n            start: 0,\n            end: self.len(),\n            matcher: pat.into_searcher(self),\n            allow_trailing_empty: true,\n            finished: false,\n        })\n    }\n\n    /// An iterator over substrings of the given string slice, separated by\n    /// characters matched by a pattern and yielded in reverse order.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines the\n    /// split.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator requires that the pattern supports a reverse\n    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse\n    /// search yields the same elements.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// For iterating from the front, the [`split`] method can be used.\n    ///\n    /// [`split`]: #method.split\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"Mary had a little lamb\".rsplit(' ').collect();\n    /// assert_eq!(v, [\"lamb\", \"little\", \"a\", \"had\", \"Mary\"]);\n    ///\n    /// let v: Vec<&str> = \"\".rsplit('X').collect();\n    /// assert_eq!(v, [\"\"]);\n    ///\n    /// let v: Vec<&str> = \"lionXXtigerXleopard\".rsplit('X').collect();\n    /// assert_eq!(v, [\"leopard\", \"tiger\", \"\", \"lion\"]);\n    ///\n    /// let v: Vec<&str> = \"lion::tiger::leopard\".rsplit(\"::\").collect();\n    /// assert_eq!(v, [\"leopard\", \"tiger\", \"lion\"]);\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abc1defXghi\".rsplit(|c| c == '1' || c == 'X').collect();\n    /// assert_eq!(v, [\"ghi\", \"def\", \"abc\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rsplit<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplit<'a, P>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        RSplit(self.split(pat).0)\n    }\n\n    /// An iterator over substrings of the given string slice, separated by\n    /// characters matched by a pattern.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines the\n    /// split.\n    ///\n    /// Equivalent to [`split`], except that the trailing substring\n    /// is skipped if empty.\n    ///\n    /// [`split`]: #method.split\n    ///\n    /// This method can be used for string data that is _terminated_,\n    /// rather than _separated_ by a pattern.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern\n    /// allows a reverse search and forward/reverse search yields the same\n    /// elements. This is true for, eg, [`char`] but not for `&str`.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// If the pattern allows a reverse search but its results might differ\n    /// from a forward search, the [`rsplit_terminator`] method can be used.\n    ///\n    /// [`rsplit_terminator`]: #method.rsplit_terminator\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"A.B.\".split_terminator('.').collect();\n    /// assert_eq!(v, [\"A\", \"B\"]);\n    ///\n    /// let v: Vec<&str> = \"A..B..\".split_terminator(\".\").collect();\n    /// assert_eq!(v, [\"A\", \"\", \"B\", \"\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> {\n        SplitTerminator(SplitInternal {\n            allow_trailing_empty: false,\n            ..self.split(pat).0\n        })\n    }\n\n    /// An iterator over substrings of `self`, separated by characters\n    /// matched by a pattern and yielded in reverse order.\n    ///\n    /// The pattern can be a simple `&str`, [`char`], or a closure that\n    /// determines the split.\n    /// Additional libraries might provide more complex patterns like\n    /// regular expressions.\n    ///\n    /// Equivalent to [`split`], except that the trailing substring is\n    /// skipped if empty.\n    ///\n    /// [`split`]: #method.split\n    ///\n    /// This method can be used for string data that is _terminated_,\n    /// rather than _separated_ by a pattern.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator requires that the pattern supports a\n    /// reverse search, and it will be double ended if a forward/reverse\n    /// search yields the same elements.\n    ///\n    /// For iterating from the front, the [`split_terminator`] method can be\n    /// used.\n    ///\n    /// [`split_terminator`]: #method.split_terminator\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"A.B.\".rsplit_terminator('.').collect();\n    /// assert_eq!(v, [\"B\", \"A\"]);\n    ///\n    /// let v: Vec<&str> = \"A..B..\".rsplit_terminator(\".\").collect();\n    /// assert_eq!(v, [\"\", \"B\", \"\", \"A\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rsplit_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplitTerminator<'a, P>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        RSplitTerminator(self.split_terminator(pat).0)\n    }\n\n    /// An iterator over substrings of the given string slice, separated by a\n    /// pattern, restricted to returning at most `n` items.\n    ///\n    /// If `n` substrings are returned, the last substring (the `n`th substring)\n    /// will contain the remainder of the string.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines the\n    /// split.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will not be double ended, because it is\n    /// not efficient to support.\n    ///\n    /// If the pattern allows a reverse search, the [`rsplitn`] method can be\n    /// used.\n    ///\n    /// [`rsplitn`]: #method.rsplitn\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"Mary had a little lambda\".splitn(3, ' ').collect();\n    /// assert_eq!(v, [\"Mary\", \"had\", \"a little lambda\"]);\n    ///\n    /// let v: Vec<&str> = \"lionXXtigerXleopard\".splitn(3, \"X\").collect();\n    /// assert_eq!(v, [\"lion\", \"\", \"tigerXleopard\"]);\n    ///\n    /// let v: Vec<&str> = \"abcXdef\".splitn(1, 'X').collect();\n    /// assert_eq!(v, [\"abcXdef\"]);\n    ///\n    /// let v: Vec<&str> = \"\".splitn(1, 'X').collect();\n    /// assert_eq!(v, [\"\"]);\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abc1defXghi\".splitn(2, |c| c == '1' || c == 'X').collect();\n    /// assert_eq!(v, [\"abc\", \"defXghi\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn splitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> {\n        SplitN(SplitNInternal {\n            iter: self.split(pat).0,\n            count: n,\n        })\n    }\n\n    /// An iterator over substrings of this string slice, separated by a\n    /// pattern, starting from the end of the string, restricted to returning\n    /// at most `n` items.\n    ///\n    /// If `n` substrings are returned, the last substring (the `n`th substring)\n    /// will contain the remainder of the string.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that\n    /// determines the split.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will not be double ended, because it is not\n    /// efficient to support.\n    ///\n    /// For splitting from the front, the [`splitn`] method can be used.\n    ///\n    /// [`splitn`]: #method.splitn\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"Mary had a little lamb\".rsplitn(3, ' ').collect();\n    /// assert_eq!(v, [\"lamb\", \"little\", \"Mary had a\"]);\n    ///\n    /// let v: Vec<&str> = \"lionXXtigerXleopard\".rsplitn(3, 'X').collect();\n    /// assert_eq!(v, [\"leopard\", \"tiger\", \"lionX\"]);\n    ///\n    /// let v: Vec<&str> = \"lion::tiger::leopard\".rsplitn(2, \"::\").collect();\n    /// assert_eq!(v, [\"leopard\", \"lion::tiger\"]);\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abc1defXghi\".rsplitn(2, |c| c == '1' || c == 'X').collect();\n    /// assert_eq!(v, [\"ghi\", \"abc1def\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rsplitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> RSplitN<'a, P>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        RSplitN(self.splitn(n, pat).0)\n    }\n\n    /// An iterator over the disjoint matches of a pattern within the given string\n    /// slice.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that\n    /// determines if a character matches.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern\n    /// allows a reverse search and forward/reverse search yields the same\n    /// elements. This is true for, eg, [`char`] but not for `&str`.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// If the pattern allows a reverse search but its results might differ\n    /// from a forward search, the [`rmatches`] method can be used.\n    ///\n    /// [`rmatches`]: #method.rmatches\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abcXXXabcYYYabc\".matches(\"abc\").collect();\n    /// assert_eq!(v, [\"abc\", \"abc\", \"abc\"]);\n    ///\n    /// let v: Vec<&str> = \"1abc2abc3\".matches(char::is_numeric).collect();\n    /// assert_eq!(v, [\"1\", \"2\", \"3\"]);\n    /// ```\n    #[stable(feature = \"str_matches\", since = \"1.2.0\")]\n    #[inline]\n    pub fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P> {\n        Matches(MatchesInternal(pat.into_searcher(self)))\n    }\n\n    /// An iterator over the disjoint matches of a pattern within this string slice,\n    /// yielded in reverse order.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if\n    /// a character matches.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator requires that the pattern supports a reverse\n    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse\n    /// search yields the same elements.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// For iterating from the front, the [`matches`] method can be used.\n    ///\n    /// [`matches`]: #method.matches\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v: Vec<&str> = \"abcXXXabcYYYabc\".rmatches(\"abc\").collect();\n    /// assert_eq!(v, [\"abc\", \"abc\", \"abc\"]);\n    ///\n    /// let v: Vec<&str> = \"1abc2abc3\".rmatches(char::is_numeric).collect();\n    /// assert_eq!(v, [\"3\", \"2\", \"1\"]);\n    /// ```\n    #[stable(feature = \"str_matches\", since = \"1.2.0\")]\n    #[inline]\n    pub fn rmatches<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatches<'a, P>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        RMatches(self.matches(pat).0)\n    }\n\n    /// An iterator over the disjoint matches of a pattern within this string\n    /// slice as well as the index that the match starts at.\n    ///\n    /// For matches of `pat` within `self` that overlap, only the indices\n    /// corresponding to the first match are returned.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines\n    /// if a character matches.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern\n    /// allows a reverse search and forward/reverse search yields the same\n    /// elements. This is true for, eg, [`char`] but not for `&str`.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// If the pattern allows a reverse search but its results might differ\n    /// from a forward search, the [`rmatch_indices`] method can be used.\n    ///\n    /// [`rmatch_indices`]: #method.rmatch_indices\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v: Vec<_> = \"abcXXXabcYYYabc\".match_indices(\"abc\").collect();\n    /// assert_eq!(v, [(0, \"abc\"), (6, \"abc\"), (12, \"abc\")]);\n    ///\n    /// let v: Vec<_> = \"1abcabc2\".match_indices(\"abc\").collect();\n    /// assert_eq!(v, [(1, \"abc\"), (4, \"abc\")]);\n    ///\n    /// let v: Vec<_> = \"ababa\".match_indices(\"aba\").collect();\n    /// assert_eq!(v, [(0, \"aba\")]); // only the first `aba`\n    /// ```\n    #[stable(feature = \"str_match_indices\", since = \"1.5.0\")]\n    #[inline]\n    pub fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> {\n        MatchIndices(MatchIndicesInternal(pat.into_searcher(self)))\n    }\n\n    /// An iterator over the disjoint matches of a pattern within `self`,\n    /// yielded in reverse order along with the index of the match.\n    ///\n    /// For matches of `pat` within `self` that overlap, only the indices\n    /// corresponding to the last match are returned.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if a\n    /// character matches.\n    ///\n    /// # Iterator behavior\n    ///\n    /// The returned iterator requires that the pattern supports a reverse\n    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse\n    /// search yields the same elements.\n    ///\n    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html\n    ///\n    /// For iterating from the front, the [`match_indices`] method can be used.\n    ///\n    /// [`match_indices`]: #method.match_indices\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v: Vec<_> = \"abcXXXabcYYYabc\".rmatch_indices(\"abc\").collect();\n    /// assert_eq!(v, [(12, \"abc\"), (6, \"abc\"), (0, \"abc\")]);\n    ///\n    /// let v: Vec<_> = \"1abcabc2\".rmatch_indices(\"abc\").collect();\n    /// assert_eq!(v, [(4, \"abc\"), (1, \"abc\")]);\n    ///\n    /// let v: Vec<_> = \"ababa\".rmatch_indices(\"aba\").collect();\n    /// assert_eq!(v, [(2, \"aba\")]); // only the last `aba`\n    /// ```\n    #[stable(feature = \"str_match_indices\", since = \"1.5.0\")]\n    #[inline]\n    pub fn rmatch_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatchIndices<'a, P>\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        RMatchIndices(self.match_indices(pat).0)\n    }\n\n    /// Returns a string slice with leading and trailing whitespace removed.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \" Hello\\tworld\\t\";\n    ///\n    /// assert_eq!(\"Hello\\tworld\", s.trim());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn trim(&self) -> &str {\n        self.trim_matches(|c: char| c.is_whitespace())\n    }\n\n    /// Returns a string slice with leading whitespace removed.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. `start` in this context means the first\n    /// position of that byte string; for a left-to-right language like English or\n    /// Russian, this will be left side; and for right-to-left languages like\n    /// like Arabic or Hebrew, this will be the right side.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \" Hello\\tworld\\t\";\n    /// assert_eq!(\"Hello\\tworld\\t\", s.trim_start());\n    /// ```\n    ///\n    /// Directionality:\n    ///\n    /// ```\n    /// let s = \"  English  \";\n    /// assert!(Some('E') == s.trim_start().chars().next());\n    ///\n    /// let s = \"  \u05e2\u05d1\u05e8\u05d9\u05ea  \";\n    /// assert!(Some('\u05e2') == s.trim_start().chars().next());\n    /// ```\n    #[stable(feature = \"trim_direction\", since = \"1.30.0\")]\n    pub fn trim_start(&self) -> &str {\n        self.trim_start_matches(|c: char| c.is_whitespace())\n    }\n\n    /// Returns a string slice with trailing whitespace removed.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. `end` in this context means the last\n    /// position of that byte string; for a left-to-right language like English or\n    /// Russian, this will be right side; and for right-to-left languages like\n    /// like Arabic or Hebrew, this will be the left side.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \" Hello\\tworld\\t\";\n    /// assert_eq!(\" Hello\\tworld\", s.trim_end());\n    /// ```\n    ///\n    /// Directionality:\n    ///\n    /// ```\n    /// let s = \"  English  \";\n    /// assert!(Some('h') == s.trim_end().chars().rev().next());\n    ///\n    /// let s = \"  \u05e2\u05d1\u05e8\u05d9\u05ea  \";\n    /// assert!(Some('\u05ea') == s.trim_end().chars().rev().next());\n    /// ```\n    #[stable(feature = \"trim_direction\", since = \"1.30.0\")]\n    pub fn trim_end(&self) -> &str {\n        self.trim_end_matches(|c: char| c.is_whitespace())\n    }\n\n    /// Returns a string slice with leading whitespace removed.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Left' in this context means the first\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _right_ side, not the left.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \" Hello\\tworld\\t\";\n    ///\n    /// assert_eq!(\"Hello\\tworld\\t\", s.trim_left());\n    /// ```\n    ///\n    /// Directionality:\n    ///\n    /// ```\n    /// let s = \"  English\";\n    /// assert!(Some('E') == s.trim_left().chars().next());\n    ///\n    /// let s = \"  \u05e2\u05d1\u05e8\u05d9\u05ea\";\n    /// assert!(Some('\u05e2') == s.trim_left().chars().next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(reason = \"superseded by `trim_start`\", since = \"1.33.0\")]\n    pub fn trim_left(&self) -> &str {\n        self.trim_start()\n    }\n\n    /// Returns a string slice with trailing whitespace removed.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived\n    /// Core Property `White_Space`.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Right' in this context means the last\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _left_ side, not the right.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \" Hello\\tworld\\t\";\n    ///\n    /// assert_eq!(\" Hello\\tworld\", s.trim_right());\n    /// ```\n    ///\n    /// Directionality:\n    ///\n    /// ```\n    /// let s = \"English  \";\n    /// assert!(Some('h') == s.trim_right().chars().rev().next());\n    ///\n    /// let s = \"\u05e2\u05d1\u05e8\u05d9\u05ea  \";\n    /// assert!(Some('\u05ea') == s.trim_right().chars().rev().next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(reason = \"superseded by `trim_end`\", since = \"1.33.0\")]\n    pub fn trim_right(&self) -> &str {\n        self.trim_end()\n    }\n\n    /// Returns a string slice with all prefixes and suffixes that match a\n    /// pattern repeatedly removed.\n    ///\n    /// The pattern can be a [`char`] or a closure that determines if a\n    /// character matches.\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// assert_eq!(\"11foo1bar11\".trim_matches('1'), \"foo1bar\");\n    /// assert_eq!(\"123foo1bar123\".trim_matches(char::is_numeric), \"foo1bar\");\n    ///\n    /// let x: &[_] = &['1', '2'];\n    /// assert_eq!(\"12foo1bar12\".trim_matches(x), \"foo1bar\");\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// assert_eq!(\"1foo1barXX\".trim_matches(|c| c == '1' || c == 'X'), \"foo1bar\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str\n        where P::Searcher: DoubleEndedSearcher<'a>\n    {\n        let mut i = 0;\n        let mut j = 0;\n        let mut matcher = pat.into_searcher(self);\n        if let Some((a, b)) = matcher.next_reject() {\n            i = a;\n            j = b; // Remember earliest known match, correct it below if\n                   // last match is different\n        }\n        if let Some((_, b)) = matcher.next_reject_back() {\n            j = b;\n        }\n        unsafe {\n            // Searcher is known to return valid indices\n            self.get_unchecked(i..j)\n        }\n    }\n\n    /// Returns a string slice with all prefixes that match a pattern\n    /// repeatedly removed.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if\n    /// a character matches.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Left' in this context means the first\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _right_ side, not the left.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert_eq!(\"11foo1bar11\".trim_start_matches('1'), \"foo1bar11\");\n    /// assert_eq!(\"123foo1bar123\".trim_start_matches(char::is_numeric), \"foo1bar123\");\n    ///\n    /// let x: &[_] = &['1', '2'];\n    /// assert_eq!(\"12foo1bar12\".trim_start_matches(x), \"foo1bar12\");\n    /// ```\n    #[stable(feature = \"trim_direction\", since = \"1.30.0\")]\n    pub fn trim_start_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {\n        let mut i = self.len();\n        let mut matcher = pat.into_searcher(self);\n        if let Some((a, _)) = matcher.next_reject() {\n            i = a;\n        }\n        unsafe {\n            // Searcher is known to return valid indices\n            self.get_unchecked(i..self.len())\n        }\n    }\n\n    /// Returns a string slice with all suffixes that match a pattern\n    /// repeatedly removed.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that\n    /// determines if a character matches.\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Right' in this context means the last\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _left_ side, not the right.\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// assert_eq!(\"11foo1bar11\".trim_end_matches('1'), \"11foo1bar\");\n    /// assert_eq!(\"123foo1bar123\".trim_end_matches(char::is_numeric), \"123foo1bar\");\n    ///\n    /// let x: &[_] = &['1', '2'];\n    /// assert_eq!(\"12foo1bar12\".trim_end_matches(x), \"12foo1bar\");\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// assert_eq!(\"1fooX\".trim_end_matches(|c| c == '1' || c == 'X'), \"1foo\");\n    /// ```\n    #[stable(feature = \"trim_direction\", since = \"1.30.0\")]\n    pub fn trim_end_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        let mut j = 0;\n        let mut matcher = pat.into_searcher(self);\n        if let Some((_, b)) = matcher.next_reject_back() {\n            j = b;\n        }\n        unsafe {\n            // Searcher is known to return valid indices\n            self.get_unchecked(0..j)\n        }\n    }\n\n    /// Returns a string slice with all prefixes that match a pattern\n    /// repeatedly removed.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that determines if\n    /// a character matches.\n    ///\n    /// [`char`]: primitive.char.html\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Left' in this context means the first\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _right_ side, not the left.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert_eq!(\"11foo1bar11\".trim_left_matches('1'), \"foo1bar11\");\n    /// assert_eq!(\"123foo1bar123\".trim_left_matches(char::is_numeric), \"foo1bar123\");\n    ///\n    /// let x: &[_] = &['1', '2'];\n    /// assert_eq!(\"12foo1bar12\".trim_left_matches(x), \"foo1bar12\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(reason = \"superseded by `trim_start_matches`\", since = \"1.33.0\")]\n    pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {\n        self.trim_start_matches(pat)\n    }\n\n    /// Returns a string slice with all suffixes that match a pattern\n    /// repeatedly removed.\n    ///\n    /// The pattern can be a `&str`, [`char`], or a closure that\n    /// determines if a character matches.\n    ///\n    /// [`char`]: primitive.char.html\n    ///\n    /// # Text directionality\n    ///\n    /// A string is a sequence of bytes. 'Right' in this context means the last\n    /// position of that byte string; for a language like Arabic or Hebrew\n    /// which are 'right to left' rather than 'left to right', this will be\n    /// the _left_ side, not the right.\n    ///\n    /// # Examples\n    ///\n    /// Simple patterns:\n    ///\n    /// ```\n    /// assert_eq!(\"11foo1bar11\".trim_right_matches('1'), \"11foo1bar\");\n    /// assert_eq!(\"123foo1bar123\".trim_right_matches(char::is_numeric), \"123foo1bar\");\n    ///\n    /// let x: &[_] = &['1', '2'];\n    /// assert_eq!(\"12foo1bar12\".trim_right_matches(x), \"12foo1bar\");\n    /// ```\n    ///\n    /// A more complex pattern, using a closure:\n    ///\n    /// ```\n    /// assert_eq!(\"1fooX\".trim_right_matches(|c| c == '1' || c == 'X'), \"1foo\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(reason = \"superseded by `trim_end_matches`\", since = \"1.33.0\")]\n    pub fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str\n        where P::Searcher: ReverseSearcher<'a>\n    {\n        self.trim_end_matches(pat)\n    }\n\n    /// Parses this string slice into another type.\n    ///\n    /// Because `parse` is so general, it can cause problems with type\n    /// inference. As such, `parse` is one of the few times you'll see\n    /// the syntax affectionately known as the 'turbofish': `::<>`. This\n    /// helps the inference algorithm understand specifically which type\n    /// you're trying to parse into.\n    ///\n    /// `parse` can parse any type that implements the [`FromStr`] trait.\n    ///\n    /// [`FromStr`]: str/trait.FromStr.html\n    ///\n    /// # Errors\n    ///\n    /// Will return [`Err`] if it's not possible to parse this string slice into\n    /// the desired type.\n    ///\n    /// [`Err`]: str/trait.FromStr.html#associatedtype.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage\n    ///\n    /// ```\n    /// let four: u32 = \"4\".parse().unwrap();\n    ///\n    /// assert_eq!(4, four);\n    /// ```\n    ///\n    /// Using the 'turbofish' instead of annotating `four`:\n    ///\n    /// ```\n    /// let four = \"4\".parse::<u32>();\n    ///\n    /// assert_eq!(Ok(4), four);\n    /// ```\n    ///\n    /// Failing to parse:\n    ///\n    /// ```\n    /// let nope = \"j\".parse::<u32>();\n    ///\n    /// assert!(nope.is_err());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn parse<F: FromStr>(&self) -> Result<F, F::Err> {\n        FromStr::from_str(self)\n    }\n\n    /// Checks if all characters in this string are within the ASCII range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let ascii = \"hello!\\n\";\n    /// let non_ascii = \"Gr\u00fc\u00dfe, J\u00fcrgen \u2764\";\n    ///\n    /// assert!(ascii.is_ascii());\n    /// assert!(!non_ascii.is_ascii());\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn is_ascii(&self) -> bool {\n        // We can treat each byte as character here: all multibyte characters\n        // start with a byte that is not in the ascii range, so we will stop\n        // there already.\n        self.bytes().all(|b| b.is_ascii())\n    }\n\n    /// Checks that two strings are an ASCII case-insensitive match.\n    ///\n    /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,\n    /// but without allocating and copying temporaries.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert!(\"Ferris\".eq_ignore_ascii_case(\"FERRIS\"));\n    /// assert!(\"Ferr\u00f6s\".eq_ignore_ascii_case(\"FERR\u00f6S\"));\n    /// assert!(!\"Ferr\u00f6s\".eq_ignore_ascii_case(\"FERR\u00d6S\"));\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn eq_ignore_ascii_case(&self, other: &str) -> bool {\n        self.as_bytes().eq_ignore_ascii_case(other.as_bytes())\n    }\n\n    /// Converts this string to its ASCII upper case equivalent in-place.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new uppercased value without modifying the existing one, use\n    /// [`to_ascii_uppercase`].\n    ///\n    /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    pub fn make_ascii_uppercase(&mut self) {\n        let me = unsafe { self.as_bytes_mut() };\n        me.make_ascii_uppercase()\n    }\n\n    /// Converts this string to its ASCII lower case equivalent in-place.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new lowercased value without modifying the existing one, use\n    /// [`to_ascii_lowercase`].\n    ///\n    /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    pub fn make_ascii_lowercase(&mut self) {\n        let me = unsafe { self.as_bytes_mut() };\n        me.make_ascii_lowercase()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<[u8]> for str {\n    #[inline]\n    fn as_ref(&self) -> &[u8] {\n        self.as_bytes()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Default for &str {\n    /// Creates an empty str\n    fn default() -> Self { \"\" }\n}\n\n#[stable(feature = \"default_mut_str\", since = \"1.28.0\")]\nimpl Default for &mut str {\n    /// Creates an empty mutable str\n    fn default() -> Self { unsafe { from_utf8_unchecked_mut(&mut []) } }\n}\n\n/// An iterator over the non-whitespace substrings of a string,\n/// separated by any amount of whitespace.\n///\n/// This struct is created by the [`split_whitespace`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`split_whitespace`]: ../../std/primitive.str.html#method.split_whitespace\n/// [`str`]: ../../std/primitive.str.html\n#[stable(feature = \"split_whitespace\", since = \"1.1.0\")]\n#[derive(Clone, Debug)]\npub struct SplitWhitespace<'a> {\n    inner: Filter<Split<'a, IsWhitespace>, IsNotEmpty>,\n}\n\n/// An iterator over the non-ASCII-whitespace substrings of a string,\n/// separated by any amount of ASCII whitespace.\n///\n/// This struct is created by the [`split_ascii_whitespace`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`split_ascii_whitespace`]: ../../std/primitive.str.html#method.split_ascii_whitespace\n/// [`str`]: ../../std/primitive.str.html\n#[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\n#[derive(Clone, Debug)]\npub struct SplitAsciiWhitespace<'a> {\n    inner: Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, IsNotEmpty>, UnsafeBytesToStr>,\n}\n\n#[derive(Clone)]\nstruct IsWhitespace;\n\nimpl FnOnce<(char, )> for IsWhitespace {\n    type Output = bool;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(mut self, arg: (char, )) -> bool {\n        self.call_mut(arg)\n    }\n}\n\nimpl FnMut<(char, )> for IsWhitespace {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, arg: (char, )) -> bool {\n        arg.0.is_whitespace()\n    }\n}\n\n#[derive(Clone)]\nstruct IsAsciiWhitespace;\n\nimpl<'a> FnOnce<(&'a u8, )> for IsAsciiWhitespace {\n    type Output = bool;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(mut self, arg: (&u8, )) -> bool {\n        self.call_mut(arg)\n    }\n}\n\nimpl<'a> FnMut<(&'a u8, )> for IsAsciiWhitespace {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, arg: (&u8, )) -> bool {\n        arg.0.is_ascii_whitespace()\n    }\n}\n\n#[derive(Clone)]\nstruct IsNotEmpty;\n\nimpl<'a, 'b> FnOnce<(&'a &'b str, )> for IsNotEmpty {\n    type Output = bool;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(mut self, arg: (&'a &'b str, )) -> bool {\n        self.call_mut(arg)\n    }\n}\n\nimpl<'a, 'b> FnMut<(&'a &'b str, )> for IsNotEmpty {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, arg: (&'a &'b str, )) -> bool {\n        !arg.0.is_empty()\n    }\n}\n\nimpl<'a, 'b> FnOnce<(&'a &'b [u8], )> for IsNotEmpty {\n    type Output = bool;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(mut self, arg: (&'a &'b [u8], )) -> bool {\n        self.call_mut(arg)\n    }\n}\n\nimpl<'a, 'b> FnMut<(&'a &'b [u8], )> for IsNotEmpty {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, arg: (&'a &'b [u8], )) -> bool {\n        !arg.0.is_empty()\n    }\n}\n\n#[derive(Clone)]\nstruct UnsafeBytesToStr;\n\nimpl<'a> FnOnce<(&'a [u8], )> for UnsafeBytesToStr {\n    type Output = &'a str;\n\n    #[inline]\n    extern \"rust-call\" fn call_once(mut self, arg: (&'a [u8], )) -> &'a str {\n        self.call_mut(arg)\n    }\n}\n\nimpl<'a> FnMut<(&'a [u8], )> for UnsafeBytesToStr {\n    #[inline]\n    extern \"rust-call\" fn call_mut(&mut self, arg: (&'a [u8], )) -> &'a str {\n        unsafe { from_utf8_unchecked(arg.0) }\n    }\n}\n\n\n#[stable(feature = \"split_whitespace\", since = \"1.1.0\")]\nimpl<'a> Iterator for SplitWhitespace<'a> {\n    type Item = &'a str;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        self.inner.next()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"split_whitespace\", since = \"1.1.0\")]\nimpl<'a> DoubleEndedIterator for SplitWhitespace<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str> {\n        self.inner.next_back()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for SplitWhitespace<'_> {}\n\n#[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\nimpl<'a> Iterator for SplitAsciiWhitespace<'a> {\n    type Item = &'a str;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a str> {\n        self.inner.next()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\nimpl<'a> DoubleEndedIterator for SplitAsciiWhitespace<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a str> {\n        self.inner.next_back()\n    }\n}\n\n#[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\nimpl FusedIterator for SplitAsciiWhitespace<'_> {}\n\n/// An iterator of [`u16`] over the string encoded as UTF-16.\n///\n/// [`u16`]: ../../std/primitive.u16.html\n///\n/// This struct is created by the [`encode_utf16`] method on [`str`].\n/// See its documentation for more.\n///\n/// [`encode_utf16`]: ../../std/primitive.str.html#method.encode_utf16\n/// [`str`]: ../../std/primitive.str.html\n#[derive(Clone)]\n#[stable(feature = \"encode_utf16\", since = \"1.8.0\")]\npub struct EncodeUtf16<'a> {\n    chars: Chars<'a>,\n    extra: u16,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl fmt::Debug for EncodeUtf16<'_> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"EncodeUtf16 { .. }\")\n    }\n}\n\n#[stable(feature = \"encode_utf16\", since = \"1.8.0\")]\nimpl<'a> Iterator for EncodeUtf16<'a> {\n    type Item = u16;\n\n    #[inline]\n    fn next(&mut self) -> Option<u16> {\n        if self.extra != 0 {\n            let tmp = self.extra;\n            self.extra = 0;\n            return Some(tmp);\n        }\n\n        let mut buf = [0; 2];\n        self.chars.next().map(|ch| {\n            let n = ch.encode_utf16(&mut buf).len();\n            if n == 2 {\n                self.extra = buf[1];\n            }\n            buf[0]\n        })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (low, high) = self.chars.size_hint();\n        // every char gets either one u16 or two u16,\n        // so this iterator is between 1 or 2 times as\n        // long as the underlying iterator.\n        (low, high.and_then(|n| n.checked_mul(2)))\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for EncodeUtf16<'_> {}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A contiguous growable array type with heap-allocated contents, written\n//! `Vec<T>`.\n//!\n//! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and\n//! `O(1)` pop (from the end).\n//!\n//! # Examples\n//!\n//! You can explicitly create a [`Vec<T>`] with [`new`]:\n//!\n//! ```\n//! let v: Vec<i32> = Vec::new();\n//! ```\n//!\n//! ...or by using the [`vec!`] macro:\n//!\n//! ```\n//! let v: Vec<i32> = vec![];\n//!\n//! let v = vec![1, 2, 3, 4, 5];\n//!\n//! let v = vec![0; 10]; // ten zeroes\n//! ```\n//!\n//! You can [`push`] values onto the end of a vector (which will grow the vector\n//! as needed):\n//!\n//! ```\n//! let mut v = vec![1, 2];\n//!\n//! v.push(3);\n//! ```\n//!\n//! Popping values works in much the same way:\n//!\n//! ```\n//! let mut v = vec![1, 2];\n//!\n//! let two = v.pop();\n//! ```\n//!\n//! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits):\n//!\n//! ```\n//! let mut v = vec![1, 2, 3];\n//! let three = v[2];\n//! v[1] = v[1] + 5;\n//! ```\n//!\n//! [`Vec<T>`]: ../../std/vec/struct.Vec.html\n//! [`new`]: ../../std/vec/struct.Vec.html#method.new\n//! [`push`]: ../../std/vec/struct.Vec.html#method.push\n//! [`Index`]: ../../std/ops/trait.Index.html\n//! [`IndexMut`]: ../../std/ops/trait.IndexMut.html\n//! [`vec!`]: ../../std/macro.vec.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse core::cmp::{self, Ordering};\nuse core::fmt;\nuse core::hash::{self, Hash};\nuse core::intrinsics::{arith_offset, assume};\nuse core::iter::{FromIterator, FusedIterator, TrustedLen};\nuse core::marker::PhantomData;\nuse core::mem;\nuse core::ops::Bound::{Excluded, Included, Unbounded};\nuse core::ops::{Index, IndexMut, RangeBounds};\nuse core::ops;\nuse core::ptr;\nuse core::ptr::NonNull;\nuse core::slice;\n\nuse collections::CollectionAllocErr;\nuse borrow::ToOwned;\nuse borrow::Cow;\nuse boxed::Box;\nuse raw_vec::RawVec;\n\n/// A contiguous growable array type, written `Vec<T>` but pronounced 'vector'.\n///\n/// # Examples\n///\n/// ```\n/// let mut vec = Vec::new();\n/// vec.push(1);\n/// vec.push(2);\n///\n/// assert_eq!(vec.len(), 2);\n/// assert_eq!(vec[0], 1);\n///\n/// assert_eq!(vec.pop(), Some(2));\n/// assert_eq!(vec.len(), 1);\n///\n/// vec[0] = 7;\n/// assert_eq!(vec[0], 7);\n///\n/// vec.extend([1, 2, 3].iter().cloned());\n///\n/// for x in &vec {\n///     println!(\"{}\", x);\n/// }\n/// assert_eq!(vec, [7, 1, 2, 3]);\n/// ```\n///\n/// The [`vec!`] macro is provided to make initialization more convenient:\n///\n/// ```\n/// let mut vec = vec![1, 2, 3];\n/// vec.push(4);\n/// assert_eq!(vec, [1, 2, 3, 4]);\n/// ```\n///\n/// It can also initialize each element of a `Vec<T>` with a given value.\n/// This may be more efficient than performing allocation and initialization\n/// in separate steps, especially when initializing a vector of zeros:\n///\n/// ```\n/// let vec = vec![0; 5];\n/// assert_eq!(vec, [0, 0, 0, 0, 0]);\n///\n/// // The following is equivalent, but potentially slower:\n/// let mut vec1 = Vec::with_capacity(5);\n/// vec1.resize(5, 0);\n/// ```\n///\n/// Use a `Vec<T>` as an efficient stack:\n///\n/// ```\n/// let mut stack = Vec::new();\n///\n/// stack.push(1);\n/// stack.push(2);\n/// stack.push(3);\n///\n/// while let Some(top) = stack.pop() {\n///     // Prints 3, 2, 1\n///     println!(\"{}\", top);\n/// }\n/// ```\n///\n/// # Indexing\n///\n/// The `Vec` type allows to access values by index, because it implements the\n/// [`Index`] trait. An example will be more explicit:\n///\n/// ```\n/// let v = vec![0, 2, 4, 6];\n/// println!(\"{}\", v[1]); // it will display '2'\n/// ```\n///\n/// However be careful: if you try to access an index which isn't in the `Vec`,\n/// your software will panic! You cannot do this:\n///\n/// ```should_panic\n/// let v = vec![0, 2, 4, 6];\n/// println!(\"{}\", v[6]); // it will panic!\n/// ```\n///\n/// In conclusion: always check if the index you want to get really exists\n/// before doing it.\n///\n/// # Slicing\n///\n/// A `Vec` can be mutable. Slices, on the other hand, are read-only objects.\n/// To get a slice, use `&`. Example:\n///\n/// ```\n/// fn read_slice(slice: &[usize]) {\n///     // ...\n/// }\n///\n/// let v = vec![0, 1];\n/// read_slice(&v);\n///\n/// // ... and that's all!\n/// // you can also do it like this:\n/// let x : &[usize] = &v;\n/// ```\n///\n/// In Rust, it's more common to pass slices as arguments rather than vectors\n/// when you just want to provide a read access. The same goes for [`String`] and\n/// [`&str`].\n///\n/// # Capacity and reallocation\n///\n/// The capacity of a vector is the amount of space allocated for any future\n/// elements that will be added onto the vector. This is not to be confused with\n/// the *length* of a vector, which specifies the number of actual elements\n/// within the vector. If a vector's length exceeds its capacity, its capacity\n/// will automatically be increased, but its elements will have to be\n/// reallocated.\n///\n/// For example, a vector with capacity 10 and length 0 would be an empty vector\n/// with space for 10 more elements. Pushing 10 or fewer elements onto the\n/// vector will not change its capacity or cause reallocation to occur. However,\n/// if the vector's length is increased to 11, it will have to reallocate, which\n/// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`]\n/// whenever possible to specify how big the vector is expected to get.\n///\n/// # Guarantees\n///\n/// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees\n/// about its design. This ensures that it's as low-overhead as possible in\n/// the general case, and can be correctly manipulated in primitive ways\n/// by unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`.\n/// If additional type parameters are added (e.g. to support custom allocators),\n/// overriding their defaults may change the behavior.\n///\n/// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length)\n/// triplet. No more, no less. The order of these fields is completely\n/// unspecified, and you should use the appropriate methods to modify these.\n/// The pointer will never be null, so this type is null-pointer-optimized.\n///\n/// However, the pointer may not actually point to allocated memory. In particular,\n/// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],\n/// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]\n/// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized\n/// types inside a `Vec`, it will not allocate space for them. *Note that in this case\n/// the `Vec` may not report a [`capacity`] of 0*. `Vec` will allocate if and only\n/// if [`mem::size_of::<T>`]`() * capacity() > 0`. In general, `Vec`'s allocation\n/// details are very subtle &mdash; if you intend to allocate memory using a `Vec`\n/// and use it for something else (either to pass to unsafe code, or to build your\n/// own memory-backed collection), be sure to deallocate this memory by using\n/// `from_raw_parts` to recover the `Vec` and then dropping it.\n///\n/// If a `Vec` *has* allocated memory, then the memory it points to is on the heap\n/// (as defined by the allocator Rust is configured to use by default), and its\n/// pointer points to [`len`] initialized, contiguous elements in order (what\n/// you would see if you coerced it to a slice), followed by [`capacity`]` -\n/// `[`len`] logically uninitialized, contiguous elements.\n///\n/// `Vec` will never perform a \"small optimization\" where elements are actually\n/// stored on the stack for two reasons:\n///\n/// * It would make it more difficult for unsafe code to correctly manipulate\n///   a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were\n///   only moved, and it would be more difficult to determine if a `Vec` had\n///   actually allocated memory.\n///\n/// * It would penalize the general case, incurring an additional branch\n///   on every access.\n///\n/// `Vec` will never automatically shrink itself, even if completely empty. This\n/// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec`\n/// and then filling it back up to the same [`len`] should incur no calls to\n/// the allocator. If you wish to free up unused memory, use\n/// [`shrink_to_fit`][`shrink_to_fit`].\n///\n/// [`push`] and [`insert`] will never (re)allocate if the reported capacity is\n/// sufficient. [`push`] and [`insert`] *will* (re)allocate if\n/// [`len`]` == `[`capacity`]. That is, the reported capacity is completely\n/// accurate, and can be relied on. It can even be used to manually free the memory\n/// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even\n/// when not necessary.\n///\n/// `Vec` does not guarantee any particular growth strategy when reallocating\n/// when full, nor when [`reserve`] is called. The current strategy is basic\n/// and it may prove desirable to use a non-constant growth factor. Whatever\n/// strategy is used will of course guarantee `O(1)` amortized [`push`].\n///\n/// `vec![x; n]`, `vec![a, b, c, d]`, and\n/// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec`\n/// with exactly the requested capacity. If [`len`]` == `[`capacity`],\n/// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to\n/// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.\n///\n/// `Vec` will not specifically overwrite any data that is removed from it,\n/// but also won't specifically preserve it. Its uninitialized memory is\n/// scratch space that it may use however it wants. It will generally just do\n/// whatever is most efficient or otherwise easy to implement. Do not rely on\n/// removed data to be erased for security purposes. Even if you drop a `Vec`, its\n/// buffer may simply be reused by another `Vec`. Even if you zero a `Vec`'s memory\n/// first, that may not actually happen because the optimizer does not consider\n/// this a side-effect that must be preserved. There is one case which we will\n/// not break, however: using `unsafe` code to write to the excess capacity,\n/// and then increasing the length to match, is always valid.\n///\n/// `Vec` does not currently guarantee the order in which elements are dropped.\n/// The order has changed in the past and may change again.\n///\n/// [`vec!`]: ../../std/macro.vec.html\n/// [`Index`]: ../../std/ops/trait.Index.html\n/// [`String`]: ../../std/string/struct.String.html\n/// [`&str`]: ../../std/primitive.str.html\n/// [`Vec::with_capacity`]: ../../std/vec/struct.Vec.html#method.with_capacity\n/// [`Vec::new`]: ../../std/vec/struct.Vec.html#method.new\n/// [`shrink_to_fit`]: ../../std/vec/struct.Vec.html#method.shrink_to_fit\n/// [`capacity`]: ../../std/vec/struct.Vec.html#method.capacity\n/// [`mem::size_of::<T>`]: ../../std/mem/fn.size_of.html\n/// [`len`]: ../../std/vec/struct.Vec.html#method.len\n/// [`push`]: ../../std/vec/struct.Vec.html#method.push\n/// [`insert`]: ../../std/vec/struct.Vec.html#method.insert\n/// [`reserve`]: ../../std/vec/struct.Vec.html#method.reserve\n/// [owned slice]: ../../std/boxed/struct.Box.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Vec<T> {\n    buf: RawVec<T>,\n    len: usize,\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Inherent methods\n////////////////////////////////////////////////////////////////////////////////\n\nimpl<T> Vec<T> {\n    /// Constructs a new, empty `Vec<T>`.\n    ///\n    /// The vector will not allocate until elements are pushed onto it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![allow(unused_mut)]\n    /// let mut vec: Vec<i32> = Vec::new();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature = \"const_vec_new\")]\n    pub const fn new() -> Vec<T> {\n        Vec {\n            buf: RawVec::new(),\n            len: 0,\n        }\n    }\n\n    /// Constructs a new, empty `Vec<T>` with the specified capacity.\n    ///\n    /// The vector will be able to hold exactly `capacity` elements without\n    /// reallocating. If `capacity` is 0, the vector will not allocate.\n    ///\n    /// It is important to note that although the returned vector has the\n    /// *capacity* specified, the vector will have a zero *length*. For an\n    /// explanation of the difference between length and capacity, see\n    /// *[Capacity and reallocation]*.\n    ///\n    /// [Capacity and reallocation]: #capacity-and-reallocation\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = Vec::with_capacity(10);\n    ///\n    /// // The vector contains no items, even though it has capacity for more\n    /// assert_eq!(vec.len(), 0);\n    ///\n    /// // These are all done without reallocating...\n    /// for i in 0..10 {\n    ///     vec.push(i);\n    /// }\n    ///\n    /// // ...but this may make the vector reallocate\n    /// vec.push(11);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(capacity: usize) -> Vec<T> {\n        Vec {\n            buf: RawVec::with_capacity(capacity),\n            len: 0,\n        }\n    }\n\n    /// Creates a `Vec<T>` directly from the raw components of another vector.\n    ///\n    /// # Safety\n    ///\n    /// This is highly unsafe, due to the number of invariants that aren't\n    /// checked:\n    ///\n    /// * `ptr` needs to have been previously allocated via [`String`]/`Vec<T>`\n    ///   (at least, it's highly likely to be incorrect if it wasn't).\n    /// * `ptr`'s `T` needs to have the same size and alignment as it was allocated with.\n    /// * `length` needs to be less than or equal to `capacity`.\n    /// * `capacity` needs to be the capacity that the pointer was allocated with.\n    ///\n    /// Violating these may cause problems like corrupting the allocator's\n    /// internal data structures. For example it is **not** safe\n    /// to build a `Vec<u8>` from a pointer to a C `char` array and a `size_t`.\n    ///\n    /// The ownership of `ptr` is effectively transferred to the\n    /// `Vec<T>` which may then deallocate, reallocate or change the\n    /// contents of memory pointed to by the pointer at will. Ensure\n    /// that nothing else uses the pointer after calling this\n    /// function.\n    ///\n    /// [`String`]: ../../std/string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ptr;\n    /// use std::mem;\n    ///\n    /// fn main() {\n    ///     let mut v = vec![1, 2, 3];\n    ///\n    ///     // Pull out the various important pieces of information about `v`\n    ///     let p = v.as_mut_ptr();\n    ///     let len = v.len();\n    ///     let cap = v.capacity();\n    ///\n    ///     unsafe {\n    ///         // Cast `v` into the void: no destructor run, so we are in\n    ///         // complete control of the allocation to which `p` points.\n    ///         mem::forget(v);\n    ///\n    ///         // Overwrite memory with 4, 5, 6\n    ///         for i in 0..len as isize {\n    ///             ptr::write(p.offset(i), 4 + i);\n    ///         }\n    ///\n    ///         // Put everything back together into a Vec\n    ///         let rebuilt = Vec::from_raw_parts(p, len, cap);\n    ///         assert_eq!(rebuilt, [4, 5, 6]);\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Vec<T> {\n        Vec {\n            buf: RawVec::from_raw_parts(ptr, capacity),\n            len: length,\n        }\n    }\n\n    /// Returns the number of elements the vector can hold without\n    /// reallocating.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let vec: Vec<i32> = Vec::with_capacity(10);\n    /// assert_eq!(vec.capacity(), 10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn capacity(&self) -> usize {\n        self.buf.cap()\n    }\n\n    /// Reserves capacity for at least `additional` more elements to be inserted\n    /// in the given `Vec<T>`. The collection may reserve more space to avoid\n    /// frequent reallocations. After calling `reserve`, capacity will be\n    /// greater than or equal to `self.len() + additional`. Does nothing if\n    /// capacity is already sufficient.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new capacity overflows `usize`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1];\n    /// vec.reserve(10);\n    /// assert!(vec.capacity() >= 11);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reserve(&mut self, additional: usize) {\n        self.buf.reserve(self.len, additional);\n    }\n\n    /// Reserves the minimum capacity for exactly `additional` more elements to\n    /// be inserted in the given `Vec<T>`. After calling `reserve_exact`,\n    /// capacity will be greater than or equal to `self.len() + additional`.\n    /// Does nothing if the capacity is already sufficient.\n    ///\n    /// Note that the allocator may give the collection more space than it\n    /// requests. Therefore capacity can not be relied upon to be precisely\n    /// minimal. Prefer `reserve` if future insertions are expected.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new capacity overflows `usize`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1];\n    /// vec.reserve_exact(10);\n    /// assert!(vec.capacity() >= 11);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reserve_exact(&mut self, additional: usize) {\n        self.buf.reserve_exact(self.len, additional);\n    }\n\n    /// Tries to reserve capacity for at least `additional` more elements to be inserted\n    /// in the given `Vec<T>`. The collection may reserve more space to avoid\n    /// frequent reallocations. After calling `reserve`, capacity will be\n    /// greater than or equal to `self.len() + additional`. Does nothing if\n    /// capacity is already sufficient.\n    ///\n    /// # Errors\n    ///\n    /// If the capacity overflows, or the allocator reports a failure, then an error\n    /// is returned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(try_reserve)]\n    /// use std::collections::CollectionAllocErr;\n    ///\n    /// fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr> {\n    ///     let mut output = Vec::new();\n    ///\n    ///     // Pre-reserve the memory, exiting if we can't\n    ///     output.try_reserve(data.len())?;\n    ///\n    ///     // Now we know this can't OOM in the middle of our complex work\n    ///     output.extend(data.iter().map(|&val| {\n    ///         val * 2 + 5 // very complicated\n    ///     }));\n    ///\n    ///     Ok(output)\n    /// }\n    /// # process_data(&[1, 2, 3]).expect(\"why is the test harness OOMing on 12 bytes?\");\n    /// ```\n    #[unstable(feature = \"try_reserve\", reason = \"new API\", issue=\"48043\")]\n    pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {\n        self.buf.try_reserve(self.len, additional)\n    }\n\n    /// Tries to reserves the minimum capacity for exactly `additional` more elements to\n    /// be inserted in the given `Vec<T>`. After calling `reserve_exact`,\n    /// capacity will be greater than or equal to `self.len() + additional`.\n    /// Does nothing if the capacity is already sufficient.\n    ///\n    /// Note that the allocator may give the collection more space than it\n    /// requests. Therefore capacity can not be relied upon to be precisely\n    /// minimal. Prefer `reserve` if future insertions are expected.\n    ///\n    /// # Errors\n    ///\n    /// If the capacity overflows, or the allocator reports a failure, then an error\n    /// is returned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(try_reserve)]\n    /// use std::collections::CollectionAllocErr;\n    ///\n    /// fn process_data(data: &[u32]) -> Result<Vec<u32>, CollectionAllocErr> {\n    ///     let mut output = Vec::new();\n    ///\n    ///     // Pre-reserve the memory, exiting if we can't\n    ///     output.try_reserve(data.len())?;\n    ///\n    ///     // Now we know this can't OOM in the middle of our complex work\n    ///     output.extend(data.iter().map(|&val| {\n    ///         val * 2 + 5 // very complicated\n    ///     }));\n    ///\n    ///     Ok(output)\n    /// }\n    /// # process_data(&[1, 2, 3]).expect(\"why is the test harness OOMing on 12 bytes?\");\n    /// ```\n    #[unstable(feature = \"try_reserve\", reason = \"new API\", issue=\"48043\")]\n    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr>  {\n        self.buf.try_reserve_exact(self.len, additional)\n    }\n\n    /// Shrinks the capacity of the vector as much as possible.\n    ///\n    /// It will drop down as close as possible to the length but the allocator\n    /// may still inform the vector that there is space for a few more elements.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = Vec::with_capacity(10);\n    /// vec.extend([1, 2, 3].iter().cloned());\n    /// assert_eq!(vec.capacity(), 10);\n    /// vec.shrink_to_fit();\n    /// assert!(vec.capacity() >= 3);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn shrink_to_fit(&mut self) {\n        if self.capacity() != self.len {\n            self.buf.shrink_to_fit(self.len);\n        }\n    }\n\n    /// Shrinks the capacity of the vector with a lower bound.\n    ///\n    /// The capacity will remain at least as large as both the length\n    /// and the supplied value.\n    ///\n    /// Panics if the current capacity is smaller than the supplied\n    /// minimum capacity.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(shrink_to)]\n    /// let mut vec = Vec::with_capacity(10);\n    /// vec.extend([1, 2, 3].iter().cloned());\n    /// assert_eq!(vec.capacity(), 10);\n    /// vec.shrink_to(4);\n    /// assert!(vec.capacity() >= 4);\n    /// vec.shrink_to(0);\n    /// assert!(vec.capacity() >= 3);\n    /// ```\n    #[unstable(feature = \"shrink_to\", reason = \"new API\", issue=\"0\")]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        self.buf.shrink_to_fit(cmp::max(self.len, min_capacity));\n    }\n\n    /// Converts the vector into [`Box<[T]>`][owned slice].\n    ///\n    /// Note that this will drop any excess capacity.\n    ///\n    /// [owned slice]: ../../std/boxed/struct.Box.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = vec![1, 2, 3];\n    ///\n    /// let slice = v.into_boxed_slice();\n    /// ```\n    ///\n    /// Any excess capacity is removed:\n    ///\n    /// ```\n    /// let mut vec = Vec::with_capacity(10);\n    /// vec.extend([1, 2, 3].iter().cloned());\n    ///\n    /// assert_eq!(vec.capacity(), 10);\n    /// let slice = vec.into_boxed_slice();\n    /// assert_eq!(slice.into_vec().capacity(), 3);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_boxed_slice(mut self) -> Box<[T]> {\n        unsafe {\n            self.shrink_to_fit();\n            let buf = ptr::read(&self.buf);\n            mem::forget(self);\n            buf.into_box()\n        }\n    }\n\n    /// Shortens the vector, keeping the first `len` elements and dropping\n    /// the rest.\n    ///\n    /// If `len` is greater than the vector's current length, this has no\n    /// effect.\n    ///\n    /// The [`drain`] method can emulate `truncate`, but causes the excess\n    /// elements to be returned instead of dropped.\n    ///\n    /// Note that this method has no effect on the allocated capacity\n    /// of the vector.\n    ///\n    /// # Examples\n    ///\n    /// Truncating a five element vector to two elements:\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3, 4, 5];\n    /// vec.truncate(2);\n    /// assert_eq!(vec, [1, 2]);\n    /// ```\n    ///\n    /// No truncation occurs when `len` is greater than the vector's current\n    /// length:\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3];\n    /// vec.truncate(8);\n    /// assert_eq!(vec, [1, 2, 3]);\n    /// ```\n    ///\n    /// Truncating when `len == 0` is equivalent to calling the [`clear`]\n    /// method.\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3];\n    /// vec.truncate(0);\n    /// assert_eq!(vec, []);\n    /// ```\n    ///\n    /// [`clear`]: #method.clear\n    /// [`drain`]: #method.drain\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn truncate(&mut self, len: usize) {\n        let current_len = self.len;\n        unsafe {\n            let mut ptr = self.as_mut_ptr().add(self.len);\n            // Set the final length at the end, keeping in mind that\n            // dropping an element might panic. Works around a missed\n            // optimization, as seen in the following issue:\n            // https://github.com/rust-lang/rust/issues/51802\n            let mut local_len = SetLenOnDrop::new(&mut self.len);\n\n            // drop any extra elements\n            for _ in len..current_len {\n                local_len.decrement_len(1);\n                ptr = ptr.offset(-1);\n                ptr::drop_in_place(ptr);\n            }\n        }\n    }\n\n    /// Extracts a slice containing the entire vector.\n    ///\n    /// Equivalent to `&s[..]`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{self, Write};\n    /// let buffer = vec![1, 2, 3, 5, 8];\n    /// io::sink().write(buffer.as_slice()).unwrap();\n    /// ```\n    #[inline]\n    #[stable(feature = \"vec_as_slice\", since = \"1.7.0\")]\n    pub fn as_slice(&self) -> &[T] {\n        self\n    }\n\n    /// Extracts a mutable slice of the entire vector.\n    ///\n    /// Equivalent to `&mut s[..]`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{self, Read};\n    /// let mut buffer = vec![0; 3];\n    /// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();\n    /// ```\n    #[inline]\n    #[stable(feature = \"vec_as_slice\", since = \"1.7.0\")]\n    pub fn as_mut_slice(&mut self) -> &mut [T] {\n        self\n    }\n\n    /// Sets the length of a vector.\n    ///\n    /// This will explicitly set the size of the vector, without actually\n    /// modifying its buffers, so it is up to the caller to ensure that the\n    /// vector is actually the specified size.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ptr;\n    ///\n    /// let mut vec = vec!['r', 'u', 's', 't'];\n    ///\n    /// unsafe {\n    ///     ptr::drop_in_place(&mut vec[3]);\n    ///     vec.set_len(3);\n    /// }\n    /// assert_eq!(vec, ['r', 'u', 's']);\n    /// ```\n    ///\n    /// In this example, there is a memory leak since the memory locations\n    /// owned by the inner vectors were not freed prior to the `set_len` call:\n    ///\n    /// ```\n    /// let mut vec = vec![vec![1, 0, 0],\n    ///                    vec![0, 1, 0],\n    ///                    vec![0, 0, 1]];\n    /// unsafe {\n    ///     vec.set_len(0);\n    /// }\n    /// ```\n    ///\n    /// In this example, the vector gets expanded from zero to four items\n    /// without any memory allocations occurring, resulting in vector\n    /// values of unallocated memory:\n    ///\n    /// ```\n    /// let mut vec: Vec<char> = Vec::new();\n    ///\n    /// unsafe {\n    ///     vec.set_len(4);\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn set_len(&mut self, len: usize) {\n        self.len = len;\n    }\n\n    /// Removes an element from the vector and returns it.\n    ///\n    /// The removed element is replaced by the last element of the vector.\n    ///\n    /// This does not preserve ordering, but is O(1).\n    ///\n    /// # Panics\n    ///\n    /// Panics if `index` is out of bounds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = vec![\"foo\", \"bar\", \"baz\", \"qux\"];\n    ///\n    /// assert_eq!(v.swap_remove(1), \"bar\");\n    /// assert_eq!(v, [\"foo\", \"qux\", \"baz\"]);\n    ///\n    /// assert_eq!(v.swap_remove(0), \"foo\");\n    /// assert_eq!(v, [\"baz\", \"qux\"]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn swap_remove(&mut self, index: usize) -> T {\n        unsafe {\n            // We replace self[index] with the last element. Note that if the\n            // bounds check on hole succeeds there must be a last element (which\n            // can be self[index] itself).\n            let hole: *mut T = &mut self[index];\n            let last = ptr::read(self.get_unchecked(self.len - 1));\n            self.len -= 1;\n            ptr::replace(hole, last)\n        }\n    }\n\n    /// Inserts an element at position `index` within the vector, shifting all\n    /// elements after it to the right.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `index > len`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3];\n    /// vec.insert(1, 4);\n    /// assert_eq!(vec, [1, 4, 2, 3]);\n    /// vec.insert(4, 5);\n    /// assert_eq!(vec, [1, 4, 2, 3, 5]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, index: usize, element: T) {\n        let len = self.len();\n        assert!(index <= len);\n\n        // space for the new element\n        if len == self.buf.cap() {\n            self.reserve(1);\n        }\n\n        unsafe {\n            // infallible\n            // The spot to put the new value\n            {\n                let p = self.as_mut_ptr().add(index);\n                // Shift everything over to make space. (Duplicating the\n                // `index`th element into two consecutive places.)\n                ptr::copy(p, p.offset(1), len - index);\n                // Write it in, overwriting the first copy of the `index`th\n                // element.\n                ptr::write(p, element);\n            }\n            self.set_len(len + 1);\n        }\n    }\n\n    /// Removes and returns the element at position `index` within the vector,\n    /// shifting all elements after it to the left.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `index` is out of bounds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = vec![1, 2, 3];\n    /// assert_eq!(v.remove(1), 2);\n    /// assert_eq!(v, [1, 3]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove(&mut self, index: usize) -> T {\n        let len = self.len();\n        assert!(index < len);\n        unsafe {\n            // infallible\n            let ret;\n            {\n                // the place we are taking from.\n                let ptr = self.as_mut_ptr().add(index);\n                // copy it out, unsafely having a copy of the value on\n                // the stack and in the vector at the same time.\n                ret = ptr::read(ptr);\n\n                // Shift everything down to fill in that spot.\n                ptr::copy(ptr.offset(1), ptr, len - index - 1);\n            }\n            self.set_len(len - 1);\n            ret\n        }\n    }\n\n    /// Retains only the elements specified by the predicate.\n    ///\n    /// In other words, remove all elements `e` such that `f(&e)` returns `false`.\n    /// This method operates in place and preserves the order of the retained\n    /// elements.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3, 4];\n    /// vec.retain(|&x| x%2 == 0);\n    /// assert_eq!(vec, [2, 4]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn retain<F>(&mut self, mut f: F)\n        where F: FnMut(&T) -> bool\n    {\n        self.drain_filter(|x| !f(x));\n    }\n\n    /// Removes all but the first of consecutive elements in the vector that resolve to the same\n    /// key.\n    ///\n    /// If the vector is sorted, this removes all duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![10, 20, 21, 30, 20];\n    ///\n    /// vec.dedup_by_key(|i| *i / 10);\n    ///\n    /// assert_eq!(vec, [10, 20, 30, 20]);\n    /// ```\n    #[stable(feature = \"dedup_by\", since = \"1.16.0\")]\n    #[inline]\n    pub fn dedup_by_key<F, K>(&mut self, mut key: F) where F: FnMut(&mut T) -> K, K: PartialEq {\n        self.dedup_by(|a, b| key(a) == key(b))\n    }\n\n    /// Removes all but the first of consecutive elements in the vector satisfying a given equality\n    /// relation.\n    ///\n    /// The `same_bucket` function is passed references to two elements from the vector and\n    /// must determine if the elements compare equal. The elements are passed in opposite order\n    /// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed.\n    ///\n    /// If the vector is sorted, this removes all duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![\"foo\", \"bar\", \"Bar\", \"baz\", \"bar\"];\n    ///\n    /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));\n    ///\n    /// assert_eq!(vec, [\"foo\", \"bar\", \"baz\", \"bar\"]);\n    /// ```\n    #[stable(feature = \"dedup_by\", since = \"1.16.0\")]\n    pub fn dedup_by<F>(&mut self, same_bucket: F) where F: FnMut(&mut T, &mut T) -> bool {\n        let len = {\n            let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);\n            dedup.len()\n        };\n        self.truncate(len);\n    }\n\n    /// Appends an element to the back of a collection.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the number of elements in the vector overflows a `usize`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2];\n    /// vec.push(3);\n    /// assert_eq!(vec, [1, 2, 3]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn push(&mut self, value: T) {\n        // This will panic or abort if we would allocate > isize::MAX bytes\n        // or if the length increment would overflow for zero-sized types.\n        if self.len == self.buf.cap() {\n            self.reserve(1);\n        }\n        unsafe {\n            let end = self.as_mut_ptr().add(self.len);\n            ptr::write(end, value);\n            self.len += 1;\n        }\n    }\n\n    /// Removes the last element from a vector and returns it, or [`None`] if it\n    /// is empty.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3];\n    /// assert_eq!(vec.pop(), Some(3));\n    /// assert_eq!(vec, [1, 2]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn pop(&mut self) -> Option<T> {\n        if self.len == 0 {\n            None\n        } else {\n            unsafe {\n                self.len -= 1;\n                Some(ptr::read(self.get_unchecked(self.len())))\n            }\n        }\n    }\n\n    /// Moves all the elements of `other` into `Self`, leaving `other` empty.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the number of elements in the vector overflows a `usize`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 3];\n    /// let mut vec2 = vec![4, 5, 6];\n    /// vec.append(&mut vec2);\n    /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);\n    /// assert_eq!(vec2, []);\n    /// ```\n    #[inline]\n    #[stable(feature = \"append\", since = \"1.4.0\")]\n    pub fn append(&mut self, other: &mut Self) {\n        unsafe {\n            self.append_elements(other.as_slice() as _);\n            other.set_len(0);\n        }\n    }\n\n    /// Appends elements to `Self` from other buffer.\n    #[inline]\n    unsafe fn append_elements(&mut self, other: *const [T]) {\n        let count = (*other).len();\n        self.reserve(count);\n        let len = self.len();\n        ptr::copy_nonoverlapping(other as *const T, self.get_unchecked_mut(len), count);\n        self.len += count;\n    }\n\n    /// Creates a draining iterator that removes the specified range in the vector\n    /// and yields the removed items.\n    ///\n    /// Note 1: The element range is removed even if the iterator is only\n    /// partially consumed or not consumed at all.\n    ///\n    /// Note 2: It is unspecified how many elements are removed from the vector\n    /// if the `Drain` value is leaked.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the starting point is greater than the end point or if\n    /// the end point is greater than the length of the vector.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = vec![1, 2, 3];\n    /// let u: Vec<_> = v.drain(1..).collect();\n    /// assert_eq!(v, &[1]);\n    /// assert_eq!(u, &[2, 3]);\n    ///\n    /// // A full range clears the vector\n    /// v.drain(..);\n    /// assert_eq!(v, &[]);\n    /// ```\n    #[stable(feature = \"drain\", since = \"1.6.0\")]\n    pub fn drain<R>(&mut self, range: R) -> Drain<T>\n        where R: RangeBounds<usize>\n    {\n        // Memory safety\n        //\n        // When the Drain is first created, it shortens the length of\n        // the source vector to make sure no uninitialized or moved-from elements\n        // are accessible at all if the Drain's destructor never gets to run.\n        //\n        // Drain will ptr::read out the values to remove.\n        // When finished, remaining tail of the vec is copied back to cover\n        // the hole, and the vector length is restored to the new length.\n        //\n        let len = self.len();\n        let start = match range.start_bound() {\n            Included(&n) => n,\n            Excluded(&n) => n + 1,\n            Unbounded    => 0,\n        };\n        let end = match range.end_bound() {\n            Included(&n) => n + 1,\n            Excluded(&n) => n,\n            Unbounded    => len,\n        };\n        assert!(start <= end);\n        assert!(end <= len);\n\n        unsafe {\n            // set self.vec length's to start, to be safe in case Drain is leaked\n            self.set_len(start);\n            // Use the borrow in the IterMut to indicate borrowing behavior of the\n            // whole Drain iterator (like &mut T).\n            let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start),\n                                                        end - start);\n            Drain {\n                tail_start: end,\n                tail_len: len - end,\n                iter: range_slice.iter(),\n                vec: NonNull::from(self),\n            }\n        }\n    }\n\n    /// Clears the vector, removing all values.\n    ///\n    /// Note that this method has no effect on the allocated capacity\n    /// of the vector.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = vec![1, 2, 3];\n    ///\n    /// v.clear();\n    ///\n    /// assert!(v.is_empty());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn clear(&mut self) {\n        self.truncate(0)\n    }\n\n    /// Returns the number of elements in the vector, also referred to\n    /// as its 'length'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = vec![1, 2, 3];\n    /// assert_eq!(a.len(), 3);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn len(&self) -> usize {\n        self.len\n    }\n\n    /// Returns `true` if the vector contains no elements.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = Vec::new();\n    /// assert!(v.is_empty());\n    ///\n    /// v.push(1);\n    /// assert!(!v.is_empty());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n\n    /// Splits the collection into two at the given index.\n    ///\n    /// Returns a newly allocated `Self`. `self` contains elements `[0, at)`,\n    /// and the returned `Self` contains elements `[at, len)`.\n    ///\n    /// Note that the capacity of `self` does not change.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `at > len`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1,2,3];\n    /// let vec2 = vec.split_off(1);\n    /// assert_eq!(vec, [1]);\n    /// assert_eq!(vec2, [2, 3]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"split_off\", since = \"1.4.0\")]\n    pub fn split_off(&mut self, at: usize) -> Self {\n        assert!(at <= self.len(), \"`at` out of bounds\");\n\n        let other_len = self.len - at;\n        let mut other = Vec::with_capacity(other_len);\n\n        // Unsafely `set_len` and copy items to `other`.\n        unsafe {\n            self.set_len(at);\n            other.set_len(other_len);\n\n            ptr::copy_nonoverlapping(self.as_ptr().add(at),\n                                     other.as_mut_ptr(),\n                                     other.len());\n        }\n        other\n    }\n\n    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.\n    ///\n    /// If `new_len` is greater than `len`, the `Vec` is extended by the\n    /// difference, with each additional slot filled with the result of\n    /// calling the closure `f`. The return values from `f` will end up\n    /// in the `Vec` in the order they have been generated.\n    ///\n    /// If `new_len` is less than `len`, the `Vec` is simply truncated.\n    ///\n    /// This method uses a closure to create new values on every push. If\n    /// you'd rather [`Clone`] a given value, use [`resize`]. If you want\n    /// to use the [`Default`] trait to generate values, you can pass\n    /// [`Default::default()`] as the second argument..\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(vec_resize_with)]\n    ///\n    /// let mut vec = vec![1, 2, 3];\n    /// vec.resize_with(5, Default::default);\n    /// assert_eq!(vec, [1, 2, 3, 0, 0]);\n    ///\n    /// let mut vec = vec![];\n    /// let mut p = 1;\n    /// vec.resize_with(4, || { p *= 2; p });\n    /// assert_eq!(vec, [2, 4, 8, 16]);\n    /// ```\n    ///\n    /// [`resize`]: #method.resize\n    /// [`Clone`]: ../../std/clone/trait.Clone.html\n    #[unstable(feature = \"vec_resize_with\", issue = \"41758\")]\n    pub fn resize_with<F>(&mut self, new_len: usize, f: F)\n        where F: FnMut() -> T\n    {\n        let len = self.len();\n        if new_len > len {\n            self.extend_with(new_len - len, ExtendFunc(f));\n        } else {\n            self.truncate(new_len);\n        }\n    }\n}\n\nimpl<T: Clone> Vec<T> {\n    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.\n    ///\n    /// If `new_len` is greater than `len`, the `Vec` is extended by the\n    /// difference, with each additional slot filled with `value`.\n    /// If `new_len` is less than `len`, the `Vec` is simply truncated.\n    ///\n    /// This method requires [`Clone`] to be able clone the passed value. If\n    /// you need more flexibility (or want to rely on [`Default`] instead of\n    /// [`Clone`]), use [`resize_with`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![\"hello\"];\n    /// vec.resize(3, \"world\");\n    /// assert_eq!(vec, [\"hello\", \"world\", \"world\"]);\n    ///\n    /// let mut vec = vec![1, 2, 3, 4];\n    /// vec.resize(2, 0);\n    /// assert_eq!(vec, [1, 2]);\n    /// ```\n    ///\n    /// [`Clone`]: ../../std/clone/trait.Clone.html\n    /// [`Default`]: ../../std/default/trait.Default.html\n    /// [`resize_with`]: #method.resize_with\n    #[stable(feature = \"vec_resize\", since = \"1.5.0\")]\n    pub fn resize(&mut self, new_len: usize, value: T) {\n        let len = self.len();\n\n        if new_len > len {\n            self.extend_with(new_len - len, ExtendElement(value))\n        } else {\n            self.truncate(new_len);\n        }\n    }\n\n    /// Clones and appends all elements in a slice to the `Vec`.\n    ///\n    /// Iterates over the slice `other`, clones each element, and then appends\n    /// it to this `Vec`. The `other` vector is traversed in-order.\n    ///\n    /// Note that this function is same as [`extend`] except that it is\n    /// specialized to work with slices instead. If and when Rust gets\n    /// specialization this function will likely be deprecated (but still\n    /// available).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1];\n    /// vec.extend_from_slice(&[2, 3, 4]);\n    /// assert_eq!(vec, [1, 2, 3, 4]);\n    /// ```\n    ///\n    /// [`extend`]: #method.extend\n    #[stable(feature = \"vec_extend_from_slice\", since = \"1.6.0\")]\n    pub fn extend_from_slice(&mut self, other: &[T]) {\n        self.spec_extend(other.iter())\n    }\n}\n\nimpl<T: Default> Vec<T> {\n    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.\n    ///\n    /// If `new_len` is greater than `len`, the `Vec` is extended by the\n    /// difference, with each additional slot filled with [`Default::default()`].\n    /// If `new_len` is less than `len`, the `Vec` is simply truncated.\n    ///\n    /// This method uses [`Default`] to create new values on every push. If\n    /// you'd rather [`Clone`] a given value, use [`resize`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(vec_resize_default)]\n    ///\n    /// let mut vec = vec![1, 2, 3];\n    /// vec.resize_default(5);\n    /// assert_eq!(vec, [1, 2, 3, 0, 0]);\n    ///\n    /// let mut vec = vec![1, 2, 3, 4];\n    /// vec.resize_default(2);\n    /// assert_eq!(vec, [1, 2]);\n    /// ```\n    ///\n    /// [`resize`]: #method.resize\n    /// [`Default::default()`]: ../../std/default/trait.Default.html#tymethod.default\n    /// [`Default`]: ../../std/default/trait.Default.html\n    /// [`Clone`]: ../../std/clone/trait.Clone.html\n    #[unstable(feature = \"vec_resize_default\", issue = \"41758\")]\n    pub fn resize_default(&mut self, new_len: usize) {\n        let len = self.len();\n\n        if new_len > len {\n            self.extend_with(new_len - len, ExtendDefault);\n        } else {\n            self.truncate(new_len);\n        }\n    }\n}\n\n// This code generalises `extend_with_{element,default}`.\ntrait ExtendWith<T> {\n    fn next(&mut self) -> T;\n    fn last(self) -> T;\n}\n\nstruct ExtendElement<T>(T);\nimpl<T: Clone> ExtendWith<T> for ExtendElement<T> {\n    fn next(&mut self) -> T { self.0.clone() }\n    fn last(self) -> T { self.0 }\n}\n\nstruct ExtendDefault;\nimpl<T: Default> ExtendWith<T> for ExtendDefault {\n    fn next(&mut self) -> T { Default::default() }\n    fn last(self) -> T { Default::default() }\n}\n\nstruct ExtendFunc<F>(F);\nimpl<T, F: FnMut() -> T> ExtendWith<T> for ExtendFunc<F> {\n    fn next(&mut self) -> T { (self.0)() }\n    fn last(mut self) -> T { (self.0)() }\n}\n\nimpl<T> Vec<T> {\n    /// Extend the vector by `n` values, using the given generator.\n    fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {\n        self.reserve(n);\n\n        unsafe {\n            let mut ptr = self.as_mut_ptr().add(self.len());\n            // Use SetLenOnDrop to work around bug where compiler\n            // may not realize the store through `ptr` through self.set_len()\n            // don't alias.\n            let mut local_len = SetLenOnDrop::new(&mut self.len);\n\n            // Write all elements except the last one\n            for _ in 1..n {\n                ptr::write(ptr, value.next());\n                ptr = ptr.offset(1);\n                // Increment the length in every step in case next() panics\n                local_len.increment_len(1);\n            }\n\n            if n > 0 {\n                // We can write the last element directly without cloning needlessly\n                ptr::write(ptr, value.last());\n                local_len.increment_len(1);\n            }\n\n            // len set by scope guard\n        }\n    }\n}\n\n// Set the length of the vec when the `SetLenOnDrop` value goes out of scope.\n//\n// The idea is: The length field in SetLenOnDrop is a local variable\n// that the optimizer will see does not alias with any stores through the Vec's data\n// pointer. This is a workaround for alias analysis issue #32155\nstruct SetLenOnDrop<'a> {\n    len: &'a mut usize,\n    local_len: usize,\n}\n\nimpl<'a> SetLenOnDrop<'a> {\n    #[inline]\n    fn new(len: &'a mut usize) -> Self {\n        SetLenOnDrop { local_len: *len, len: len }\n    }\n\n    #[inline]\n    fn increment_len(&mut self, increment: usize) {\n        self.local_len += increment;\n    }\n\n    #[inline]\n    fn decrement_len(&mut self, decrement: usize) {\n        self.local_len -= decrement;\n    }\n}\n\nimpl<'a> Drop for SetLenOnDrop<'a> {\n    #[inline]\n    fn drop(&mut self) {\n        *self.len = self.local_len;\n    }\n}\n\nimpl<T: PartialEq> Vec<T> {\n    /// Removes consecutive repeated elements in the vector according to the\n    /// [`PartialEq`] trait implementation.\n    ///\n    /// If the vector is sorted, this removes all duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut vec = vec![1, 2, 2, 3, 2];\n    ///\n    /// vec.dedup();\n    ///\n    /// assert_eq!(vec, [1, 2, 3, 2]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn dedup(&mut self) {\n        self.dedup_by(|a, b| a == b)\n    }\n\n    /// Removes the first instance of `item` from the vector if the item exists.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(vec_remove_item)]\n    /// let mut vec = vec![1, 2, 3, 1];\n    ///\n    /// vec.remove_item(&1);\n    ///\n    /// assert_eq!(vec, vec![2, 3, 1]);\n    /// ```\n    #[unstable(feature = \"vec_remove_item\", reason = \"recently added\", issue = \"40062\")]\n    pub fn remove_item(&mut self, item: &T) -> Option<T> {\n        let pos = self.iter().position(|x| *x == *item)?;\n        Some(self.remove(pos))\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Internal methods and functions\n////////////////////////////////////////////////////////////////////////////////\n\n#[doc(hidden)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {\n    <T as SpecFromElem>::from_elem(elem, n)\n}\n\n// Specialization trait used for Vec::from_elem\ntrait SpecFromElem: Sized {\n    fn from_elem(elem: Self, n: usize) -> Vec<Self>;\n}\n\nimpl<T: Clone> SpecFromElem for T {\n    default fn from_elem(elem: Self, n: usize) -> Vec<Self> {\n        let mut v = Vec::with_capacity(n);\n        v.extend_with(n, ExtendElement(elem));\n        v\n    }\n}\n\nimpl SpecFromElem for u8 {\n    #[inline]\n    fn from_elem(elem: u8, n: usize) -> Vec<u8> {\n        if elem == 0 {\n            return Vec {\n                buf: RawVec::with_capacity_zeroed(n),\n                len: n,\n            }\n        }\n        unsafe {\n            let mut v = Vec::with_capacity(n);\n            ptr::write_bytes(v.as_mut_ptr(), elem, n);\n            v.set_len(n);\n            v\n        }\n    }\n}\n\nimpl<T: Clone + IsZero> SpecFromElem for T {\n    #[inline]\n    fn from_elem(elem: T, n: usize) -> Vec<T> {\n        if elem.is_zero() {\n            return Vec {\n                buf: RawVec::with_capacity_zeroed(n),\n                len: n,\n            }\n        }\n        let mut v = Vec::with_capacity(n);\n        v.extend_with(n, ExtendElement(elem));\n        v\n    }\n}\n\nunsafe trait IsZero {\n    /// Whether this value is zero\n    fn is_zero(&self) -> bool;\n}\n\nmacro_rules! impl_is_zero {\n    ($t: ty, $is_zero: expr) => {\n        unsafe impl IsZero for $t {\n            #[inline]\n            fn is_zero(&self) -> bool {\n                $is_zero(*self)\n            }\n        }\n    }\n}\n\nimpl_is_zero!(i8, |x| x == 0);\nimpl_is_zero!(i16, |x| x == 0);\nimpl_is_zero!(i32, |x| x == 0);\nimpl_is_zero!(i64, |x| x == 0);\nimpl_is_zero!(i128, |x| x == 0);\nimpl_is_zero!(isize, |x| x == 0);\n\nimpl_is_zero!(u16, |x| x == 0);\nimpl_is_zero!(u32, |x| x == 0);\nimpl_is_zero!(u64, |x| x == 0);\nimpl_is_zero!(u128, |x| x == 0);\nimpl_is_zero!(usize, |x| x == 0);\n\nimpl_is_zero!(char, |x| x == '\\0');\n\nimpl_is_zero!(f32, |x: f32| x.to_bits() == 0);\nimpl_is_zero!(f64, |x: f64| x.to_bits() == 0);\n\nunsafe impl<T: ?Sized> IsZero for *const T {\n    #[inline]\n    fn is_zero(&self) -> bool {\n        (*self).is_null()\n    }\n}\n\nunsafe impl<T: ?Sized> IsZero for *mut T {\n    #[inline]\n    fn is_zero(&self) -> bool {\n        (*self).is_null()\n    }\n}\n\n\n////////////////////////////////////////////////////////////////////////////////\n// Common trait implementations for Vec\n////////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Clone> Clone for Vec<T> {\n    #[cfg(not(test))]\n    fn clone(&self) -> Vec<T> {\n        <[T]>::to_vec(&**self)\n    }\n\n    // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is\n    // required for this method definition, is not available. Instead use the\n    // `slice::to_vec`  function which is only available with cfg(test)\n    // NB see the slice::hack module in slice.rs for more information\n    #[cfg(test)]\n    fn clone(&self) -> Vec<T> {\n        ::slice::to_vec(&**self)\n    }\n\n    fn clone_from(&mut self, other: &Vec<T>) {\n        other.as_slice().clone_into(self);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Hash> Hash for Vec<T> {\n    #[inline]\n    fn hash<H: hash::Hasher>(&self, state: &mut H) {\n        Hash::hash(&**self, state)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    message=\"vector indices are of type `usize` or ranges of `usize`\",\n    label=\"vector indices are of type `usize` or ranges of `usize`\",\n)]\nimpl<T, I> Index<I> for Vec<T>\nwhere\n    I: ::core::slice::SliceIndex<[T]>,\n{\n    type Output = I::Output;\n\n    #[inline]\n    fn index(&self, index: I) -> &Self::Output {\n        Index::index(&**self, index)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    message=\"vector indices are of type `usize` or ranges of `usize`\",\n    label=\"vector indices are of type `usize` or ranges of `usize`\",\n)]\nimpl<T, I> IndexMut<I> for Vec<T>\nwhere\n    I: ::core::slice::SliceIndex<[T]>,\n{\n    #[inline]\n    fn index_mut(&mut self, index: I) -> &mut Self::Output {\n        IndexMut::index_mut(&mut **self, index)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ops::Deref for Vec<T> {\n    type Target = [T];\n\n    fn deref(&self) -> &[T] {\n        unsafe {\n            let p = self.buf.ptr();\n            assume(!p.is_null());\n            slice::from_raw_parts(p, self.len)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ops::DerefMut for Vec<T> {\n    fn deref_mut(&mut self) -> &mut [T] {\n        unsafe {\n            let ptr = self.buf.ptr();\n            assume(!ptr.is_null());\n            slice::from_raw_parts_mut(ptr, self.len)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> FromIterator<T> for Vec<T> {\n    #[inline]\n    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {\n        <Self as SpecExtend<T, I::IntoIter>>::from_iter(iter.into_iter())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> IntoIterator for Vec<T> {\n    type Item = T;\n    type IntoIter = IntoIter<T>;\n\n    /// Creates a consuming iterator, that is, one that moves each value out of\n    /// the vector (from start to end). The vector cannot be used after calling\n    /// this.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = vec![\"a\".to_string(), \"b\".to_string()];\n    /// for s in v.into_iter() {\n    ///     // s has type String, not &String\n    ///     println!(\"{}\", s);\n    /// }\n    /// ```\n    #[inline]\n    fn into_iter(mut self) -> IntoIter<T> {\n        unsafe {\n            let begin = self.as_mut_ptr();\n            assume(!begin.is_null());\n            let end = if mem::size_of::<T>() == 0 {\n                arith_offset(begin as *const i8, self.len() as isize) as *const T\n            } else {\n                begin.add(self.len()) as *const T\n            };\n            let cap = self.buf.cap();\n            mem::forget(self);\n            IntoIter {\n                buf: NonNull::new_unchecked(begin),\n                phantom: PhantomData,\n                cap,\n                ptr: begin,\n                end,\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> IntoIterator for &'a Vec<T> {\n    type Item = &'a T;\n    type IntoIter = slice::Iter<'a, T>;\n\n    fn into_iter(self) -> slice::Iter<'a, T> {\n        self.iter()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> IntoIterator for &'a mut Vec<T> {\n    type Item = &'a mut T;\n    type IntoIter = slice::IterMut<'a, T>;\n\n    fn into_iter(self) -> slice::IterMut<'a, T> {\n        self.iter_mut()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Extend<T> for Vec<T> {\n    #[inline]\n    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {\n        <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())\n    }\n}\n\n// Specialization trait used for Vec::from_iter and Vec::extend\ntrait SpecExtend<T, I> {\n    fn from_iter(iter: I) -> Self;\n    fn spec_extend(&mut self, iter: I);\n}\n\nimpl<T, I> SpecExtend<T, I> for Vec<T>\n    where I: Iterator<Item=T>,\n{\n    default fn from_iter(mut iterator: I) -> Self {\n        // Unroll the first iteration, as the vector is going to be\n        // expanded on this iteration in every case when the iterable is not\n        // empty, but the loop in extend_desugared() is not going to see the\n        // vector being full in the few subsequent loop iterations.\n        // So we get better branch prediction.\n        let mut vector = match iterator.next() {\n            None => return Vec::new(),\n            Some(element) => {\n                let (lower, _) = iterator.size_hint();\n                let mut vector = Vec::with_capacity(lower.saturating_add(1));\n                unsafe {\n                    ptr::write(vector.get_unchecked_mut(0), element);\n                    vector.set_len(1);\n                }\n                vector\n            }\n        };\n        <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);\n        vector\n    }\n\n    default fn spec_extend(&mut self, iter: I) {\n        self.extend_desugared(iter)\n    }\n}\n\nimpl<T, I> SpecExtend<T, I> for Vec<T>\n    where I: TrustedLen<Item=T>,\n{\n    default fn from_iter(iterator: I) -> Self {\n        let mut vector = Vec::new();\n        vector.spec_extend(iterator);\n        vector\n    }\n\n    default fn spec_extend(&mut self, iterator: I) {\n        // This is the case for a TrustedLen iterator.\n        let (low, high) = iterator.size_hint();\n        if let Some(high_value) = high {\n            debug_assert_eq!(low, high_value,\n                             \"TrustedLen iterator's size hint is not exact: {:?}\",\n                             (low, high));\n        }\n        if let Some(additional) = high {\n            self.reserve(additional);\n            unsafe {\n                let mut ptr = self.as_mut_ptr().add(self.len());\n                let mut local_len = SetLenOnDrop::new(&mut self.len);\n                iterator.for_each(move |element| {\n                    ptr::write(ptr, element);\n                    ptr = ptr.offset(1);\n                    // NB can't overflow since we would have had to alloc the address space\n                    local_len.increment_len(1);\n                });\n            }\n        } else {\n            self.extend_desugared(iterator)\n        }\n    }\n}\n\nimpl<T> SpecExtend<T, IntoIter<T>> for Vec<T> {\n    fn from_iter(iterator: IntoIter<T>) -> Self {\n        // A common case is passing a vector into a function which immediately\n        // re-collects into a vector. We can short circuit this if the IntoIter\n        // has not been advanced at all.\n        if iterator.buf.as_ptr() as *const _ == iterator.ptr {\n            unsafe {\n                let vec = Vec::from_raw_parts(iterator.buf.as_ptr(),\n                                              iterator.len(),\n                                              iterator.cap);\n                mem::forget(iterator);\n                vec\n            }\n        } else {\n            let mut vector = Vec::new();\n            vector.spec_extend(iterator);\n            vector\n        }\n    }\n\n    fn spec_extend(&mut self, mut iterator: IntoIter<T>) {\n        unsafe {\n            self.append_elements(iterator.as_slice() as _);\n        }\n        iterator.ptr = iterator.end;\n    }\n}\n\nimpl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec<T>\n    where I: Iterator<Item=&'a T>,\n          T: Clone,\n{\n    default fn from_iter(iterator: I) -> Self {\n        SpecExtend::from_iter(iterator.cloned())\n    }\n\n    default fn spec_extend(&mut self, iterator: I) {\n        self.spec_extend(iterator.cloned())\n    }\n}\n\nimpl<'a, T: 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T>\n    where T: Copy,\n{\n    fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {\n        let slice = iterator.as_slice();\n        self.reserve(slice.len());\n        unsafe {\n            let len = self.len();\n            self.set_len(len + slice.len());\n            self.get_unchecked_mut(len..).copy_from_slice(slice);\n        }\n    }\n}\n\nimpl<T> Vec<T> {\n    fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {\n        // This is the case for a general iterator.\n        //\n        // This function should be the moral equivalent of:\n        //\n        //      for item in iterator {\n        //          self.push(item);\n        //      }\n        while let Some(element) = iterator.next() {\n            let len = self.len();\n            if len == self.capacity() {\n                let (lower, _) = iterator.size_hint();\n                self.reserve(lower.saturating_add(1));\n            }\n            unsafe {\n                ptr::write(self.get_unchecked_mut(len), element);\n                // NB can't overflow since we would have had to alloc the address space\n                self.set_len(len + 1);\n            }\n        }\n    }\n\n    /// Creates a splicing iterator that replaces the specified range in the vector\n    /// with the given `replace_with` iterator and yields the removed items.\n    /// `replace_with` does not need to be the same length as `range`.\n    ///\n    /// Note 1: The element range is removed even if the iterator is not\n    /// consumed until the end.\n    ///\n    /// Note 2: It is unspecified how many elements are removed from the vector,\n    /// if the `Splice` value is leaked.\n    ///\n    /// Note 3: The input iterator `replace_with` is only consumed\n    /// when the `Splice` value is dropped.\n    ///\n    /// Note 4: This is optimal if:\n    ///\n    /// * The tail (elements in the vector after `range`) is empty,\n    /// * or `replace_with` yields fewer elements than `range`\u2019s length\n    /// * or the lower bound of its `size_hint()` is exact.\n    ///\n    /// Otherwise, a temporary vector is allocated and the tail is moved twice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the starting point is greater than the end point or if\n    /// the end point is greater than the length of the vector.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = vec![1, 2, 3];\n    /// let new = [7, 8];\n    /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();\n    /// assert_eq!(v, &[7, 8, 3]);\n    /// assert_eq!(u, &[1, 2]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"vec_splice\", since = \"1.21.0\")]\n    pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter>\n        where R: RangeBounds<usize>, I: IntoIterator<Item=T>\n    {\n        Splice {\n            drain: self.drain(range),\n            replace_with: replace_with.into_iter(),\n        }\n    }\n\n    /// Creates an iterator which uses a closure to determine if an element should be removed.\n    ///\n    /// If the closure returns true, then the element is removed and yielded.\n    /// If the closure returns false, the element will remain in the vector and will not be yielded\n    /// by the iterator.\n    ///\n    /// Using this method is equivalent to the following code:\n    ///\n    /// ```\n    /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };\n    /// # let mut vec = vec![1, 2, 3, 4, 5, 6];\n    /// let mut i = 0;\n    /// while i != vec.len() {\n    ///     if some_predicate(&mut vec[i]) {\n    ///         let val = vec.remove(i);\n    ///         // your code here\n    ///     } else {\n    ///         i += 1;\n    ///     }\n    /// }\n    ///\n    /// # assert_eq!(vec, vec![1, 4, 5]);\n    /// ```\n    ///\n    /// But `drain_filter` is easier to use. `drain_filter` is also more efficient,\n    /// because it can backshift the elements of the array in bulk.\n    ///\n    /// Note that `drain_filter` also lets you mutate every element in the filter closure,\n    /// regardless of whether you choose to keep or remove it.\n    ///\n    ///\n    /// # Examples\n    ///\n    /// Splitting an array into evens and odds, reusing the original allocation:\n    ///\n    /// ```\n    /// #![feature(drain_filter)]\n    /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];\n    ///\n    /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();\n    /// let odds = numbers;\n    ///\n    /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);\n    /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);\n    /// ```\n    #[unstable(feature = \"drain_filter\", reason = \"recently added\", issue = \"43244\")]\n    pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F>\n        where F: FnMut(&mut T) -> bool,\n    {\n        let old_len = self.len();\n\n        // Guard against us getting leaked (leak amplification)\n        unsafe { self.set_len(0); }\n\n        DrainFilter {\n            vec: self,\n            idx: 0,\n            del: 0,\n            old_len,\n            pred: filter,\n        }\n    }\n}\n\n/// Extend implementation that copies elements out of references before pushing them onto the Vec.\n///\n/// This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] to\n/// append the entire slice at once.\n///\n/// [`copy_from_slice`]: ../../std/primitive.slice.html#method.copy_from_slice\n#[stable(feature = \"extend_ref\", since = \"1.2.0\")]\nimpl<'a, T: 'a + Copy> Extend<&'a T> for Vec<T> {\n    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {\n        self.spec_extend(iter.into_iter())\n    }\n}\n\nmacro_rules! __impl_slice_eq1 {\n    ($Lhs: ty, $Rhs: ty) => {\n        __impl_slice_eq1! { $Lhs, $Rhs, Sized }\n    };\n    ($Lhs: ty, $Rhs: ty, $Bound: ident) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {\n            #[inline]\n            fn eq(&self, other: &$Rhs) -> bool { self[..] == other[..] }\n            #[inline]\n            fn ne(&self, other: &$Rhs) -> bool { self[..] != other[..] }\n        }\n    }\n}\n\n__impl_slice_eq1! { Vec<A>, Vec<B> }\n__impl_slice_eq1! { Vec<A>, &'b [B] }\n__impl_slice_eq1! { Vec<A>, &'b mut [B] }\n__impl_slice_eq1! { Cow<'a, [A]>, &'b [B], Clone }\n__impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B], Clone }\n__impl_slice_eq1! { Cow<'a, [A]>, Vec<B>, Clone }\n\nmacro_rules! array_impls {\n    ($($N: expr)+) => {\n        $(\n            // NOTE: some less important impls are omitted to reduce code bloat\n            __impl_slice_eq1! { Vec<A>, [B; $N] }\n            __impl_slice_eq1! { Vec<A>, &'b [B; $N] }\n            // __impl_slice_eq1! { Vec<A>, &'b mut [B; $N] }\n            // __impl_slice_eq1! { Cow<'a, [A]>, [B; $N], Clone }\n            // __impl_slice_eq1! { Cow<'a, [A]>, &'b [B; $N], Clone }\n            // __impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B; $N], Clone }\n        )+\n    }\n}\n\narray_impls! {\n     0  1  2  3  4  5  6  7  8  9\n    10 11 12 13 14 15 16 17 18 19\n    20 21 22 23 24 25 26 27 28 29\n    30 31 32\n}\n\n/// Implements comparison of vectors, lexicographically.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: PartialOrd> PartialOrd for Vec<T> {\n    #[inline]\n    fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {\n        PartialOrd::partial_cmp(&**self, &**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Eq> Eq for Vec<T> {}\n\n/// Implements ordering of vectors, lexicographically.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Ord> Ord for Vec<T> {\n    #[inline]\n    fn cmp(&self, other: &Vec<T>) -> Ordering {\n        Ord::cmp(&**self, &**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<#[may_dangle] T> Drop for Vec<T> {\n    fn drop(&mut self) {\n        unsafe {\n            // use drop for [T]\n            ptr::drop_in_place(&mut self[..]);\n        }\n        // RawVec handles deallocation\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Default for Vec<T> {\n    /// Creates an empty `Vec<T>`.\n    fn default() -> Vec<T> {\n        Vec::new()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: fmt::Debug> fmt::Debug for Vec<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> AsRef<Vec<T>> for Vec<T> {\n    fn as_ref(&self) -> &Vec<T> {\n        self\n    }\n}\n\n#[stable(feature = \"vec_as_mut\", since = \"1.5.0\")]\nimpl<T> AsMut<Vec<T>> for Vec<T> {\n    fn as_mut(&mut self) -> &mut Vec<T> {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> AsRef<[T]> for Vec<T> {\n    fn as_ref(&self) -> &[T] {\n        self\n    }\n}\n\n#[stable(feature = \"vec_as_mut\", since = \"1.5.0\")]\nimpl<T> AsMut<[T]> for Vec<T> {\n    fn as_mut(&mut self) -> &mut [T] {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: Clone> From<&'a [T]> for Vec<T> {\n    #[cfg(not(test))]\n    fn from(s: &'a [T]) -> Vec<T> {\n        s.to_vec()\n    }\n    #[cfg(test)]\n    fn from(s: &'a [T]) -> Vec<T> {\n        ::slice::to_vec(s)\n    }\n}\n\n#[stable(feature = \"vec_from_mut\", since = \"1.19.0\")]\nimpl<'a, T: Clone> From<&'a mut [T]> for Vec<T> {\n    #[cfg(not(test))]\n    fn from(s: &'a mut [T]) -> Vec<T> {\n        s.to_vec()\n    }\n    #[cfg(test)]\n    fn from(s: &'a mut [T]) -> Vec<T> {\n        ::slice::to_vec(s)\n    }\n}\n\n#[stable(feature = \"vec_from_cow_slice\", since = \"1.14.0\")]\nimpl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {\n    fn from(s: Cow<'a, [T]>) -> Vec<T> {\n        s.into_owned()\n    }\n}\n\n// note: test pulls in libstd, which causes errors here\n#[cfg(not(test))]\n#[stable(feature = \"vec_from_box\", since = \"1.18.0\")]\nimpl<T> From<Box<[T]>> for Vec<T> {\n    fn from(s: Box<[T]>) -> Vec<T> {\n        s.into_vec()\n    }\n}\n\n// note: test pulls in libstd, which causes errors here\n#[cfg(not(test))]\n#[stable(feature = \"box_from_vec\", since = \"1.20.0\")]\nimpl<T> From<Vec<T>> for Box<[T]> {\n    fn from(v: Vec<T>) -> Box<[T]> {\n        v.into_boxed_slice()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> From<&'a str> for Vec<u8> {\n    fn from(s: &'a str) -> Vec<u8> {\n        From::from(s.as_bytes())\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Clone-on-write\n////////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"cow_from_vec\", since = \"1.8.0\")]\nimpl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]> {\n    fn from(s: &'a [T]) -> Cow<'a, [T]> {\n        Cow::Borrowed(s)\n    }\n}\n\n#[stable(feature = \"cow_from_vec\", since = \"1.8.0\")]\nimpl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]> {\n    fn from(v: Vec<T>) -> Cow<'a, [T]> {\n        Cow::Owned(v)\n    }\n}\n\n#[stable(feature = \"cow_from_vec_ref\", since = \"1.28.0\")]\nimpl<'a, T: Clone> From<&'a Vec<T>> for Cow<'a, [T]> {\n    fn from(v: &'a Vec<T>) -> Cow<'a, [T]> {\n        Cow::Borrowed(v.as_slice())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> FromIterator<T> for Cow<'a, [T]> where T: Clone {\n    fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]> {\n        Cow::Owned(FromIterator::from_iter(it))\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Iterators\n////////////////////////////////////////////////////////////////////////////////\n\n/// An iterator that moves out of a vector.\n///\n/// This `struct` is created by the `into_iter` method on [`Vec`][`Vec`] (provided\n/// by the [`IntoIterator`] trait).\n///\n/// [`Vec`]: struct.Vec.html\n/// [`IntoIterator`]: ../../std/iter/trait.IntoIterator.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoIter<T> {\n    buf: NonNull<T>,\n    phantom: PhantomData<T>,\n    cap: usize,\n    ptr: *const T,\n    end: *const T,\n}\n\n#[stable(feature = \"vec_intoiter_debug\", since = \"1.13.0\")]\nimpl<T: fmt::Debug> fmt::Debug for IntoIter<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"IntoIter\")\n            .field(&self.as_slice())\n            .finish()\n    }\n}\n\nimpl<T> IntoIter<T> {\n    /// Returns the remaining items of this iterator as a slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let vec = vec!['a', 'b', 'c'];\n    /// let mut into_iter = vec.into_iter();\n    /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);\n    /// let _ = into_iter.next().unwrap();\n    /// assert_eq!(into_iter.as_slice(), &['b', 'c']);\n    /// ```\n    #[stable(feature = \"vec_into_iter_as_slice\", since = \"1.15.0\")]\n    pub fn as_slice(&self) -> &[T] {\n        unsafe {\n            slice::from_raw_parts(self.ptr, self.len())\n        }\n    }\n\n    /// Returns the remaining items of this iterator as a mutable slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let vec = vec!['a', 'b', 'c'];\n    /// let mut into_iter = vec.into_iter();\n    /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);\n    /// into_iter.as_mut_slice()[2] = 'z';\n    /// assert_eq!(into_iter.next().unwrap(), 'a');\n    /// assert_eq!(into_iter.next().unwrap(), 'b');\n    /// assert_eq!(into_iter.next().unwrap(), 'z');\n    /// ```\n    #[stable(feature = \"vec_into_iter_as_slice\", since = \"1.15.0\")]\n    pub fn as_mut_slice(&mut self) -> &mut [T] {\n        unsafe {\n            slice::from_raw_parts_mut(self.ptr as *mut T, self.len())\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Send> Send for IntoIter<T> {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Sync> Sync for IntoIter<T> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Iterator for IntoIter<T> {\n    type Item = T;\n\n    #[inline]\n    fn next(&mut self) -> Option<T> {\n        unsafe {\n            if self.ptr as *const _ == self.end {\n                None\n            } else {\n                if mem::size_of::<T>() == 0 {\n                    // purposefully don't use 'ptr.offset' because for\n                    // vectors with 0-size elements this would return the\n                    // same pointer.\n                    self.ptr = arith_offset(self.ptr as *const i8, 1) as *mut T;\n\n                    // Make up a value of this ZST.\n                    Some(mem::zeroed())\n                } else {\n                    let old = self.ptr;\n                    self.ptr = self.ptr.offset(1);\n\n                    Some(ptr::read(old))\n                }\n            }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let exact = if mem::size_of::<T>() == 0 {\n            (self.end as usize).wrapping_sub(self.ptr as usize)\n        } else {\n            unsafe { self.end.offset_from(self.ptr) as usize }\n        };\n        (exact, Some(exact))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> DoubleEndedIterator for IntoIter<T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<T> {\n        unsafe {\n            if self.end == self.ptr {\n                None\n            } else {\n                if mem::size_of::<T>() == 0 {\n                    // See above for why 'ptr.offset' isn't used\n                    self.end = arith_offset(self.end as *const i8, -1) as *mut T;\n\n                    // Make up a value of this ZST.\n                    Some(mem::zeroed())\n                } else {\n                    self.end = self.end.offset(-1);\n\n                    Some(ptr::read(self.end))\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for IntoIter<T> {\n    fn is_empty(&self) -> bool {\n        self.ptr == self.end\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for IntoIter<T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for IntoIter<T> {}\n\n#[stable(feature = \"vec_into_iter_clone\", since = \"1.8.0\")]\nimpl<T: Clone> Clone for IntoIter<T> {\n    fn clone(&self) -> IntoIter<T> {\n        self.as_slice().to_owned().into_iter()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<#[may_dangle] T> Drop for IntoIter<T> {\n    fn drop(&mut self) {\n        // destroy the remaining elements\n        for _x in self.by_ref() {}\n\n        // RawVec handles deallocation\n        let _ = unsafe { RawVec::from_raw_parts(self.buf.as_ptr(), self.cap) };\n    }\n}\n\n/// A draining iterator for `Vec<T>`.\n///\n/// This `struct` is created by the [`drain`] method on [`Vec`].\n///\n/// [`drain`]: struct.Vec.html#method.drain\n/// [`Vec`]: struct.Vec.html\n#[stable(feature = \"drain\", since = \"1.6.0\")]\npub struct Drain<'a, T: 'a> {\n    /// Index of tail to preserve\n    tail_start: usize,\n    /// Length of tail\n    tail_len: usize,\n    /// Current remaining range to remove\n    iter: slice::Iter<'a, T>,\n    vec: NonNull<Vec<T>>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"Drain\")\n         .field(&self.iter.as_slice())\n         .finish()\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nunsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nunsafe impl<'a, T: Send> Send for Drain<'a, T> {}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, T> Iterator for Drain<'a, T> {\n    type Item = T;\n\n    #[inline]\n    fn next(&mut self) -> Option<T> {\n        self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) })\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, T> DoubleEndedIterator for Drain<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<T> {\n        self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) })\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, T> Drop for Drain<'a, T> {\n    fn drop(&mut self) {\n        // exhaust self first\n        self.for_each(drop);\n\n        if self.tail_len > 0 {\n            unsafe {\n                let source_vec = self.vec.as_mut();\n                // memmove back untouched tail, update to new length\n                let start = source_vec.len();\n                let tail = self.tail_start;\n                if tail != start {\n                    let src = source_vec.as_ptr().add(tail);\n                    let dst = source_vec.as_mut_ptr().add(start);\n                    ptr::copy(src, dst, self.tail_len);\n                }\n                source_vec.set_len(start + self.tail_len);\n            }\n        }\n    }\n}\n\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, T> ExactSizeIterator for Drain<'a, T> {\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, T> FusedIterator for Drain<'a, T> {}\n\n/// A splicing iterator for `Vec`.\n///\n/// This struct is created by the [`splice()`] method on [`Vec`]. See its\n/// documentation for more.\n///\n/// [`splice()`]: struct.Vec.html#method.splice\n/// [`Vec`]: struct.Vec.html\n#[derive(Debug)]\n#[stable(feature = \"vec_splice\", since = \"1.21.0\")]\npub struct Splice<'a, I: Iterator + 'a> {\n    drain: Drain<'a, I::Item>,\n    replace_with: I,\n}\n\n#[stable(feature = \"vec_splice\", since = \"1.21.0\")]\nimpl<'a, I: Iterator> Iterator for Splice<'a, I> {\n    type Item = I::Item;\n\n    fn next(&mut self) -> Option<Self::Item> {\n        self.drain.next()\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.drain.size_hint()\n    }\n}\n\n#[stable(feature = \"vec_splice\", since = \"1.21.0\")]\nimpl<'a, I: Iterator> DoubleEndedIterator for Splice<'a, I> {\n    fn next_back(&mut self) -> Option<Self::Item> {\n        self.drain.next_back()\n    }\n}\n\n#[stable(feature = \"vec_splice\", since = \"1.21.0\")]\nimpl<'a, I: Iterator> ExactSizeIterator for Splice<'a, I> {}\n\n\n#[stable(feature = \"vec_splice\", since = \"1.21.0\")]\nimpl<'a, I: Iterator> Drop for Splice<'a, I> {\n    fn drop(&mut self) {\n        self.drain.by_ref().for_each(drop);\n\n        unsafe {\n            if self.drain.tail_len == 0 {\n                self.drain.vec.as_mut().extend(self.replace_with.by_ref());\n                return\n            }\n\n            // First fill the range left by drain().\n            if !self.drain.fill(&mut self.replace_with) {\n                return\n            }\n\n            // There may be more elements. Use the lower bound as an estimate.\n            // FIXME: Is the upper bound a better guess? Or something else?\n            let (lower_bound, _upper_bound) = self.replace_with.size_hint();\n            if lower_bound > 0  {\n                self.drain.move_tail(lower_bound);\n                if !self.drain.fill(&mut self.replace_with) {\n                    return\n                }\n            }\n\n            // Collect any remaining elements.\n            // This is a zero-length vector which does not allocate if `lower_bound` was exact.\n            let mut collected = self.replace_with.by_ref().collect::<Vec<I::Item>>().into_iter();\n            // Now we have an exact count.\n            if collected.len() > 0 {\n                self.drain.move_tail(collected.len());\n                let filled = self.drain.fill(&mut collected);\n                debug_assert!(filled);\n                debug_assert_eq!(collected.len(), 0);\n            }\n        }\n        // Let `Drain::drop` move the tail back if necessary and restore `vec.len`.\n    }\n}\n\n/// Private helper methods for `Splice::drop`\nimpl<'a, T> Drain<'a, T> {\n    /// The range from `self.vec.len` to `self.tail_start` contains elements\n    /// that have been moved out.\n    /// Fill that range as much as possible with new elements from the `replace_with` iterator.\n    /// Return whether we filled the entire range. (`replace_with.next()` didn\u2019t return `None`.)\n    unsafe fn fill<I: Iterator<Item=T>>(&mut self, replace_with: &mut I) -> bool {\n        let vec = self.vec.as_mut();\n        let range_start = vec.len;\n        let range_end = self.tail_start;\n        let range_slice = slice::from_raw_parts_mut(\n            vec.as_mut_ptr().add(range_start),\n            range_end - range_start);\n\n        for place in range_slice {\n            if let Some(new_item) = replace_with.next() {\n                ptr::write(place, new_item);\n                vec.len += 1;\n            } else {\n                return false\n            }\n        }\n        true\n    }\n\n    /// Make room for inserting more elements before the tail.\n    unsafe fn move_tail(&mut self, extra_capacity: usize) {\n        let vec = self.vec.as_mut();\n        let used_capacity = self.tail_start + self.tail_len;\n        vec.buf.reserve(used_capacity, extra_capacity);\n\n        let new_tail_start = self.tail_start + extra_capacity;\n        let src = vec.as_ptr().add(self.tail_start);\n        let dst = vec.as_mut_ptr().add(new_tail_start);\n        ptr::copy(src, dst, self.tail_len);\n        self.tail_start = new_tail_start;\n    }\n}\n\n/// An iterator produced by calling `drain_filter` on Vec.\n#[unstable(feature = \"drain_filter\", reason = \"recently added\", issue = \"43244\")]\n#[derive(Debug)]\npub struct DrainFilter<'a, T: 'a, F>\n    where F: FnMut(&mut T) -> bool,\n{\n    vec: &'a mut Vec<T>,\n    idx: usize,\n    del: usize,\n    old_len: usize,\n    pred: F,\n}\n\n#[unstable(feature = \"drain_filter\", reason = \"recently added\", issue = \"43244\")]\nimpl<'a, T, F> Iterator for DrainFilter<'a, T, F>\n    where F: FnMut(&mut T) -> bool,\n{\n    type Item = T;\n\n    fn next(&mut self) -> Option<T> {\n        unsafe {\n            while self.idx != self.old_len {\n                let i = self.idx;\n                self.idx += 1;\n                let v = slice::from_raw_parts_mut(self.vec.as_mut_ptr(), self.old_len);\n                if (self.pred)(&mut v[i]) {\n                    self.del += 1;\n                    return Some(ptr::read(&v[i]));\n                } else if self.del > 0 {\n                    let del = self.del;\n                    let src: *const T = &v[i];\n                    let dst: *mut T = &mut v[i - del];\n                    // This is safe because self.vec has length 0\n                    // thus its elements will not have Drop::drop\n                    // called on them in the event of a panic.\n                    ptr::copy_nonoverlapping(src, dst, 1);\n                }\n            }\n            None\n        }\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (0, Some(self.old_len - self.idx))\n    }\n}\n\n#[unstable(feature = \"drain_filter\", reason = \"recently added\", issue = \"43244\")]\nimpl<'a, T, F> Drop for DrainFilter<'a, T, F>\n    where F: FnMut(&mut T) -> bool,\n{\n    fn drop(&mut self) {\n        self.for_each(drop);\n        unsafe {\n            self.vec.set_len(self.old_len - self.del);\n        }\n    }\n}\n","use std::slice;\nuse std::str;\nuse std::mem;\n\nextern \"C\" {\n  fn print(text: *const u8, text_len: usize);\n}\n\n#[no_mangle]\npub extern \"C\" fn alloc_mem(size: usize) -> *mut u8 {\n  let mut m = Vec::with_capacity(mem::size_of::<usize>() + size);\n  unsafe {\n    let p: *mut u8 = m.as_mut_ptr();\n    *(p as *mut usize) = size;\n    mem::forget(m);\n    return p.offset(mem::size_of::<usize>() as isize);\n  }\n}\n\n#[no_mangle]\npub extern \"C\" fn free_mem(p: *mut u8) {\n  unsafe {\n    let v = p.offset(-(mem::size_of::<usize>() as isize));\n    let size = *(v as *mut usize);\n    Vec::from_raw_parts(v, 0, size);\n  }\n}\n\n#[no_mangle]\npub extern \"C\" fn hello(name: *const u8, name_len: usize) {\n  let name_str = str::from_utf8(unsafe {\n    slice::from_raw_parts(name, name_len)\n  }).unwrap();\n  let text = format!(\"Hey, {}!\", name_str);\n  let text_str = text.as_str();\n  unsafe { \n    print(text_str.as_ptr(), text.len());\n  }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Error handling with the `Result` type.\n//!\n//! [`Result<T, E>`][`Result`] is the type used for returning and propagating\n//! errors. It is an enum with the variants, [`Ok(T)`], representing\n//! success and containing a value, and [`Err(E)`], representing error\n//! and containing an error value.\n//!\n//! ```\n//! # #[allow(dead_code)]\n//! enum Result<T, E> {\n//!    Ok(T),\n//!    Err(E),\n//! }\n//! ```\n//!\n//! Functions return [`Result`] whenever errors are expected and\n//! recoverable. In the `std` crate, [`Result`] is most prominently used\n//! for [I/O](../../std/io/index.html).\n//!\n//! A simple function returning [`Result`] might be\n//! defined and used like so:\n//!\n//! ```\n//! #[derive(Debug)]\n//! enum Version { Version1, Version2 }\n//!\n//! fn parse_version(header: &[u8]) -> Result<Version, &'static str> {\n//!     match header.get(0) {\n//!         None => Err(\"invalid header length\"),\n//!         Some(&1) => Ok(Version::Version1),\n//!         Some(&2) => Ok(Version::Version2),\n//!         Some(_) => Err(\"invalid version\"),\n//!     }\n//! }\n//!\n//! let version = parse_version(&[1, 2, 3, 4]);\n//! match version {\n//!     Ok(v) => println!(\"working with version: {:?}\", v),\n//!     Err(e) => println!(\"error parsing header: {:?}\", e),\n//! }\n//! ```\n//!\n//! Pattern matching on [`Result`]s is clear and straightforward for\n//! simple cases, but [`Result`] comes with some convenience methods\n//! that make working with it more succinct.\n//!\n//! ```\n//! let good_result: Result<i32, i32> = Ok(10);\n//! let bad_result: Result<i32, i32> = Err(10);\n//!\n//! // The `is_ok` and `is_err` methods do what they say.\n//! assert!(good_result.is_ok() && !good_result.is_err());\n//! assert!(bad_result.is_err() && !bad_result.is_ok());\n//!\n//! // `map` consumes the `Result` and produces another.\n//! let good_result: Result<i32, i32> = good_result.map(|i| i + 1);\n//! let bad_result: Result<i32, i32> = bad_result.map(|i| i - 1);\n//!\n//! // Use `and_then` to continue the computation.\n//! let good_result: Result<bool, i32> = good_result.and_then(|i| Ok(i == 11));\n//!\n//! // Use `or_else` to handle the error.\n//! let bad_result: Result<i32, i32> = bad_result.or_else(|i| Ok(i + 20));\n//!\n//! // Consume the result and return the contents with `unwrap`.\n//! let final_awesome_result = good_result.unwrap();\n//! ```\n//!\n//! # Results must be used\n//!\n//! A common problem with using return values to indicate errors is\n//! that it is easy to ignore the return value, thus failing to handle\n//! the error. [`Result`] is annotated with the `#[must_use]` attribute,\n//! which will cause the compiler to issue a warning when a Result\n//! value is ignored. This makes [`Result`] especially useful with\n//! functions that may encounter errors but don't otherwise return a\n//! useful value.\n//!\n//! Consider the [`write_all`] method defined for I/O types\n//! by the [`Write`] trait:\n//!\n//! ```\n//! use std::io;\n//!\n//! trait Write {\n//!     fn write_all(&mut self, bytes: &[u8]) -> Result<(), io::Error>;\n//! }\n//! ```\n//!\n//! *Note: The actual definition of [`Write`] uses [`io::Result`], which\n//! is just a synonym for [`Result`]`<T, `[`io::Error`]`>`.*\n//!\n//! This method doesn't produce a value, but the write may\n//! fail. It's crucial to handle the error case, and *not* write\n//! something like this:\n//!\n//! ```no_run\n//! # #![allow(unused_must_use)] // \\o/\n//! use std::fs::File;\n//! use std::io::prelude::*;\n//!\n//! let mut file = File::create(\"valuable_data.txt\").unwrap();\n//! // If `write_all` errors, then we'll never know, because the return\n//! // value is ignored.\n//! file.write_all(b\"important message\");\n//! ```\n//!\n//! If you *do* write that in Rust, the compiler will give you a\n//! warning (by default, controlled by the `unused_must_use` lint).\n//!\n//! You might instead, if you don't want to handle the error, simply\n//! assert success with [`expect`]. This will panic if the\n//! write fails, providing a marginally useful message indicating why:\n//!\n//! ```{.no_run}\n//! use std::fs::File;\n//! use std::io::prelude::*;\n//!\n//! let mut file = File::create(\"valuable_data.txt\").unwrap();\n//! file.write_all(b\"important message\").expect(\"failed to write message\");\n//! ```\n//!\n//! You might also simply assert success:\n//!\n//! ```{.no_run}\n//! # use std::fs::File;\n//! # use std::io::prelude::*;\n//! # let mut file = File::create(\"valuable_data.txt\").unwrap();\n//! assert!(file.write_all(b\"important message\").is_ok());\n//! ```\n//!\n//! Or propagate the error up the call stack with [`?`]:\n//!\n//! ```\n//! # use std::fs::File;\n//! # use std::io::prelude::*;\n//! # use std::io;\n//! # #[allow(dead_code)]\n//! fn write_message() -> io::Result<()> {\n//!     let mut file = File::create(\"valuable_data.txt\")?;\n//!     file.write_all(b\"important message\")?;\n//!     Ok(())\n//! }\n//! ```\n//!\n//! # The question mark operator, `?`\n//!\n//! When writing code that calls many functions that return the\n//! [`Result`] type, the error handling can be tedious. The question mark\n//! operator, [`?`], hides some of the boilerplate of propagating errors\n//! up the call stack.\n//!\n//! It replaces this:\n//!\n//! ```\n//! # #![allow(dead_code)]\n//! use std::fs::File;\n//! use std::io::prelude::*;\n//! use std::io;\n//!\n//! struct Info {\n//!     name: String,\n//!     age: i32,\n//!     rating: i32,\n//! }\n//!\n//! fn write_info(info: &Info) -> io::Result<()> {\n//!     // Early return on error\n//!     let mut file = match File::create(\"my_best_friends.txt\") {\n//!            Err(e) => return Err(e),\n//!            Ok(f) => f,\n//!     };\n//!     if let Err(e) = file.write_all(format!(\"name: {}\\n\", info.name).as_bytes()) {\n//!         return Err(e)\n//!     }\n//!     if let Err(e) = file.write_all(format!(\"age: {}\\n\", info.age).as_bytes()) {\n//!         return Err(e)\n//!     }\n//!     if let Err(e) = file.write_all(format!(\"rating: {}\\n\", info.rating).as_bytes()) {\n//!         return Err(e)\n//!     }\n//!     Ok(())\n//! }\n//! ```\n//!\n//! With this:\n//!\n//! ```\n//! # #![allow(dead_code)]\n//! use std::fs::File;\n//! use std::io::prelude::*;\n//! use std::io;\n//!\n//! struct Info {\n//!     name: String,\n//!     age: i32,\n//!     rating: i32,\n//! }\n//!\n//! fn write_info(info: &Info) -> io::Result<()> {\n//!     let mut file = File::create(\"my_best_friends.txt\")?;\n//!     // Early return on error\n//!     file.write_all(format!(\"name: {}\\n\", info.name).as_bytes())?;\n//!     file.write_all(format!(\"age: {}\\n\", info.age).as_bytes())?;\n//!     file.write_all(format!(\"rating: {}\\n\", info.rating).as_bytes())?;\n//!     Ok(())\n//! }\n//! ```\n//!\n//! *It's much nicer!*\n//!\n//! Ending the expression with [`?`] will result in the unwrapped\n//! success ([`Ok`]) value, unless the result is [`Err`], in which case\n//! [`Err`] is returned early from the enclosing function.\n//!\n//! [`?`] can only be used in functions that return [`Result`] because of the\n//! early return of [`Err`] that it provides.\n//!\n//! [`expect`]: enum.Result.html#method.expect\n//! [`Write`]: ../../std/io/trait.Write.html\n//! [`write_all`]: ../../std/io/trait.Write.html#method.write_all\n//! [`io::Result`]: ../../std/io/type.Result.html\n//! [`?`]: ../../std/macro.try.html\n//! [`Result`]: enum.Result.html\n//! [`Ok(T)`]: enum.Result.html#variant.Ok\n//! [`Err(E)`]: enum.Result.html#variant.Err\n//! [`io::Error`]: ../../std/io/struct.Error.html\n//! [`Ok`]: enum.Result.html#variant.Ok\n//! [`Err`]: enum.Result.html#variant.Err\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse fmt;\nuse iter::{FromIterator, FusedIterator, TrustedLen};\nuse ops::{self, Deref};\n\n/// `Result` is a type that represents either success ([`Ok`]) or failure ([`Err`]).\n///\n/// See the [`std::result`](index.html) module documentation for details.\n///\n/// [`Ok`]: enum.Result.html#variant.Ok\n/// [`Err`]: enum.Result.html#variant.Err\n#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]\n#[must_use = \"this `Result` may be an `Err` variant, which should be handled\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Result<T, E> {\n    /// Contains the success value\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Ok(#[stable(feature = \"rust1\", since = \"1.0.0\")] T),\n\n    /// Contains the error value\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Err(#[stable(feature = \"rust1\", since = \"1.0.0\")] E),\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Type implementation\n/////////////////////////////////////////////////////////////////////////////\n\nimpl<T, E> Result<T, E> {\n    /////////////////////////////////////////////////////////////////////////\n    // Querying the contained values\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns `true` if the result is [`Ok`].\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<i32, &str> = Ok(-3);\n    /// assert_eq!(x.is_ok(), true);\n    ///\n    /// let x: Result<i32, &str> = Err(\"Some error message\");\n    /// assert_eq!(x.is_ok(), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_ok(&self) -> bool {\n        match *self {\n            Ok(_) => true,\n            Err(_) => false\n        }\n    }\n\n    /// Returns `true` if the result is [`Err`].\n    ///\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<i32, &str> = Ok(-3);\n    /// assert_eq!(x.is_err(), false);\n    ///\n    /// let x: Result<i32, &str> = Err(\"Some error message\");\n    /// assert_eq!(x.is_err(), true);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_err(&self) -> bool {\n        !self.is_ok()\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Adapter for each variant\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Converts from `Result<T, E>` to [`Option<T>`].\n    ///\n    /// Converts `self` into an [`Option<T>`], consuming `self`,\n    /// and discarding the error, if any.\n    ///\n    /// [`Option<T>`]: ../../std/option/enum.Option.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// assert_eq!(x.ok(), Some(2));\n    ///\n    /// let x: Result<u32, &str> = Err(\"Nothing here\");\n    /// assert_eq!(x.ok(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ok(self) -> Option<T> {\n        match self {\n            Ok(x)  => Some(x),\n            Err(_) => None,\n        }\n    }\n\n    /// Converts from `Result<T, E>` to [`Option<E>`].\n    ///\n    /// Converts `self` into an [`Option<E>`], consuming `self`,\n    /// and discarding the success value, if any.\n    ///\n    /// [`Option<E>`]: ../../std/option/enum.Option.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// assert_eq!(x.err(), None);\n    ///\n    /// let x: Result<u32, &str> = Err(\"Nothing here\");\n    /// assert_eq!(x.err(), Some(\"Nothing here\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn err(self) -> Option<E> {\n        match self {\n            Ok(_)  => None,\n            Err(x) => Some(x),\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Adapter for working with references\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Converts from `Result<T, E>` to `Result<&T, &E>`.\n    ///\n    /// Produces a new `Result`, containing a reference\n    /// into the original, leaving the original in place.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// assert_eq!(x.as_ref(), Ok(&2));\n    ///\n    /// let x: Result<u32, &str> = Err(\"Error\");\n    /// assert_eq!(x.as_ref(), Err(&\"Error\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_ref(&self) -> Result<&T, &E> {\n        match *self {\n            Ok(ref x) => Ok(x),\n            Err(ref x) => Err(x),\n        }\n    }\n\n    /// Converts from `Result<T, E>` to `Result<&mut T, &mut E>`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// fn mutate(r: &mut Result<i32, i32>) {\n    ///     match r.as_mut() {\n    ///         Ok(v) => *v = 42,\n    ///         Err(e) => *e = 0,\n    ///     }\n    /// }\n    ///\n    /// let mut x: Result<i32, i32> = Ok(2);\n    /// mutate(&mut x);\n    /// assert_eq!(x.unwrap(), 42);\n    ///\n    /// let mut x: Result<i32, i32> = Err(13);\n    /// mutate(&mut x);\n    /// assert_eq!(x.unwrap_err(), 0);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_mut(&mut self) -> Result<&mut T, &mut E> {\n        match *self {\n            Ok(ref mut x) => Ok(x),\n            Err(ref mut x) => Err(x),\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Transforming contained values\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a\n    /// contained [`Ok`] value, leaving an [`Err`] value untouched.\n    ///\n    /// This function can be used to compose the results of two functions.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Print the numbers on each line of a string multiplied by two.\n    ///\n    /// ```\n    /// let line = \"1\\n2\\n3\\n4\\n\";\n    ///\n    /// for num in line.lines() {\n    ///     match num.parse::<i32>().map(|i| i * 2) {\n    ///         Ok(n) => println!(\"{}\", n),\n    ///         Err(..) => {}\n    ///     }\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn map<U, F: FnOnce(T) -> U>(self, op: F) -> Result<U,E> {\n        match self {\n            Ok(t) => Ok(op(t)),\n            Err(e) => Err(e)\n        }\n    }\n\n    /// Maps a `Result<T, E>` to `U` by applying a function to a\n    /// contained [`Ok`] value, or a fallback function to a\n    /// contained [`Err`] value.\n    ///\n    /// This function can be used to unpack a successful result\n    /// while handling an error.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(result_map_or_else)]\n    /// let k = 21;\n    ///\n    /// let x : Result<_, &str> = Ok(\"foo\");\n    /// assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 3);\n    ///\n    /// let x : Result<&str, _> = Err(\"bar\");\n    /// assert_eq!(x.map_or_else(|e| k * 2, |v| v.len()), 42);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"result_map_or_else\", issue = \"53268\")]\n    pub fn map_or_else<U, M: FnOnce(T) -> U, F: FnOnce(E) -> U>(self, fallback: F, map: M) -> U {\n        self.map(map).unwrap_or_else(fallback)\n    }\n\n    /// Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a\n    /// contained [`Err`] value, leaving an [`Ok`] value untouched.\n    ///\n    /// This function can be used to pass through a successful result while handling\n    /// an error.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// fn stringify(x: u32) -> String { format!(\"error code: {}\", x) }\n    ///\n    /// let x: Result<u32, u32> = Ok(2);\n    /// assert_eq!(x.map_err(stringify), Ok(2));\n    ///\n    /// let x: Result<u32, u32> = Err(13);\n    /// assert_eq!(x.map_err(stringify), Err(\"error code: 13\".to_string()));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Result<T,F> {\n        match self {\n            Ok(t) => Ok(t),\n            Err(e) => Err(op(e))\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Iterator constructors\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns an iterator over the possibly contained value.\n    ///\n    /// The iterator yields one value if the result is [`Result::Ok`], otherwise none.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(7);\n    /// assert_eq!(x.iter().next(), Some(&7));\n    ///\n    /// let x: Result<u32, &str> = Err(\"nothing!\");\n    /// assert_eq!(x.iter().next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter(&self) -> Iter<T> {\n        Iter { inner: self.as_ref().ok() }\n    }\n\n    /// Returns a mutable iterator over the possibly contained value.\n    ///\n    /// The iterator yields one value if the result is [`Result::Ok`], otherwise none.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut x: Result<u32, &str> = Ok(7);\n    /// match x.iter_mut().next() {\n    ///     Some(v) => *v = 40,\n    ///     None => {},\n    /// }\n    /// assert_eq!(x, Ok(40));\n    ///\n    /// let mut x: Result<u32, &str> = Err(\"nothing!\");\n    /// assert_eq!(x.iter_mut().next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter_mut(&mut self) -> IterMut<T> {\n        IterMut { inner: self.as_mut().ok() }\n    }\n\n    ////////////////////////////////////////////////////////////////////////\n    // Boolean operations on the values, eager and lazy\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns `res` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// let y: Result<&str, &str> = Err(\"late error\");\n    /// assert_eq!(x.and(y), Err(\"late error\"));\n    ///\n    /// let x: Result<u32, &str> = Err(\"early error\");\n    /// let y: Result<&str, &str> = Ok(\"foo\");\n    /// assert_eq!(x.and(y), Err(\"early error\"));\n    ///\n    /// let x: Result<u32, &str> = Err(\"not a 2\");\n    /// let y: Result<&str, &str> = Err(\"late error\");\n    /// assert_eq!(x.and(y), Err(\"not a 2\"));\n    ///\n    /// let x: Result<u32, &str> = Ok(2);\n    /// let y: Result<&str, &str> = Ok(\"different result type\");\n    /// assert_eq!(x.and(y), Ok(\"different result type\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn and<U>(self, res: Result<U, E>) -> Result<U, E> {\n        match self {\n            Ok(_) => res,\n            Err(e) => Err(e),\n        }\n    }\n\n    /// Calls `op` if the result is [`Ok`], otherwise returns the [`Err`] value of `self`.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// This function can be used for control flow based on `Result` values.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\n    /// fn err(x: u32) -> Result<u32, u32> { Err(x) }\n    ///\n    /// assert_eq!(Ok(2).and_then(sq).and_then(sq), Ok(16));\n    /// assert_eq!(Ok(2).and_then(sq).and_then(err), Err(4));\n    /// assert_eq!(Ok(2).and_then(err).and_then(sq), Err(2));\n    /// assert_eq!(Err(3).and_then(sq).and_then(sq), Err(3));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn and_then<U, F: FnOnce(T) -> Result<U, E>>(self, op: F) -> Result<U, E> {\n        match self {\n            Ok(t) => op(t),\n            Err(e) => Err(e),\n        }\n    }\n\n    /// Returns `res` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.\n    ///\n    /// Arguments passed to `or` are eagerly evaluated; if you are passing the\n    /// result of a function call, it is recommended to use [`or_else`], which is\n    /// lazily evaluated.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    /// [`or_else`]: #method.or_else\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// let y: Result<u32, &str> = Err(\"late error\");\n    /// assert_eq!(x.or(y), Ok(2));\n    ///\n    /// let x: Result<u32, &str> = Err(\"early error\");\n    /// let y: Result<u32, &str> = Ok(2);\n    /// assert_eq!(x.or(y), Ok(2));\n    ///\n    /// let x: Result<u32, &str> = Err(\"not a 2\");\n    /// let y: Result<u32, &str> = Err(\"late error\");\n    /// assert_eq!(x.or(y), Err(\"late error\"));\n    ///\n    /// let x: Result<u32, &str> = Ok(2);\n    /// let y: Result<u32, &str> = Ok(100);\n    /// assert_eq!(x.or(y), Ok(2));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or<F>(self, res: Result<T, F>) -> Result<T, F> {\n        match self {\n            Ok(v) => Ok(v),\n            Err(_) => res,\n        }\n    }\n\n    /// Calls `op` if the result is [`Err`], otherwise returns the [`Ok`] value of `self`.\n    ///\n    /// This function can be used for control flow based on result values.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// fn sq(x: u32) -> Result<u32, u32> { Ok(x * x) }\n    /// fn err(x: u32) -> Result<u32, u32> { Err(x) }\n    ///\n    /// assert_eq!(Ok(2).or_else(sq).or_else(sq), Ok(2));\n    /// assert_eq!(Ok(2).or_else(err).or_else(sq), Ok(2));\n    /// assert_eq!(Err(3).or_else(sq).or_else(err), Ok(9));\n    /// assert_eq!(Err(3).or_else(err).or_else(err), Err(3));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or_else<F, O: FnOnce(E) -> Result<T, F>>(self, op: O) -> Result<T, F> {\n        match self {\n            Ok(t) => Ok(t),\n            Err(e) => op(e),\n        }\n    }\n\n    /// Unwraps a result, yielding the content of an [`Ok`].\n    /// Else, it returns `optb`.\n    ///\n    /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing\n    /// the result of a function call, it is recommended to use [`unwrap_or_else`],\n    /// which is lazily evaluated.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    /// [`unwrap_or_else`]: #method.unwrap_or_else\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let optb = 2;\n    /// let x: Result<u32, &str> = Ok(9);\n    /// assert_eq!(x.unwrap_or(optb), 9);\n    ///\n    /// let x: Result<u32, &str> = Err(\"error\");\n    /// assert_eq!(x.unwrap_or(optb), optb);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_or(self, optb: T) -> T {\n        match self {\n            Ok(t) => t,\n            Err(_) => optb\n        }\n    }\n\n    /// Unwraps a result, yielding the content of an [`Ok`].\n    /// If the value is an [`Err`] then it calls `op` with its value.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// fn count(x: &str) -> usize { x.len() }\n    ///\n    /// assert_eq!(Ok(2).unwrap_or_else(count), 2);\n    /// assert_eq!(Err(\"foo\").unwrap_or_else(count), 3);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_or_else<F: FnOnce(E) -> T>(self, op: F) -> T {\n        match self {\n            Ok(t) => t,\n            Err(e) => op(e)\n        }\n    }\n}\n\nimpl<T, E: fmt::Debug> Result<T, E> {\n    /// Unwraps a result, yielding the content of an [`Ok`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is an [`Err`], with a panic message provided by the\n    /// [`Err`]'s value.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(2);\n    /// assert_eq!(x.unwrap(), 2);\n    /// ```\n    ///\n    /// ```{.should_panic}\n    /// let x: Result<u32, &str> = Err(\"emergency failure\");\n    /// x.unwrap(); // panics with `emergency failure`\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap(self) -> T {\n        match self {\n            Ok(t) => t,\n            Err(e) => unwrap_failed(\"called `Result::unwrap()` on an `Err` value\", e),\n        }\n    }\n\n    /// Unwraps a result, yielding the content of an [`Ok`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is an [`Err`], with a panic message including the\n    /// passed message, and the content of the [`Err`].\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```{.should_panic}\n    /// let x: Result<u32, &str> = Err(\"emergency failure\");\n    /// x.expect(\"Testing expect\"); // panics with `Testing expect: emergency failure`\n    /// ```\n    #[inline]\n    #[stable(feature = \"result_expect\", since = \"1.4.0\")]\n    pub fn expect(self, msg: &str) -> T {\n        match self {\n            Ok(t) => t,\n            Err(e) => unwrap_failed(msg, e),\n        }\n    }\n}\n\nimpl<T: fmt::Debug, E> Result<T, E> {\n    /// Unwraps a result, yielding the content of an [`Err`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is an [`Ok`], with a custom panic message provided\n    /// by the [`Ok`]'s value.\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    ///\n    /// # Examples\n    ///\n    /// ```{.should_panic}\n    /// let x: Result<u32, &str> = Ok(2);\n    /// x.unwrap_err(); // panics with `2`\n    /// ```\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Err(\"emergency failure\");\n    /// assert_eq!(x.unwrap_err(), \"emergency failure\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_err(self) -> E {\n        match self {\n            Ok(t) => unwrap_failed(\"called `Result::unwrap_err()` on an `Ok` value\", t),\n            Err(e) => e,\n        }\n    }\n\n    /// Unwraps a result, yielding the content of an [`Err`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is an [`Ok`], with a panic message including the\n    /// passed message, and the content of the [`Ok`].\n    ///\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```{.should_panic}\n    /// let x: Result<u32, &str> = Ok(10);\n    /// x.expect_err(\"Testing expect_err\"); // panics with `Testing expect_err: 10`\n    /// ```\n    #[inline]\n    #[stable(feature = \"result_expect_err\", since = \"1.17.0\")]\n    pub fn expect_err(self, msg: &str) -> E {\n        match self {\n            Ok(t) => unwrap_failed(msg, t),\n            Err(e) => e,\n        }\n    }\n}\n\nimpl<T: Default, E> Result<T, E> {\n    /// Returns the contained value or a default\n    ///\n    /// Consumes the `self` argument then, if [`Ok`], returns the contained\n    /// value, otherwise if [`Err`], returns the default value for that\n    /// type.\n    ///\n    /// # Examples\n    ///\n    /// Convert a string to an integer, turning poorly-formed strings\n    /// into 0 (the default value for integers). [`parse`] converts\n    /// a string to any other type that implements [`FromStr`], returning an\n    /// [`Err`] on error.\n    ///\n    /// ```\n    /// let good_year_from_input = \"1909\";\n    /// let bad_year_from_input = \"190blarg\";\n    /// let good_year = good_year_from_input.parse().unwrap_or_default();\n    /// let bad_year = bad_year_from_input.parse().unwrap_or_default();\n    ///\n    /// assert_eq!(1909, good_year);\n    /// assert_eq!(0, bad_year);\n    /// ```\n    ///\n    /// [`parse`]: ../../std/primitive.str.html#method.parse\n    /// [`FromStr`]: ../../std/str/trait.FromStr.html\n    /// [`Ok`]: enum.Result.html#variant.Ok\n    /// [`Err`]: enum.Result.html#variant.Err\n    #[inline]\n    #[stable(feature = \"result_unwrap_or_default\", since = \"1.16.0\")]\n    pub fn unwrap_or_default(self) -> T {\n        match self {\n            Ok(x) => x,\n            Err(_) => Default::default(),\n        }\n    }\n}\n\n#[unstable(feature = \"inner_deref\", reason = \"newly added\", issue = \"50264\")]\nimpl<T: Deref, E> Result<T, E> {\n    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E>`.\n    ///\n    /// Leaves the original Result in-place, creating a new one with a reference\n    /// to the original one, additionally coercing the `Ok` arm of the Result via\n    /// `Deref`.\n    pub fn deref_ok(&self) -> Result<&T::Target, &E> {\n        self.as_ref().map(|t| t.deref())\n    }\n}\n\n#[unstable(feature = \"inner_deref\", reason = \"newly added\", issue = \"50264\")]\nimpl<T, E: Deref> Result<T, E> {\n    /// Converts from `&Result<T, E>` to `Result<&T, &E::Target>`.\n    ///\n    /// Leaves the original Result in-place, creating a new one with a reference\n    /// to the original one, additionally coercing the `Err` arm of the Result via\n    /// `Deref`.\n    pub fn deref_err(&self) -> Result<&T, &E::Target>\n    {\n        self.as_ref().map_err(|e| e.deref())\n    }\n}\n\n#[unstable(feature = \"inner_deref\", reason = \"newly added\", issue = \"50264\")]\nimpl<T: Deref, E: Deref> Result<T, E> {\n    /// Converts from `&Result<T, E>` to `Result<&T::Target, &E::Target>`.\n    ///\n    /// Leaves the original Result in-place, creating a new one with a reference\n    /// to the original one, additionally coercing both the `Ok` and `Err` arms\n    /// of the Result via `Deref`.\n    pub fn deref(&self) -> Result<&T::Target, &E::Target>\n    {\n        self.as_ref().map(|t| t.deref()).map_err(|e| e.deref())\n    }\n}\n\nimpl<T, E> Result<Option<T>, E> {\n    /// Transposes a `Result` of an `Option` into an `Option` of a `Result`.\n    ///\n    /// `Ok(None)` will be mapped to `None`.\n    /// `Ok(Some(_))` and `Err(_)` will be mapped to `Some(Ok(_))` and `Some(Err(_))`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(transpose_result)]\n    ///\n    /// #[derive(Debug, Eq, PartialEq)]\n    /// struct SomeErr;\n    ///\n    /// let x: Result<Option<i32>, SomeErr> = Ok(Some(5));\n    /// let y: Option<Result<i32, SomeErr>> = Some(Ok(5));\n    /// assert_eq!(x.transpose(), y);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"transpose_result\", issue = \"47338\")]\n    pub fn transpose(self) -> Option<Result<T, E>> {\n        match self {\n            Ok(Some(x)) => Some(Ok(x)),\n            Ok(None) => None,\n            Err(e) => Some(Err(e)),\n        }\n    }\n}\n\n// This is a separate function to reduce the code size of the methods\n#[inline(never)]\n#[cold]\nfn unwrap_failed<E: fmt::Debug>(msg: &str, error: E) -> ! {\n    panic!(\"{}: {:?}\", msg, error)\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Trait implementations\n/////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T, E> IntoIterator for Result<T, E> {\n    type Item = T;\n    type IntoIter = IntoIter<T>;\n\n    /// Returns a consuming iterator over the possibly contained value.\n    ///\n    /// The iterator yields one value if the result is [`Result::Ok`], otherwise none.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let x: Result<u32, &str> = Ok(5);\n    /// let v: Vec<u32> = x.into_iter().collect();\n    /// assert_eq!(v, [5]);\n    ///\n    /// let x: Result<u32, &str> = Err(\"nothing!\");\n    /// let v: Vec<u32> = x.into_iter().collect();\n    /// assert_eq!(v, []);\n    /// ```\n    #[inline]\n    fn into_iter(self) -> IntoIter<T> {\n        IntoIter { inner: self.ok() }\n    }\n}\n\n#[stable(since = \"1.4.0\", feature = \"result_iter\")]\nimpl<'a, T, E> IntoIterator for &'a Result<T, E> {\n    type Item = &'a T;\n    type IntoIter = Iter<'a, T>;\n\n    fn into_iter(self) -> Iter<'a, T> {\n        self.iter()\n    }\n}\n\n#[stable(since = \"1.4.0\", feature = \"result_iter\")]\nimpl<'a, T, E> IntoIterator for &'a mut Result<T, E> {\n    type Item = &'a mut T;\n    type IntoIter = IterMut<'a, T>;\n\n    fn into_iter(self) -> IterMut<'a, T> {\n        self.iter_mut()\n    }\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// The Result Iterators\n/////////////////////////////////////////////////////////////////////////////\n\n/// An iterator over a reference to the [`Ok`] variant of a [`Result`].\n///\n/// The iterator yields one value if the result is [`Ok`], otherwise none.\n///\n/// Created by [`Result::iter`].\n///\n/// [`Ok`]: enum.Result.html#variant.Ok\n/// [`Result`]: enum.Result.html\n/// [`Result::iter`]: enum.Result.html#method.iter\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Iter<'a, T: 'a> { inner: Option<&'a T> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> Iterator for Iter<'a, T> {\n    type Item = &'a T;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a T> { self.inner.take() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = if self.inner.is_some() {1} else {0};\n        (n, Some(n))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> DoubleEndedIterator for Iter<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a T> { self.inner.take() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for Iter<'_, T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for Iter<'_, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for Iter<'_, A> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Clone for Iter<'_, T> {\n    #[inline]\n    fn clone(&self) -> Self { Iter { inner: self.inner } }\n}\n\n/// An iterator over a mutable reference to the [`Ok`] variant of a [`Result`].\n///\n/// Created by [`Result::iter_mut`].\n///\n/// [`Ok`]: enum.Result.html#variant.Ok\n/// [`Result`]: enum.Result.html\n/// [`Result::iter_mut`]: enum.Result.html#method.iter_mut\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IterMut<'a, T: 'a> { inner: Option<&'a mut T> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> Iterator for IterMut<'a, T> {\n    type Item = &'a mut T;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut T> { self.inner.take() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = if self.inner.is_some() {1} else {0};\n        (n, Some(n))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> DoubleEndedIterator for IterMut<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut T> { self.inner.take() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for IterMut<'_, T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for IterMut<'_, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for IterMut<'_, A> {}\n\n/// An iterator over the value in a [`Ok`] variant of a [`Result`].\n///\n/// The iterator yields one value if the result is [`Ok`], otherwise none.\n///\n/// This struct is created by the [`into_iter`] method on\n/// [`Result`][`Result`] (provided by the [`IntoIterator`] trait).\n///\n/// [`Ok`]: enum.Result.html#variant.Ok\n/// [`Result`]: enum.Result.html\n/// [`into_iter`]: ../iter/trait.IntoIterator.html#tymethod.into_iter\n/// [`IntoIterator`]: ../iter/trait.IntoIterator.html\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoIter<T> { inner: Option<T> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Iterator for IntoIter<T> {\n    type Item = T;\n\n    #[inline]\n    fn next(&mut self) -> Option<T> { self.inner.take() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = if self.inner.is_some() {1} else {0};\n        (n, Some(n))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> DoubleEndedIterator for IntoIter<T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<T> { self.inner.take() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for IntoIter<T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for IntoIter<T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for IntoIter<A> {}\n\n/////////////////////////////////////////////////////////////////////////////\n// FromIterator\n/////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, E, V: FromIterator<A>> FromIterator<Result<A, E>> for Result<V, E> {\n    /// Takes each element in the `Iterator`: if it is an `Err`, no further\n    /// elements are taken, and the `Err` is returned. Should no `Err` occur, a\n    /// container with the values of each `Result` is returned.\n    ///\n    /// Here is an example which increments every integer in a vector,\n    /// checking for overflow:\n    ///\n    /// ```\n    /// let v = vec![1, 2];\n    /// let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|\n    ///     x.checked_add(1).ok_or(\"Overflow!\")\n    /// ).collect();\n    /// assert!(res == Ok(vec![2, 3]));\n    /// ```\n    #[inline]\n    fn from_iter<I: IntoIterator<Item=Result<A, E>>>(iter: I) -> Result<V, E> {\n        // FIXME(#11084): This could be replaced with Iterator::scan when this\n        // performance bug is closed.\n\n        struct Adapter<Iter, E> {\n            iter: Iter,\n            err: Option<E>,\n        }\n\n        impl<T, E, Iter: Iterator<Item=Result<T, E>>> Iterator for Adapter<Iter, E> {\n            type Item = T;\n\n            #[inline]\n            fn next(&mut self) -> Option<T> {\n                match self.iter.next() {\n                    Some(Ok(value)) => Some(value),\n                    Some(Err(err)) => {\n                        self.err = Some(err);\n                        None\n                    }\n                    None => None,\n                }\n            }\n\n            fn size_hint(&self) -> (usize, Option<usize>) {\n                let (_min, max) = self.iter.size_hint();\n                (0, max)\n            }\n        }\n\n        let mut adapter = Adapter { iter: iter.into_iter(), err: None };\n        let v: V = FromIterator::from_iter(adapter.by_ref());\n\n        match adapter.err {\n            Some(err) => Err(err),\n            None => Ok(v),\n        }\n    }\n}\n\n#[unstable(feature = \"try_trait\", issue = \"42327\")]\nimpl<T,E> ops::Try for Result<T, E> {\n    type Ok = T;\n    type Error = E;\n\n    #[inline]\n    fn into_result(self) -> Self {\n        self\n    }\n\n    #[inline]\n    fn from_ok(v: T) -> Self {\n        Ok(v)\n    }\n\n    #[inline]\n    fn from_error(v: E) -> Self {\n        Err(v)\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// Entry point of thread panic, for details, see std::macros\n#[macro_export]\n#[allow_internal_unstable]\n#[stable(feature = \"core\", since = \"1.6.0\")]\nmacro_rules! panic {\n    () => (\n        panic!(\"explicit panic\")\n    );\n    ($msg:expr) => ({\n        $crate::panicking::panic(&($msg, file!(), line!(), __rust_unstable_column!()))\n    });\n    ($msg:expr,) => (\n        panic!($msg)\n    );\n    ($fmt:expr, $($arg:tt)+) => ({\n        $crate::panicking::panic_fmt(format_args!($fmt, $($arg)*),\n                                     &(file!(), line!(), __rust_unstable_column!()))\n    });\n}\n\n/// Asserts that two expressions are equal to each other (using [`PartialEq`]).\n///\n/// On panic, this macro will print the values of the expressions with their\n/// debug representations.\n///\n/// Like [`assert!`], this macro has a second form, where a custom\n/// panic message can be provided.\n///\n/// [`PartialEq`]: cmp/trait.PartialEq.html\n/// [`assert!`]: macro.assert.html\n///\n/// # Examples\n///\n/// ```\n/// let a = 3;\n/// let b = 1 + 2;\n/// assert_eq!(a, b);\n///\n/// assert_eq!(a, b, \"we are testing addition with {} and {}\", a, b);\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! assert_eq {\n    ($left:expr, $right:expr) => ({\n        match (&$left, &$right) {\n            (left_val, right_val) => {\n                if !(*left_val == *right_val) {\n                    panic!(r#\"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`\"#, left_val, right_val)\n                }\n            }\n        }\n    });\n    ($left:expr, $right:expr,) => ({\n        assert_eq!($left, $right)\n    });\n    ($left:expr, $right:expr, $($arg:tt)+) => ({\n        match (&($left), &($right)) {\n            (left_val, right_val) => {\n                if !(*left_val == *right_val) {\n                    panic!(r#\"assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`: {}\"#, left_val, right_val,\n                           format_args!($($arg)+))\n                }\n            }\n        }\n    });\n}\n\n/// Asserts that two expressions are not equal to each other (using [`PartialEq`]).\n///\n/// On panic, this macro will print the values of the expressions with their\n/// debug representations.\n///\n/// Like [`assert!`], this macro has a second form, where a custom\n/// panic message can be provided.\n///\n/// [`PartialEq`]: cmp/trait.PartialEq.html\n/// [`assert!`]: macro.assert.html\n///\n/// # Examples\n///\n/// ```\n/// let a = 3;\n/// let b = 2;\n/// assert_ne!(a, b);\n///\n/// assert_ne!(a, b, \"we are testing that the values are not equal\");\n/// ```\n#[macro_export]\n#[stable(feature = \"assert_ne\", since = \"1.13.0\")]\nmacro_rules! assert_ne {\n    ($left:expr, $right:expr) => ({\n        match (&$left, &$right) {\n            (left_val, right_val) => {\n                if *left_val == *right_val {\n                    panic!(r#\"assertion failed: `(left != right)`\n  left: `{:?}`,\n right: `{:?}`\"#, left_val, right_val)\n                }\n            }\n        }\n    });\n    ($left:expr, $right:expr,) => {\n        assert_ne!($left, $right)\n    };\n    ($left:expr, $right:expr, $($arg:tt)+) => ({\n        match (&($left), &($right)) {\n            (left_val, right_val) => {\n                if *left_val == *right_val {\n                    panic!(r#\"assertion failed: `(left != right)`\n  left: `{:?}`,\n right: `{:?}`: {}\"#, left_val, right_val,\n                           format_args!($($arg)+))\n                }\n            }\n        }\n    });\n}\n\n/// Ensure that a boolean expression is `true` at runtime.\n///\n/// This will invoke the [`panic!`] macro if the provided expression cannot be\n/// evaluated to `true` at runtime.\n///\n/// Like [`assert!`], this macro also has a second version, where a custom panic\n/// message can be provided.\n///\n/// # Uses\n///\n/// Unlike [`assert!`], `debug_assert!` statements are only enabled in non\n/// optimized builds by default. An optimized build will omit all\n/// `debug_assert!` statements unless `-C debug-assertions` is passed to the\n/// compiler. This makes `debug_assert!` useful for checks that are too\n/// expensive to be present in a release build but may be helpful during\n/// development.\n///\n/// An unchecked assertion allows a program in an inconsistent state to keep\n/// running, which might have unexpected consequences but does not introduce\n/// unsafety as long as this only happens in safe code. The performance cost\n/// of assertions, is however, not measurable in general. Replacing [`assert!`]\n/// with `debug_assert!` is thus only encouraged after thorough profiling, and\n/// more importantly, only in safe code!\n///\n/// [`panic!`]: macro.panic.html\n/// [`assert!`]: macro.assert.html\n///\n/// # Examples\n///\n/// ```\n/// // the panic message for these assertions is the stringified value of the\n/// // expression given.\n/// debug_assert!(true);\n///\n/// fn some_expensive_computation() -> bool { true } // a very simple function\n/// debug_assert!(some_expensive_computation());\n///\n/// // assert with a custom message\n/// let x = true;\n/// debug_assert!(x, \"x wasn't true!\");\n///\n/// let a = 3; let b = 27;\n/// debug_assert!(a + b == 30, \"a = {}, b = {}\", a, b);\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! debug_assert {\n    ($($arg:tt)*) => (if cfg!(debug_assertions) { assert!($($arg)*); })\n}\n\n/// Asserts that two expressions are equal to each other.\n///\n/// On panic, this macro will print the values of the expressions with their\n/// debug representations.\n///\n/// Unlike [`assert_eq!`], `debug_assert_eq!` statements are only enabled in non\n/// optimized builds by default. An optimized build will omit all\n/// `debug_assert_eq!` statements unless `-C debug-assertions` is passed to the\n/// compiler. This makes `debug_assert_eq!` useful for checks that are too\n/// expensive to be present in a release build but may be helpful during\n/// development.\n///\n/// [`assert_eq!`]: ../std/macro.assert_eq.html\n///\n/// # Examples\n///\n/// ```\n/// let a = 3;\n/// let b = 1 + 2;\n/// debug_assert_eq!(a, b);\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! debug_assert_eq {\n    ($($arg:tt)*) => (if cfg!(debug_assertions) { assert_eq!($($arg)*); })\n}\n\n/// Asserts that two expressions are not equal to each other.\n///\n/// On panic, this macro will print the values of the expressions with their\n/// debug representations.\n///\n/// Unlike [`assert_ne!`], `debug_assert_ne!` statements are only enabled in non\n/// optimized builds by default. An optimized build will omit all\n/// `debug_assert_ne!` statements unless `-C debug-assertions` is passed to the\n/// compiler. This makes `debug_assert_ne!` useful for checks that are too\n/// expensive to be present in a release build but may be helpful during\n/// development.\n///\n/// [`assert_ne!`]: ../std/macro.assert_ne.html\n///\n/// # Examples\n///\n/// ```\n/// let a = 3;\n/// let b = 2;\n/// debug_assert_ne!(a, b);\n/// ```\n#[macro_export]\n#[stable(feature = \"assert_ne\", since = \"1.13.0\")]\nmacro_rules! debug_assert_ne {\n    ($($arg:tt)*) => (if cfg!(debug_assertions) { assert_ne!($($arg)*); })\n}\n\n/// Helper macro for reducing boilerplate code for matching `Result` together\n/// with converting downstream errors.\n///\n/// The `?` operator was added to replace `try!` and should be used instead.\n///\n/// `try!` matches the given [`Result`]. In case of the `Ok` variant, the\n/// expression has the value of the wrapped value.\n///\n/// In case of the `Err` variant, it retrieves the inner error. `try!` then\n/// performs conversion using `From`. This provides automatic conversion\n/// between specialized errors and more general ones. The resulting\n/// error is then immediately returned.\n///\n/// Because of the early return, `try!` can only be used in functions that\n/// return [`Result`].\n///\n/// [`Result`]: ../std/result/enum.Result.html\n///\n/// # Examples\n///\n/// ```\n/// use std::io;\n/// use std::fs::File;\n/// use std::io::prelude::*;\n///\n/// enum MyError {\n///     FileWriteError\n/// }\n///\n/// impl From<io::Error> for MyError {\n///     fn from(e: io::Error) -> MyError {\n///         MyError::FileWriteError\n///     }\n/// }\n///\n/// // The preferred method of quick returning Errors\n/// fn write_to_file_question() -> Result<(), MyError> {\n///     let mut file = File::create(\"my_best_friends.txt\")?;\n///     file.write_all(b\"This is a list of my best friends.\")?;\n///     Ok(())\n/// }\n///\n/// // The previous method of quick returning Errors\n/// fn write_to_file_using_try() -> Result<(), MyError> {\n///     let mut file = try!(File::create(\"my_best_friends.txt\"));\n///     try!(file.write_all(b\"This is a list of my best friends.\"));\n///     Ok(())\n/// }\n///\n/// // This is equivalent to:\n/// fn write_to_file_using_match() -> Result<(), MyError> {\n///     let mut file = try!(File::create(\"my_best_friends.txt\"));\n///     match file.write_all(b\"This is a list of my best friends.\") {\n///         Ok(v) => v,\n///         Err(e) => return Err(From::from(e)),\n///     }\n///     Ok(())\n/// }\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(alias = \"?\")]\nmacro_rules! try {\n    ($expr:expr) => (match $expr {\n        $crate::result::Result::Ok(val) => val,\n        $crate::result::Result::Err(err) => {\n            return $crate::result::Result::Err($crate::convert::From::from(err))\n        }\n    });\n    ($expr:expr,) => (try!($expr));\n}\n\n/// Write formatted data into a buffer.\n///\n/// This macro accepts a format string, a list of arguments, and a 'writer'. Arguments will be\n/// formatted according to the specified format string and the result will be passed to the writer.\n/// The writer may be any value with a `write_fmt` method; generally this comes from an\n/// implementation of either the [`std::fmt::Write`] or the [`std::io::Write`] trait. The macro\n/// returns whatever the `write_fmt` method returns; commonly a [`std::fmt::Result`], or an\n/// [`io::Result`].\n///\n/// See [`std::fmt`] for more information on the format string syntax.\n///\n/// [`std::fmt`]: ../std/fmt/index.html\n/// [`std::fmt::Write`]: ../std/fmt/trait.Write.html\n/// [`std::io::Write`]: ../std/io/trait.Write.html\n/// [`std::fmt::Result`]: ../std/fmt/type.Result.html\n/// [`io::Result`]: ../std/io/type.Result.html\n///\n/// # Examples\n///\n/// ```\n/// use std::io::Write;\n///\n/// let mut w = Vec::new();\n/// write!(&mut w, \"test\").unwrap();\n/// write!(&mut w, \"formatted {}\", \"arguments\").unwrap();\n///\n/// assert_eq!(w, b\"testformatted arguments\");\n/// ```\n///\n/// A module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\n/// implementing either, as objects do not typically implement both. However, the module must\n/// import the traits qualified so their names do not conflict:\n///\n/// ```\n/// use std::fmt::Write as FmtWrite;\n/// use std::io::Write as IoWrite;\n///\n/// let mut s = String::new();\n/// let mut v = Vec::new();\n/// write!(&mut s, \"{} {}\", \"abc\", 123).unwrap(); // uses fmt::Write::write_fmt\n/// write!(&mut v, \"s = {:?}\", s).unwrap(); // uses io::Write::write_fmt\n/// assert_eq!(v, b\"s = \\\"abc 123\\\"\");\n/// ```\n///\n/// Note: This macro can be used in `no_std` setups as well\n/// In a `no_std` setup you are responsible for the\n/// implementation details of the components.\n///\n/// ```no_run\n/// # extern crate core;\n/// use core::fmt::Write;\n///\n/// struct Example;\n///\n/// impl Write for Example {\n///     fn write_str(&mut self, _s: &str) -> core::fmt::Result {\n///          unimplemented!();\n///     }\n/// }\n///\n/// let mut m = Example{};\n/// write!(&mut m, \"Hello World\").expect(\"Not written\");\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! write {\n    ($dst:expr, $($arg:tt)*) => ($dst.write_fmt(format_args!($($arg)*)))\n}\n\n/// Write formatted data into a buffer, with a newline appended.\n///\n/// On all platforms, the newline is the LINE FEED character (`\\n`/`U+000A`) alone\n/// (no additional CARRIAGE RETURN (`\\r`/`U+000D`).\n///\n/// For more information, see [`write!`]. For information on the format string syntax, see\n/// [`std::fmt`].\n///\n/// [`write!`]: macro.write.html\n/// [`std::fmt`]: ../std/fmt/index.html\n///\n///\n/// # Examples\n///\n/// ```\n/// use std::io::Write;\n///\n/// let mut w = Vec::new();\n/// writeln!(&mut w).unwrap();\n/// writeln!(&mut w, \"test\").unwrap();\n/// writeln!(&mut w, \"formatted {}\", \"arguments\").unwrap();\n///\n/// assert_eq!(&w[..], \"\\ntest\\nformatted arguments\\n\".as_bytes());\n/// ```\n///\n/// A module can import both `std::fmt::Write` and `std::io::Write` and call `write!` on objects\n/// implementing either, as objects do not typically implement both. However, the module must\n/// import the traits qualified so their names do not conflict:\n///\n/// ```\n/// use std::fmt::Write as FmtWrite;\n/// use std::io::Write as IoWrite;\n///\n/// let mut s = String::new();\n/// let mut v = Vec::new();\n/// writeln!(&mut s, \"{} {}\", \"abc\", 123).unwrap(); // uses fmt::Write::write_fmt\n/// writeln!(&mut v, \"s = {:?}\", s).unwrap(); // uses io::Write::write_fmt\n/// assert_eq!(v, b\"s = \\\"abc 123\\\\n\\\"\\n\");\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow_internal_unstable]\nmacro_rules! writeln {\n    ($dst:expr) => (\n        write!($dst, \"\\n\")\n    );\n    ($dst:expr,) => (\n        writeln!($dst)\n    );\n    ($dst:expr, $($arg:tt)*) => (\n        $dst.write_fmt(format_args_nl!($($arg)*))\n    );\n}\n\n/// A utility macro for indicating unreachable code.\n///\n/// This is useful any time that the compiler can't determine that some code is unreachable. For\n/// example:\n///\n/// * Match arms with guard conditions.\n/// * Loops that dynamically terminate.\n/// * Iterators that dynamically terminate.\n///\n/// If the determination that the code is unreachable proves incorrect, the\n/// program immediately terminates with a [`panic!`].  The function [`unreachable_unchecked`],\n/// which belongs to the [`std::hint`] module, informs the compilier to\n/// optimize the code out of the release version entirely.\n///\n/// [`panic!`]:  ../std/macro.panic.html\n/// [`unreachable_unchecked`]: ../std/hint/fn.unreachable_unchecked.html\n/// [`std::hint`]: ../std/hint/index.html\n///\n/// # Panics\n///\n/// This will always [`panic!`]\n///\n/// [`panic!`]: ../std/macro.panic.html\n/// # Examples\n///\n/// Match arms:\n///\n/// ```\n/// # #[allow(dead_code)]\n/// fn foo(x: Option<i32>) {\n///     match x {\n///         Some(n) if n >= 0 => println!(\"Some(Non-negative)\"),\n///         Some(n) if n <  0 => println!(\"Some(Negative)\"),\n///         Some(_)           => unreachable!(), // compile error if commented out\n///         None              => println!(\"None\")\n///     }\n/// }\n/// ```\n///\n/// Iterators:\n///\n/// ```\n/// # #[allow(dead_code)]\n/// fn divide_by_three(x: u32) -> u32 { // one of the poorest implementations of x/3\n///     for i in 0.. {\n///         if 3*i < i { panic!(\"u32 overflow\"); }\n///         if x < 3*i { return i-1; }\n///     }\n///     unreachable!();\n/// }\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! unreachable {\n    () => ({\n        panic!(\"internal error: entered unreachable code\")\n    });\n    ($msg:expr) => ({\n        unreachable!(\"{}\", $msg)\n    });\n    ($msg:expr,) => ({\n        unreachable!($msg)\n    });\n    ($fmt:expr, $($arg:tt)*) => ({\n        panic!(concat!(\"internal error: entered unreachable code: \", $fmt), $($arg)*)\n    });\n}\n\n/// A standardized placeholder for marking unfinished code.\n///\n/// This can be useful if you are prototyping and are just looking to have your\n/// code typecheck, or if you're implementing a trait that requires multiple\n/// methods, and you're only planning on using one of them.\n///\n/// # Panics\n///\n/// This will always [panic!](macro.panic.html)\n///\n/// # Examples\n///\n/// Here's an example of some in-progress code. We have a trait `Foo`:\n///\n/// ```\n/// trait Foo {\n///     fn bar(&self);\n///     fn baz(&self);\n/// }\n/// ```\n///\n/// We want to implement `Foo` on one of our types, but we also want to work on\n/// just `bar()` first. In order for our code to compile, we need to implement\n/// `baz()`, so we can use `unimplemented!`:\n///\n/// ```\n/// # trait Foo {\n/// #     fn bar(&self);\n/// #     fn baz(&self);\n/// # }\n/// struct MyStruct;\n///\n/// impl Foo for MyStruct {\n///     fn bar(&self) {\n///         // implementation goes here\n///     }\n///\n///     fn baz(&self) {\n///         // let's not worry about implementing baz() for now\n///         unimplemented!();\n///     }\n/// }\n///\n/// fn main() {\n///     let s = MyStruct;\n///     s.bar();\n///\n///     // we aren't even using baz() yet, so this is fine.\n/// }\n/// ```\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nmacro_rules! unimplemented {\n    () => (panic!(\"not yet implemented\"));\n    ($($arg:tt)+) => (panic!(\"not yet implemented: {}\", format_args!($($arg)*)));\n}\n\n/// Built-in macros to the compiler itself.\n///\n/// These macros do not have any corresponding definition with a `macro_rules!`\n/// macro, but are documented here. Their implementations can be found hardcoded\n/// into libsyntax itself.\n///\n/// For more information, see documentation for `std`'s macros.\n#[cfg(rustdoc)]\nmod builtin {\n\n    /// Unconditionally causes compilation to fail with the given error message when encountered.\n    ///\n    /// For more information, see the documentation for [`std::compile_error!`].\n    ///\n    /// [`std::compile_error!`]: ../std/macro.compile_error.html\n    #[stable(feature = \"compile_error_macro\", since = \"1.20.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! compile_error {\n        ($msg:expr) => ({ /* compiler built-in */ });\n        ($msg:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// The core macro for formatted string creation & output.\n    ///\n    /// For more information, see the documentation for [`std::format_args!`].\n    ///\n    /// [`std::format_args!`]: ../std/macro.format_args.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! format_args {\n        ($fmt:expr) => ({ /* compiler built-in */ });\n        ($fmt:expr, $($args:tt)*) => ({ /* compiler built-in */ });\n    }\n\n    /// Inspect an environment variable at compile time.\n    ///\n    /// For more information, see the documentation for [`std::env!`].\n    ///\n    /// [`std::env!`]: ../std/macro.env.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! env {\n        ($name:expr) => ({ /* compiler built-in */ });\n        ($name:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// Optionally inspect an environment variable at compile time.\n    ///\n    /// For more information, see the documentation for [`std::option_env!`].\n    ///\n    /// [`std::option_env!`]: ../std/macro.option_env.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! option_env {\n        ($name:expr) => ({ /* compiler built-in */ });\n        ($name:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// Concatenate identifiers into one identifier.\n    ///\n    /// For more information, see the documentation for [`std::concat_idents!`].\n    ///\n    /// [`std::concat_idents!`]: ../std/macro.concat_idents.html\n    #[unstable(feature = \"concat_idents_macro\", issue = \"29599\")]\n    #[rustc_doc_only_macro]\n    macro_rules! concat_idents {\n        ($($e:ident),+) => ({ /* compiler built-in */ });\n        ($($e:ident,)+) => ({ /* compiler built-in */ });\n    }\n\n    /// Concatenates literals into a static string slice.\n    ///\n    /// For more information, see the documentation for [`std::concat!`].\n    ///\n    /// [`std::concat!`]: ../std/macro.concat.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! concat {\n        ($($e:expr),*) => ({ /* compiler built-in */ });\n        ($($e:expr,)*) => ({ /* compiler built-in */ });\n    }\n\n    /// A macro which expands to the line number on which it was invoked.\n    ///\n    /// For more information, see the documentation for [`std::line!`].\n    ///\n    /// [`std::line!`]: ../std/macro.line.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! line { () => ({ /* compiler built-in */ }) }\n\n    /// A macro which expands to the column number on which it was invoked.\n    ///\n    /// For more information, see the documentation for [`std::column!`].\n    ///\n    /// [`std::column!`]: ../std/macro.column.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! column { () => ({ /* compiler built-in */ }) }\n\n    /// A macro which expands to the file name from which it was invoked.\n    ///\n    /// For more information, see the documentation for [`std::file!`].\n    ///\n    /// [`std::file!`]: ../std/macro.file.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! file { () => ({ /* compiler built-in */ }) }\n\n    /// A macro which stringifies its arguments.\n    ///\n    /// For more information, see the documentation for [`std::stringify!`].\n    ///\n    /// [`std::stringify!`]: ../std/macro.stringify.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! stringify { ($($t:tt)*) => ({ /* compiler built-in */ }) }\n\n    /// Includes a utf8-encoded file as a string.\n    ///\n    /// For more information, see the documentation for [`std::include_str!`].\n    ///\n    /// [`std::include_str!`]: ../std/macro.include_str.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! include_str {\n        ($file:expr) => ({ /* compiler built-in */ });\n        ($file:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// Includes a file as a reference to a byte array.\n    ///\n    /// For more information, see the documentation for [`std::include_bytes!`].\n    ///\n    /// [`std::include_bytes!`]: ../std/macro.include_bytes.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! include_bytes {\n        ($file:expr) => ({ /* compiler built-in */ });\n        ($file:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// Expands to a string that represents the current module path.\n    ///\n    /// For more information, see the documentation for [`std::module_path!`].\n    ///\n    /// [`std::module_path!`]: ../std/macro.module_path.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! module_path { () => ({ /* compiler built-in */ }) }\n\n    /// Boolean evaluation of configuration flags, at compile-time.\n    ///\n    /// For more information, see the documentation for [`std::cfg!`].\n    ///\n    /// [`std::cfg!`]: ../std/macro.cfg.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! cfg { ($($cfg:tt)*) => ({ /* compiler built-in */ }) }\n\n    /// Parse a file as an expression or an item according to the context.\n    ///\n    /// For more information, see the documentation for [`std::include!`].\n    ///\n    /// [`std::include!`]: ../std/macro.include.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_doc_only_macro]\n    macro_rules! include {\n        ($file:expr) => ({ /* compiler built-in */ });\n        ($file:expr,) => ({ /* compiler built-in */ });\n    }\n\n    /// Ensure that a boolean expression is `true` at runtime.\n    ///\n    /// For more information, see the documentation for [`std::assert!`].\n    ///\n    /// [`std::assert!`]: ../std/macro.assert.html\n    #[rustc_doc_only_macro]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    macro_rules! assert {\n        ($cond:expr) => ({ /* compiler built-in */ });\n        ($cond:expr,) => ({ /* compiler built-in */ });\n        ($cond:expr, $($arg:tt)+) => ({ /* compiler built-in */ });\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Numeric traits and functions for the built-in numeric types.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse convert::TryFrom;\nuse fmt;\nuse intrinsics;\nuse mem;\nuse nonzero::NonZero;\nuse ops;\nuse str::FromStr;\n\nmacro_rules! impl_nonzero_fmt {\n    ( ( $( $Trait: ident ),+ ) for $Ty: ident ) => {\n        $(\n            #[stable(feature = \"nonzero\", since = \"1.28.0\")]\n            impl fmt::$Trait for $Ty {\n                #[inline]\n                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                    self.get().fmt(f)\n                }\n            }\n        )+\n    }\n}\n\nmacro_rules! doc_comment {\n    ($x:expr, $($tt:tt)*) => {\n        #[doc = $x]\n        $($tt)*\n    };\n}\n\nmacro_rules! nonzero_integers {\n    ( $( $Ty: ident($Int: ty); )+ ) => {\n        $(\n            doc_comment! {\n                concat!(\"An integer that is known not to equal zero.\n\nThis enables some memory layout optimization.\nFor example, `Option<\", stringify!($Ty), \">` is the same size as `\", stringify!($Int), \"`:\n\n```rust\nuse std::mem::size_of;\nassert_eq!(size_of::<Option<std::num::\", stringify!($Ty), \">>(), size_of::<\", stringify!($Int),\n\">());\n```\"),\n                #[stable(feature = \"nonzero\", since = \"1.28.0\")]\n                #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]\n                #[repr(transparent)]\n                pub struct $Ty(NonZero<$Int>);\n            }\n\n            impl $Ty {\n                /// Create a non-zero without checking the value.\n                ///\n                /// # Safety\n                ///\n                /// The value must not be zero.\n                #[stable(feature = \"nonzero\", since = \"1.28.0\")]\n                #[inline]\n                pub const unsafe fn new_unchecked(n: $Int) -> Self {\n                    $Ty(NonZero(n))\n                }\n\n                /// Create a non-zero if the given value is not zero.\n                #[stable(feature = \"nonzero\", since = \"1.28.0\")]\n                #[inline]\n                pub fn new(n: $Int) -> Option<Self> {\n                    if n != 0 {\n                        Some($Ty(NonZero(n)))\n                    } else {\n                        None\n                    }\n                }\n\n                /// Returns the value as a primitive type.\n                #[stable(feature = \"nonzero\", since = \"1.28.0\")]\n                #[inline]\n                pub fn get(self) -> $Int {\n                    self.0 .0\n                }\n\n            }\n\n            #[stable(feature = \"from_nonzero\", since = \"1.31.0\")]\n            impl From<$Ty> for $Int {\n                fn from(nonzero: $Ty) -> Self {\n                    nonzero.0 .0\n                }\n            }\n\n            impl_nonzero_fmt! {\n                (Debug, Display, Binary, Octal, LowerHex, UpperHex) for $Ty\n            }\n        )+\n    }\n}\n\nnonzero_integers! {\n    NonZeroU8(u8);\n    NonZeroU16(u16);\n    NonZeroU32(u32);\n    NonZeroU64(u64);\n    NonZeroU128(u128);\n    NonZeroUsize(usize);\n}\n\n/// Provides intentionally-wrapped arithmetic on `T`.\n///\n/// Operations like `+` on `u32` values is intended to never overflow,\n/// and in some debug configurations overflow is detected and results\n/// in a panic. While most arithmetic falls into this category, some\n/// code explicitly expects and relies upon modular arithmetic (e.g.,\n/// hashing).\n///\n/// Wrapping arithmetic can be achieved either through methods like\n/// `wrapping_add`, or through the `Wrapping<T>` type, which says that\n/// all standard arithmetic operations on the underlying value are\n/// intended to have wrapping semantics.\n///\n/// The underlying value can be retrieved through the `.0` index of the\n/// `Wrapping` tuple.\n///\n/// # Examples\n///\n/// ```\n/// use std::num::Wrapping;\n///\n/// let zero = Wrapping(0u32);\n/// let one = Wrapping(1u32);\n///\n/// assert_eq!(std::u32::MAX, (zero - one).0);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default, Hash)]\n#[repr(transparent)]\npub struct Wrapping<T>(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n                       pub T);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: fmt::Debug> fmt::Debug for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n#[stable(feature = \"wrapping_display\", since = \"1.10.0\")]\nimpl<T: fmt::Display> fmt::Display for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n#[stable(feature = \"wrapping_fmt\", since = \"1.11.0\")]\nimpl<T: fmt::Binary> fmt::Binary for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n#[stable(feature = \"wrapping_fmt\", since = \"1.11.0\")]\nimpl<T: fmt::Octal> fmt::Octal for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n#[stable(feature = \"wrapping_fmt\", since = \"1.11.0\")]\nimpl<T: fmt::LowerHex> fmt::LowerHex for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n#[stable(feature = \"wrapping_fmt\", since = \"1.11.0\")]\nimpl<T: fmt::UpperHex> fmt::UpperHex for Wrapping<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n// All these modules are technically private and only exposed for coretests:\npub mod flt2dec;\npub mod dec2flt;\npub mod bignum;\npub mod diy_float;\n\nmod wrapping;\n\n// `Int` + `SignedInt` implemented for signed integers\nmacro_rules! int_impl {\n    ($SelfT:ty, $ActualT:ident, $UnsignedT:ty, $BITS:expr, $Min:expr, $Max:expr, $Feature:expr,\n     $EndFeature:expr, $rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,\n     $reversed:expr, $le_bytes:expr, $be_bytes:expr) => {\n        doc_comment! {\n            concat!(\"Returns the smallest value that can be represented by this integer type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::min_value(), \", stringify!($Min), \");\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            #[rustc_promotable]\n            pub const fn min_value() -> Self {\n                !0 ^ ((!0 as $UnsignedT) >> 1) as Self\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the largest value that can be represented by this integer type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::max_value(), \", stringify!($Max), \");\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            #[rustc_promotable]\n            pub const fn max_value() -> Self {\n                !Self::min_value()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts a string slice in a given base to an integer.\n\nThe string is expected to be an optional `+` or `-` sign followed by digits.\nLeading and trailing whitespace represent an error. Digits are a subset of these characters,\ndepending on `radix`:\n\n * `0-9`\n * `a-z`\n * `A-Z`\n\n# Panics\n\nThis function panics if `radix` is not in the range from 2 to 36.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::from_str_radix(\\\"A\\\", 16), Ok(10));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {\n                from_str_radix(src, radix)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of ones in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0b100_0000\", stringify!($SelfT), \";\n\nassert_eq!(n.count_ones(), 1);\",\n$EndFeature, \"\n```\n\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of zeros in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::max_value().count_zeros(), 1);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn count_zeros(self) -> u32 {\n                (!self).count_ones()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of leading zeros in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = -1\", stringify!($SelfT), \";\n\nassert_eq!(n.leading_zeros(), 0);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn leading_zeros(self) -> u32 {\n                (self as $UnsignedT).leading_zeros()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of trailing zeros in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = -4\", stringify!($SelfT), \";\n\nassert_eq!(n.trailing_zeros(), 2);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn trailing_zeros(self) -> u32 {\n                (self as $UnsignedT).trailing_zeros()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts the bits to the left by a specified amount, `n`,\nwrapping the truncated bits to the end of the resulting integer.\n\nPlease note this isn't the same operation as `<<`!\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $rot_op, stringify!($SelfT), \";\nlet m = \", $rot_result, \";\n\nassert_eq!(n.rotate_left(\", $rot, \"), m);\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_rotate\")]\n            #[inline]\n            pub const fn rotate_left(self, n: u32) -> Self {\n                (self as $UnsignedT).rotate_left(n) as Self\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts the bits to the right by a specified amount, `n`,\nwrapping the truncated bits to the beginning of the resulting\ninteger.\n\nPlease note this isn't the same operation as `>>`!\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $rot_result, stringify!($SelfT), \";\nlet m = \", $rot_op, \";\n\nassert_eq!(n.rotate_right(\", $rot, \"), m);\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_rotate\")]\n            #[inline]\n            pub const fn rotate_right(self, n: u32) -> Self {\n                (self as $UnsignedT).rotate_right(n) as Self\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Reverses the byte order of the integer.\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $swap_op, stringify!($SelfT), \";\n\nlet m = n.swap_bytes();\n\nassert_eq!(m, \", $swapped, \");\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn swap_bytes(self) -> Self {\n                (self as $UnsignedT).swap_bytes() as Self\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Reverses the bit pattern of the integer.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(reverse_bits)]\n\nlet n = \", $swap_op, stringify!($SelfT), \";\nlet m = n.reverse_bits();\n\nassert_eq!(m, \", $reversed, \");\n```\"),\n            #[unstable(feature = \"reverse_bits\", issue = \"48763\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn reverse_bits(self) -> Self {\n                (self as $UnsignedT).reverse_bits() as Self\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts an integer from big endian to the target's endianness.\n\nOn big endian this is a no-op. On little endian the bytes are swapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"big\\\") {\n    assert_eq!(\", stringify!($SelfT), \"::from_be(n), n)\n} else {\n    assert_eq!(\", stringify!($SelfT), \"::from_be(n), n.swap_bytes())\n}\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn from_be(x: Self) -> Self {\n                #[cfg(target_endian = \"big\")]\n                {\n                    x\n                }\n                #[cfg(not(target_endian = \"big\"))]\n                {\n                    x.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts an integer from little endian to the target's endianness.\n\nOn little endian this is a no-op. On big endian the bytes are swapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"little\\\") {\n    assert_eq!(\", stringify!($SelfT), \"::from_le(n), n)\n} else {\n    assert_eq!(\", stringify!($SelfT), \"::from_le(n), n.swap_bytes())\n}\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn from_le(x: Self) -> Self {\n                #[cfg(target_endian = \"little\")]\n                {\n                    x\n                }\n                #[cfg(not(target_endian = \"little\"))]\n                {\n                    x.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts `self` to big endian from the target's endianness.\n\nOn big endian this is a no-op. On little endian the bytes are swapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"big\\\") {\n    assert_eq!(n.to_be(), n)\n} else {\n    assert_eq!(n.to_be(), n.swap_bytes())\n}\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn to_be(self) -> Self { // or not to be?\n                #[cfg(target_endian = \"big\")]\n                {\n                    self\n                }\n                #[cfg(not(target_endian = \"big\"))]\n                {\n                    self.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts `self` to little endian from the target's endianness.\n\nOn little endian this is a no-op. On big endian the bytes are swapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"little\\\") {\n    assert_eq!(n.to_le(), n)\n} else {\n    assert_eq!(n.to_le(), n.swap_bytes())\n}\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn to_le(self) -> Self {\n                #[cfg(target_endian = \"little\")]\n                {\n                    self\n                }\n                #[cfg(not(target_endian = \"little\"))]\n                {\n                    self.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer addition. Computes `self + rhs`, returning `None`\nif overflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((\", stringify!($SelfT),\n\"::max_value() - 2).checked_add(1), Some(\", stringify!($SelfT), \"::max_value() - 1));\nassert_eq!((\", stringify!($SelfT), \"::max_value() - 2).checked_add(3), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_add(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_add(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer subtraction. Computes `self - rhs`, returning `None` if\noverflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((\", stringify!($SelfT),\n\"::min_value() + 2).checked_sub(1), Some(\", stringify!($SelfT), \"::min_value() + 1));\nassert_eq!((\", stringify!($SelfT), \"::min_value() + 2).checked_sub(3), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_sub(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_sub(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer multiplication. Computes `self * rhs`, returning `None` if\noverflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT),\n\"::max_value().checked_mul(1), Some(\", stringify!($SelfT), \"::max_value()));\nassert_eq!(\", stringify!($SelfT), \"::max_value().checked_mul(2), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_mul(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_mul(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer division. Computes `self / rhs`, returning `None` if `rhs == 0`\nor the division results in overflow.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((\", stringify!($SelfT),\n\"::min_value() + 1).checked_div(-1), Some(\", stringify!($Max), \"));\nassert_eq!(\", stringify!($SelfT), \"::min_value().checked_div(-1), None);\nassert_eq!((1\", stringify!($SelfT), \").checked_div(0), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_div(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 || (self == Self::min_value() && rhs == -1) {\n                    None\n                } else {\n                    Some(unsafe { intrinsics::unchecked_div(self, rhs) })\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked Euclidean division. Computes `self.div_euc(rhs)`,\nreturning `None` if `rhs == 0` or the division results in overflow.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!((\", stringify!($SelfT),\n\"::min_value() + 1).checked_div_euc(-1), Some(\", stringify!($Max), \"));\nassert_eq!(\", stringify!($SelfT), \"::min_value().checked_div_euc(-1), None);\nassert_eq!((1\", stringify!($SelfT), \").checked_div_euc(0), None);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn checked_div_euc(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 || (self == Self::min_value() && rhs == -1) {\n                    None\n                } else {\n                    Some(self.div_euc(rhs))\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer remainder. Computes `self % rhs`, returning `None` if\n`rhs == 0` or the division results in overflow.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".checked_rem(2), Some(1));\nassert_eq!(5\", stringify!($SelfT), \".checked_rem(0), None);\nassert_eq!(\", stringify!($SelfT), \"::MIN.checked_rem(-1), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_rem(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 || (self == Self::min_value() && rhs == -1) {\n                    None\n                } else {\n                    Some(unsafe { intrinsics::unchecked_rem(self, rhs) })\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked Euclidean modulo. Computes `self.mod_euc(rhs)`, returning `None` if\n`rhs == 0` or the division results in overflow.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nuse std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".checked_mod_euc(2), Some(1));\nassert_eq!(5\", stringify!($SelfT), \".checked_mod_euc(0), None);\nassert_eq!(\", stringify!($SelfT), \"::MIN.checked_mod_euc(-1), None);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn checked_mod_euc(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 || (self == Self::min_value() && rhs == -1) {\n                    None\n                } else {\n                    Some(self.mod_euc(rhs))\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked negation. Computes `-self`, returning `None` if `self == MIN`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".checked_neg(), Some(-5));\nassert_eq!(\", stringify!($SelfT), \"::MIN.checked_neg(), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_neg(self) -> Option<Self> {\n                let (a, b) = self.overflowing_neg();\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked shift left. Computes `self << rhs`, returning `None` if `rhs` is larger\nthan or equal to the number of bits in `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x1\", stringify!($SelfT), \".checked_shl(4), Some(0x10));\nassert_eq!(0x1\", stringify!($SelfT), \".checked_shl(129), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_shl(self, rhs: u32) -> Option<Self> {\n                let (a, b) = self.overflowing_shl(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked shift right. Computes `self >> rhs`, returning `None` if `rhs` is\nlarger than or equal to the number of bits in `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x10\", stringify!($SelfT), \".checked_shr(4), Some(0x1));\nassert_eq!(0x10\", stringify!($SelfT), \".checked_shr(128), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_shr(self, rhs: u32) -> Option<Self> {\n                let (a, b) = self.overflowing_shr(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked absolute value. Computes `self.abs()`, returning `None` if\n`self == MIN`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!((-5\", stringify!($SelfT), \").checked_abs(), Some(5));\nassert_eq!(\", stringify!($SelfT), \"::MIN.checked_abs(), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"no_panic_abs\", since = \"1.13.0\")]\n            #[inline]\n            pub fn checked_abs(self) -> Option<Self> {\n                if self.is_negative() {\n                    self.checked_neg()\n                } else {\n                    Some(self)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked exponentiation. Computes `self.pow(exp)`, returning `None` if\noverflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(8\", stringify!($SelfT), \".checked_pow(2), Some(64));\nassert_eq!(\", stringify!($SelfT), \"::max_value().checked_pow(2), None);\",\n$EndFeature, \"\n```\"),\n\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn checked_pow(self, mut exp: u32) -> Option<Self> {\n                let mut base = self;\n                let mut acc: Self = 1;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        acc = acc.checked_mul(base)?;\n                    }\n                    exp /= 2;\n                    base = base.checked_mul(base)?;\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    acc = acc.checked_mul(base)?;\n                }\n\n                Some(acc)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer addition. Computes `self + rhs`, saturating at the numeric\nbounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".saturating_add(1), 101);\nassert_eq!(\", stringify!($SelfT), \"::max_value().saturating_add(100), \", stringify!($SelfT),\n\"::max_value());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn saturating_add(self, rhs: Self) -> Self {\n                match self.checked_add(rhs) {\n                    Some(x) => x,\n                    None if rhs >= 0 => Self::max_value(),\n                    None => Self::min_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer subtraction. Computes `self - rhs`, saturating at the\nnumeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".saturating_sub(127), -27);\nassert_eq!(\", stringify!($SelfT), \"::min_value().saturating_sub(100), \", stringify!($SelfT),\n\"::min_value());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn saturating_sub(self, rhs: Self) -> Self {\n                match self.checked_sub(rhs) {\n                    Some(x) => x,\n                    None if rhs >= 0 => Self::min_value(),\n                    None => Self::max_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer multiplication. Computes `self * rhs`, saturating at the\nnumeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(10\", stringify!($SelfT), \".saturating_mul(12), 120);\nassert_eq!(\", stringify!($SelfT), \"::MAX.saturating_mul(10), \", stringify!($SelfT), \"::MAX);\nassert_eq!(\", stringify!($SelfT), \"::MIN.saturating_mul(10), \", stringify!($SelfT), \"::MIN);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn saturating_mul(self, rhs: Self) -> Self {\n                self.checked_mul(rhs).unwrap_or_else(|| {\n                    if (self < 0 && rhs < 0) || (self > 0 && rhs > 0) {\n                        Self::max_value()\n                    } else {\n                        Self::min_value()\n                    }\n                })\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer exponentiation. Computes `self.pow(exp)`,\nsaturating at the numeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!((-4\", stringify!($SelfT), \").saturating_pow(3), -64);\nassert_eq!(\", stringify!($SelfT), \"::MIN.saturating_pow(2), \", stringify!($SelfT), \"::MAX);\nassert_eq!(\", stringify!($SelfT), \"::MIN.saturating_pow(3), \", stringify!($SelfT), \"::MIN);\",\n$EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn saturating_pow(self, exp: u32) -> Self {\n                match self.checked_pow(exp) {\n                    Some(x) => x,\n                    None if self < 0 && exp % 2 == 1 => Self::min_value(),\n                    None => Self::max_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) addition. Computes `self + rhs`, wrapping around at the\nboundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_add(27), 127);\nassert_eq!(\", stringify!($SelfT), \"::max_value().wrapping_add(2), \", stringify!($SelfT),\n\"::min_value() + 1);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_add(self, rhs: Self) -> Self {\n                unsafe {\n                    intrinsics::overflowing_add(self, rhs)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) subtraction. Computes `self - rhs`, wrapping around at the\nboundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0\", stringify!($SelfT), \".wrapping_sub(127), -127);\nassert_eq!((-2\", stringify!($SelfT), \").wrapping_sub(\", stringify!($SelfT), \"::max_value()), \",\nstringify!($SelfT), \"::max_value());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_sub(self, rhs: Self) -> Self {\n                unsafe {\n                    intrinsics::overflowing_sub(self, rhs)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) multiplication. Computes `self * rhs`, wrapping around at\nthe boundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(10\", stringify!($SelfT), \".wrapping_mul(12), 120);\nassert_eq!(11i8.wrapping_mul(12), -124);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_mul(self, rhs: Self) -> Self {\n                unsafe {\n                    intrinsics::overflowing_mul(self, rhs)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) division. Computes `self / rhs`, wrapping around at the\nboundary of the type.\n\nThe only case where such wrapping can occur is when one divides `MIN / -1` on a signed type (where\n`MIN` is the negative minimal value for the type); this is equivalent to `-MIN`, a positive value\nthat is too large to represent in the type. In such a case, this function returns `MIN` itself.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_div(10), 10);\nassert_eq!((-128i8).wrapping_div(-1), -128);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[inline]\n            pub fn wrapping_div(self, rhs: Self) -> Self {\n                self.overflowing_div(rhs).0\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping Euclidean division. Computes `self.div_euc(rhs)`,\nwrapping around at the boundary of the type.\n\nWrapping will only occur in `MIN / -1` on a signed type (where `MIN` is the negative minimal value\nfor the type). This is equivalent to `-MIN`, a positive value that is too large to represent in the\ntype. In this case, this method returns `MIN` itself.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(100\", stringify!($SelfT), \".wrapping_div_euc(10), 10);\nassert_eq!((-128i8).wrapping_div_euc(-1), -128);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn wrapping_div_euc(self, rhs: Self) -> Self {\n                self.overflowing_div_euc(rhs).0\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) remainder. Computes `self % rhs`, wrapping around at the\nboundary of the type.\n\nSuch wrap-around never actually occurs mathematically; implementation artifacts make `x % y`\ninvalid for `MIN / -1` on a signed type (where `MIN` is the negative minimal value). In such a case,\nthis function returns `0`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_rem(10), 0);\nassert_eq!((-128i8).wrapping_rem(-1), 0);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[inline]\n            pub fn wrapping_rem(self, rhs: Self) -> Self {\n                self.overflowing_rem(rhs).0\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping Euclidean modulo. Computes `self.mod_euc(rhs)`, wrapping around at the\nboundary of the type.\n\nWrapping will only occur in `MIN % -1` on a signed type (where `MIN` is the negative minimal value\nfor the type). In this case, this method returns 0.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(100\", stringify!($SelfT), \".wrapping_mod_euc(10), 0);\nassert_eq!((-128i8).wrapping_mod_euc(-1), 0);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn wrapping_mod_euc(self, rhs: Self) -> Self {\n                self.overflowing_mod_euc(rhs).0\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) negation. Computes `-self`, wrapping around at the boundary\nof the type.\n\nThe only case where such wrapping can occur is when one negates `MIN` on a signed type (where `MIN`\nis the negative minimal value for the type); this is a positive value that is too large to represent\nin the type. In such a case, this function returns `MIN` itself.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_neg(), -100);\nassert_eq!(\", stringify!($SelfT), \"::min_value().wrapping_neg(), \", stringify!($SelfT),\n\"::min_value());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[inline]\n            pub fn wrapping_neg(self) -> Self {\n                self.overflowing_neg().0\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Panic-free bitwise shift-left; yields `self << mask(rhs)`, where `mask` removes\nany high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.\n\nNote that this is *not* the same as a rotate-left; the RHS of a wrapping shift-left is restricted to\nthe range of the type, rather than the bits shifted out of the LHS being returned to the other end.\nThe primitive integer types all implement a `rotate_left` function, which may be what you want\ninstead.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((-1\", stringify!($SelfT), \").wrapping_shl(7), -128);\nassert_eq!((-1\", stringify!($SelfT), \").wrapping_shl(128), -1);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_shl(self, rhs: u32) -> Self {\n                unsafe {\n                    intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Panic-free bitwise shift-right; yields `self >> mask(rhs)`, where `mask`\nremoves any high-order bits of `rhs` that would cause the shift to exceed the bitwidth of the type.\n\nNote that this is *not* the same as a rotate-right; the RHS of a wrapping shift-right is restricted\nto the range of the type, rather than the bits shifted out of the LHS being returned to the other\nend. The primitive integer types all implement a `rotate_right` function, which may be what you want\ninstead.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((-128\", stringify!($SelfT), \").wrapping_shr(7), -1);\nassert_eq!((-128i16).wrapping_shr(64), -128);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_shr(self, rhs: u32) -> Self {\n                unsafe {\n                    intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) absolute value. Computes `self.abs()`, wrapping around at\nthe boundary of the type.\n\nThe only case where such wrapping can occur is when one takes the absolute value of the negative\nminimal value for the type this is a positive value that is too large to represent in the type. In\nsuch a case, this function returns `MIN` itself.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_abs(), 100);\nassert_eq!((-100\", stringify!($SelfT), \").wrapping_abs(), 100);\nassert_eq!(\", stringify!($SelfT), \"::min_value().wrapping_abs(), \", stringify!($SelfT),\n\"::min_value());\nassert_eq!((-128i8).wrapping_abs() as u8, 128);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"no_panic_abs\", since = \"1.13.0\")]\n            #[inline]\n            pub fn wrapping_abs(self) -> Self {\n                if self.is_negative() {\n                    self.wrapping_neg()\n                } else {\n                    self\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) exponentiation. Computes `self.pow(exp)`,\nwrapping around at the boundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(3\", stringify!($SelfT), \".wrapping_pow(4), 81);\nassert_eq!(3i8.wrapping_pow(5), -13);\nassert_eq!(3i8.wrapping_pow(6), -39);\",\n$EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn wrapping_pow(self, mut exp: u32) -> Self {\n                let mut base = self;\n                let mut acc: Self = 1;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        acc = acc.wrapping_mul(base);\n                    }\n                    exp /= 2;\n                    base = base.wrapping_mul(base);\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    acc = acc.wrapping_mul(base);\n                }\n\n                acc\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates `self` + `rhs`\n\nReturns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would\noccur. If an overflow would have occurred then the wrapped value is returned.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_add(2), (7, false));\nassert_eq!(\", stringify!($SelfT), \"::MAX.overflowing_add(1), (\", stringify!($SelfT),\n\"::MIN, true));\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {\n                let (a, b) = unsafe {\n                    intrinsics::add_with_overflow(self as $ActualT,\n                                                  rhs as $ActualT)\n                };\n                (a as Self, b)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates `self` - `rhs`\n\nReturns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow\nwould occur. If an overflow would have occurred then the wrapped value is returned.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_sub(2), (3, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_sub(1), (\", stringify!($SelfT),\n\"::MAX, true));\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {\n                let (a, b) = unsafe {\n                    intrinsics::sub_with_overflow(self as $ActualT,\n                                                  rhs as $ActualT)\n                };\n                (a as Self, b)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the multiplication of `self` and `rhs`.\n\nReturns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow\nwould occur. If an overflow would have occurred then the wrapped value is returned.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(5\", stringify!($SelfT), \".overflowing_mul(2), (10, false));\nassert_eq!(1_000_000_000i32.overflowing_mul(10), (1410065408, true));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {\n                let (a, b) = unsafe {\n                    intrinsics::mul_with_overflow(self as $ActualT,\n                                                  rhs as $ActualT)\n                };\n                (a as Self, b)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the divisor when `self` is divided by `rhs`.\n\nReturns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would\noccur. If an overflow would occur then self is returned.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_div(2), (2, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_div(-1), (\", stringify!($SelfT),\n\"::MIN, true));\",\n$EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {\n                if self == Self::min_value() && rhs == -1 {\n                    (self, true)\n                } else {\n                    (self / rhs, false)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the quotient of Euclidean division `self.div_euc(rhs)`.\n\nReturns a tuple of the divisor along with a boolean indicating whether an arithmetic overflow would\noccur. If an overflow would occur then `self` is returned.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nuse std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_div_euc(2), (2, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_div_euc(-1), (\", stringify!($SelfT),\n\"::MIN, true));\n```\"),\n            #[inline]\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            pub fn overflowing_div_euc(self, rhs: Self) -> (Self, bool) {\n                if self == Self::min_value() && rhs == -1 {\n                    (self, true)\n                } else {\n                    (self.div_euc(rhs), false)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the remainder when `self` is divided by `rhs`.\n\nReturns a tuple of the remainder after dividing along with a boolean indicating whether an\narithmetic overflow would occur. If an overflow would occur then 0 is returned.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_rem(2), (1, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_rem(-1), (0, true));\",\n$EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {\n                if self == Self::min_value() && rhs == -1 {\n                    (0, true)\n                } else {\n                    (self % rhs, false)\n                }\n            }\n        }\n\n\n        doc_comment! {\n            concat!(\"Calculates the remainder `self.mod_euc(rhs)` by Euclidean division.\n\nReturns a tuple of the remainder after dividing along with a boolean indicating whether an\narithmetic overflow would occur. If an overflow would occur then 0 is returned.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nuse std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_mod_euc(2), (1, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_mod_euc(-1), (0, true));\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn overflowing_mod_euc(self, rhs: Self) -> (Self, bool) {\n                if self == Self::min_value() && rhs == -1 {\n                    (0, true)\n                } else {\n                    (self.mod_euc(rhs), false)\n                }\n            }\n        }\n\n\n        doc_comment! {\n            concat!(\"Negates self, overflowing if this is equal to the minimum value.\n\nReturns a tuple of the negated version of self along with a boolean indicating whether an overflow\nhappened. If `self` is the minimum value (e.g. `i32::MIN` for values of type `i32`), then the\nminimum value will be returned again and `true` will be returned for an overflow happening.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(2\", stringify!($SelfT), \".overflowing_neg(), (-2, false));\nassert_eq!(\", stringify!($SelfT), \"::MIN.overflowing_neg(), (\", stringify!($SelfT),\n\"::MIN, true));\", $EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_neg(self) -> (Self, bool) {\n                if self == Self::min_value() {\n                    (Self::min_value(), true)\n                } else {\n                    (-self, false)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts self left by `rhs` bits.\n\nReturns a tuple of the shifted version of self along with a boolean indicating whether the shift\nvalue was larger than or equal to the number of bits. If the shift value is too large, then value is\nmasked (N-1) where N is the number of bits, and this value is then used to perform the shift.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x1\", stringify!($SelfT),\".overflowing_shl(4), (0x10, false));\nassert_eq!(0x1i32.overflowing_shl(36), (0x10, true));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {\n                (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts self right by `rhs` bits.\n\nReturns a tuple of the shifted version of self along with a boolean indicating whether the shift\nvalue was larger than or equal to the number of bits. If the shift value is too large, then value is\nmasked (N-1) where N is the number of bits, and this value is then used to perform the shift.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x10\", stringify!($SelfT), \".overflowing_shr(4), (0x1, false));\nassert_eq!(0x10i32.overflowing_shr(36), (0x1, true));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {\n                (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Computes the absolute value of `self`.\n\nReturns a tuple of the absolute version of self along with a boolean indicating whether an overflow\nhappened. If self is the minimum value (e.g. \", stringify!($SelfT), \"::MIN for values of type\n \", stringify!($SelfT), \"), then the minimum value will be returned again and true will be returned\nfor an overflow happening.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(10\", stringify!($SelfT), \".overflowing_abs(), (10, false));\nassert_eq!((-10\", stringify!($SelfT), \").overflowing_abs(), (10, false));\nassert_eq!((\", stringify!($SelfT), \"::min_value()).overflowing_abs(), (\", stringify!($SelfT),\n\"::min_value(), true));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"no_panic_abs\", since = \"1.13.0\")]\n            #[inline]\n            pub fn overflowing_abs(self) -> (Self, bool) {\n                if self.is_negative() {\n                    self.overflowing_neg()\n                } else {\n                    (self, false)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Raises self to the power of `exp`, using exponentiation by squaring.\n\nReturns a tuple of the exponentiation along with a bool indicating\nwhether an overflow happened.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(3\", stringify!($SelfT), \".overflowing_pow(4), (81, false));\nassert_eq!(3i8.overflowing_pow(5), (-13, true));\",\n$EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {\n                let mut base = self;\n                let mut acc: Self = 1;\n                let mut overflown = false;\n                // Scratch space for storing results of overflowing_mul.\n                let mut r;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        r = acc.overflowing_mul(base);\n                        acc = r.0;\n                        overflown |= r.1;\n                    }\n                    exp /= 2;\n                    r = base.overflowing_mul(base);\n                    base = r.0;\n                    overflown |= r.1;\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    r = acc.overflowing_mul(base);\n                    acc = r.0;\n                    overflown |= r.1;\n                }\n\n                (acc, overflown)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Raises self to the power of `exp`, using exponentiation by squaring.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let x: \", stringify!($SelfT), \" = 2; // or any other integer type\n\nassert_eq!(x.pow(5), 32);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn pow(self, mut exp: u32) -> Self {\n                let mut base = self;\n                let mut acc = 1;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        acc = acc * base;\n                    }\n                    exp /= 2;\n                    base = base * base;\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    acc = acc * base;\n                }\n\n                acc\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the quotient of Euclidean division of `self` by `rhs`.\n\nThis computes the integer `n` such that `self = n * rhs + self.mod_euc(rhs)`.\nIn other words, the result is `self / rhs` rounded to the integer `n`\nsuch that `self >= n * rhs`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nlet a: \", stringify!($SelfT), \" = 7; // or any other integer type\nlet b = 4;\n\nassert_eq!(a.div_euc(b), 1); // 7 >= 4 * 1\nassert_eq!(a.div_euc(-b), -1); // 7 >= -4 * -1\nassert_eq!((-a).div_euc(b), -2); // -7 >= 4 * -2\nassert_eq!((-a).div_euc(-b), 2); // -7 >= -4 * 2\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn div_euc(self, rhs: Self) -> Self {\n                let q = self / rhs;\n                if self % rhs < 0 {\n                    return if rhs > 0 { q - 1 } else { q + 1 }\n                }\n                q\n            }\n        }\n\n\n        doc_comment! {\n            concat!(\"Calculates the remainder `self mod rhs` by Euclidean division.\n\nIn particular, the result `n` satisfies `0 <= n < rhs.abs()`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nlet a: \", stringify!($SelfT), \" = 7; // or any other integer type\nlet b = 4;\n\nassert_eq!(a.mod_euc(b), 3);\nassert_eq!((-a).mod_euc(b), 1);\nassert_eq!(a.mod_euc(-b), 3);\nassert_eq!((-a).mod_euc(-b), 1);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn mod_euc(self, rhs: Self) -> Self {\n                let r = self % rhs;\n                if r < 0 {\n                    if rhs < 0 {\n                        r - rhs\n                    } else {\n                        r + rhs\n                    }\n                } else {\n                    r\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Computes the absolute value of `self`.\n\n# Overflow behavior\n\nThe absolute value of `\", stringify!($SelfT), \"::min_value()` cannot be represented as an\n`\", stringify!($SelfT), \"`, and attempting to calculate it will cause an overflow. This means that\ncode in debug mode will trigger a panic on this case and optimized code will return `\",\nstringify!($SelfT), \"::min_value()` without a panic.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(10\", stringify!($SelfT), \".abs(), 10);\nassert_eq!((-10\", stringify!($SelfT), \").abs(), 10);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn abs(self) -> Self {\n                if self.is_negative() {\n                    // Note that the #[inline] above means that the overflow\n                    // semantics of this negation depend on the crate we're being\n                    // inlined into.\n                    -self\n                } else {\n                    self\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns a number representing sign of `self`.\n\n - `0` if the number is zero\n - `1` if the number is positive\n - `-1` if the number is negative\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(10\", stringify!($SelfT), \".signum(), 1);\nassert_eq!(0\", stringify!($SelfT), \".signum(), 0);\nassert_eq!((-10\", stringify!($SelfT), \").signum(), -1);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn signum(self) -> Self {\n                match self {\n                    n if n > 0 =>  1,\n                    0          =>  0,\n                    _          => -1,\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns `true` if `self` is positive and `false` if the number is zero or\nnegative.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert!(10\", stringify!($SelfT), \".is_positive());\nassert!(!(-10\", stringify!($SelfT), \").is_positive());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_sign\")]\n            #[inline]\n            pub const fn is_positive(self) -> bool { self > 0 }\n        }\n\n        doc_comment! {\n            concat!(\"Returns `true` if `self` is negative and `false` if the number is zero or\npositive.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert!((-10\", stringify!($SelfT), \").is_negative());\nassert!(!10\", stringify!($SelfT), \".is_negative());\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_sign\")]\n            #[inline]\n            pub const fn is_negative(self) -> bool { self < 0 }\n        }\n\n        doc_comment! {\n            concat!(\"Return the memory representation of this integer as a byte array in\nbig-endian (network) byte order.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_be_bytes();\nassert_eq!(bytes, \", $be_bytes, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                self.to_be().to_ne_bytes()\n            }\n        }\n\ndoc_comment! {\n            concat!(\"Return the memory representation of this integer as a byte array in\nlittle-endian byte order.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_le_bytes();\nassert_eq!(bytes, \", $le_bytes, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                self.to_le().to_ne_bytes()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"\nReturn the memory representation of this integer as a byte array in\nnative byte order.\n\nAs the target platform's native endianness is used, portable code\nshould use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,\ninstead.\n\n[`to_be_bytes`]: #method.to_be_bytes\n[`to_le_bytes`]: #method.to_le_bytes\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_ne_bytes();\nassert_eq!(bytes, if cfg!(target_endian = \\\"big\\\") {\n        \", $be_bytes, \"\n    } else {\n        \", $le_bytes, \"\n    });\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                unsafe { mem::transmute(self) }\n            }\n        }\n\ndoc_comment! {\n            concat!(\"Create an integer value from its representation as a byte array in\nbig endian.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_be_bytes(\", $be_bytes, \");\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                Self::from_be(Self::from_ne_bytes(bytes))\n            }\n        }\n\ndoc_comment! {\n            concat!(\"\nCreate an integer value from its representation as a byte array in\nlittle endian.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_le_bytes(\", $le_bytes, \");\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                Self::from_le(Self::from_ne_bytes(bytes))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Create an integer value from its memory representation as a byte\narray in native endianness.\n\nAs the target platform's native endianness is used, portable code\nlikely wants to use [`from_be_bytes`] or [`from_le_bytes`], as\nappropriate instead.\n\n[`from_be_bytes`]: #method.from_be_bytes\n[`from_le_bytes`]: #method.from_le_bytes\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_ne_bytes(if cfg!(target_endian = \\\"big\\\") {\n        \", $be_bytes, \"\n    } else {\n        \", $le_bytes, \"\n    });\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                unsafe { mem::transmute(bytes) }\n            }\n        }\n    }\n}\n\n#[lang = \"i8\"]\nimpl i8 {\n    int_impl! { i8, i8, u8, 8, -128, 127, \"\", \"\", 2, \"-0x7e\", \"0xa\", \"0x12\", \"0x12\", \"0x48\",\n        \"[0x12]\", \"[0x12]\" }\n}\n\n#[lang = \"i16\"]\nimpl i16 {\n    int_impl! { i16, i16, u16, 16, -32768, 32767, \"\", \"\", 4, \"-0x5ffd\", \"0x3a\", \"0x1234\", \"0x3412\",\n        \"0x2c48\", \"[0x34, 0x12]\", \"[0x12, 0x34]\" }\n}\n\n#[lang = \"i32\"]\nimpl i32 {\n    int_impl! { i32, i32, u32, 32, -2147483648, 2147483647, \"\", \"\", 8, \"0x10000b3\", \"0xb301\",\n        \"0x12345678\", \"0x78563412\", \"0x1e6a2c48\", \"[0x78, 0x56, 0x34, 0x12]\",\n        \"[0x12, 0x34, 0x56, 0x78]\" }\n}\n\n#[lang = \"i64\"]\nimpl i64 {\n    int_impl! { i64, i64, u64, 64, -9223372036854775808, 9223372036854775807, \"\", \"\", 12,\n         \"0xaa00000000006e1\", \"0x6e10aa\", \"0x1234567890123456\", \"0x5634129078563412\",\n         \"0x6a2c48091e6a2c48\", \"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n         \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]\" }\n}\n\n#[lang = \"i128\"]\nimpl i128 {\n    int_impl! { i128, i128, u128, 128, -170141183460469231731687303715884105728,\n        170141183460469231731687303715884105727, \"\", \"\", 16,\n        \"0x13f40000000000000000000000004f76\", \"0x4f7613f4\", \"0x12345678901234567890123456789012\",\n        \"0x12907856341290785634129078563412\", \"0x48091e6a2c48091e6a2c48091e6a2c48\",\n        \"[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, \\\n          0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n        \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, \\\n          0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]\" }\n}\n\n#[cfg(target_pointer_width = \"16\")]\n#[lang = \"isize\"]\nimpl isize {\n    int_impl! { isize, i16, u16, 16, -32768, 32767, \"\", \"\", 4, \"-0x5ffd\", \"0x3a\", \"0x1234\",\n        \"0x3412\", \"0x2c48\", \"[0x34, 0x12]\", \"[0x12, 0x34]\" }\n}\n\n#[cfg(target_pointer_width = \"32\")]\n#[lang = \"isize\"]\nimpl isize {\n    int_impl! { isize, i32, u32, 32, -2147483648, 2147483647, \"\", \"\", 8, \"0x10000b3\", \"0xb301\",\n        \"0x12345678\", \"0x78563412\", \"0x1e6a2c48\", \"[0x78, 0x56, 0x34, 0x12]\",\n        \"[0x12, 0x34, 0x56, 0x78]\" }\n}\n\n#[cfg(target_pointer_width = \"64\")]\n#[lang = \"isize\"]\nimpl isize {\n    int_impl! { isize, i64, u64, 64, -9223372036854775808, 9223372036854775807, \"\", \"\",\n        12, \"0xaa00000000006e1\", \"0x6e10aa\",  \"0x1234567890123456\", \"0x5634129078563412\",\n         \"0x6a2c48091e6a2c48\", \"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n         \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]\" }\n}\n\n// Emits the correct `cttz` call, depending on the size of the type.\nmacro_rules! uint_cttz_call {\n    // As of LLVM 3.6 the codegen for the zero-safe cttz8 intrinsic\n    // emits two conditional moves on x86_64. By promoting the value to\n    // u16 and setting bit 8, we get better code without any conditional\n    // operations.\n    // FIXME: There's a LLVM patch (http://reviews.llvm.org/D9284)\n    // pending, remove this workaround once LLVM generates better code\n    // for cttz8.\n    ($value:expr, 8) => { intrinsics::cttz($value as u16 | 0x100) };\n    ($value:expr, $_BITS:expr) => { intrinsics::cttz($value) }\n}\n\n// `Int` + `UnsignedInt` implemented for unsigned integers\nmacro_rules! uint_impl {\n    ($SelfT:ty, $ActualT:ty, $BITS:expr, $MaxV:expr, $Feature:expr, $EndFeature:expr,\n        $rot:expr, $rot_op:expr, $rot_result:expr, $swap_op:expr, $swapped:expr,\n        $reversed:expr, $le_bytes:expr, $be_bytes:expr) => {\n        doc_comment! {\n            concat!(\"Returns the smallest value that can be represented by this integer type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::min_value(), 0);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub const fn min_value() -> Self { 0 }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the largest value that can be represented by this integer type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::max_value(), \",\nstringify!($MaxV), \");\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub const fn max_value() -> Self { !0 }\n        }\n\n        doc_comment! {\n            concat!(\"Converts a string slice in a given base to an integer.\n\nThe string is expected to be an optional `+` sign\nfollowed by digits.\nLeading and trailing whitespace represent an error.\nDigits are a subset of these characters, depending on `radix`:\n\n* `0-9`\n* `a-z`\n* `A-Z`\n\n# Panics\n\nThis function panics if `radix` is not in the range from 2 to 36.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::from_str_radix(\\\"A\\\", 16), Ok(10));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {\n                from_str_radix(src, radix)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of ones in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0b01001100\", stringify!($SelfT), \";\n\nassert_eq!(n.count_ones(), 3);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn count_ones(self) -> u32 {\n                unsafe { intrinsics::ctpop(self as $ActualT) as u32 }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of zeros in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(\", stringify!($SelfT), \"::max_value().count_zeros(), 0);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn count_zeros(self) -> u32 {\n                (!self).count_ones()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of leading zeros in the binary representation of `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = \", stringify!($SelfT), \"::max_value() >> 2;\n\nassert_eq!(n.leading_zeros(), 2);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn leading_zeros(self) -> u32 {\n                unsafe { intrinsics::ctlz(self as $ActualT) as u32 }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the number of trailing zeros in the binary representation\nof `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0b0101000\", stringify!($SelfT), \";\n\nassert_eq!(n.trailing_zeros(), 3);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn trailing_zeros(self) -> u32 {\n                unsafe { uint_cttz_call!(self, $BITS) as u32 }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts the bits to the left by a specified amount, `n`,\nwrapping the truncated bits to the end of the resulting integer.\n\nPlease note this isn't the same operation as `<<`!\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $rot_op, stringify!($SelfT), \";\nlet m = \", $rot_result, \";\n\nassert_eq!(n.rotate_left(\", $rot, \"), m);\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_rotate\")]\n            #[inline]\n            pub const fn rotate_left(self, n: u32) -> Self {\n                (self << (n % $BITS)) | (self >> (($BITS - (n % $BITS)) % $BITS))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts the bits to the right by a specified amount, `n`,\nwrapping the truncated bits to the beginning of the resulting\ninteger.\n\nPlease note this isn't the same operation as `>>`!\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $rot_result, stringify!($SelfT), \";\nlet m = \", $rot_op, \";\n\nassert_eq!(n.rotate_right(\", $rot, \"), m);\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_rotate\")]\n            #[inline]\n            pub const fn rotate_right(self, n: u32) -> Self {\n                (self >> (n % $BITS)) | (self << (($BITS - (n % $BITS)) % $BITS))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"\nReverses the byte order of the integer.\n\n# Examples\n\nBasic usage:\n\n```\nlet n = \", $swap_op, stringify!($SelfT), \";\nlet m = n.swap_bytes();\n\nassert_eq!(m, \", $swapped, \");\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn swap_bytes(self) -> Self {\n                unsafe { intrinsics::bswap(self as $ActualT) as Self }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Reverses the bit pattern of the integer.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(reverse_bits)]\n\nlet n = \", $swap_op, stringify!($SelfT), \";\nlet m = n.reverse_bits();\n\nassert_eq!(m, \", $reversed, \");\n```\"),\n            #[unstable(feature = \"reverse_bits\", issue = \"48763\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn reverse_bits(self) -> Self {\n                unsafe { intrinsics::bitreverse(self as $ActualT) as Self }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts an integer from big endian to the target's endianness.\n\nOn big endian this is a no-op. On little endian the bytes are\nswapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"big\\\") {\n    assert_eq!(\", stringify!($SelfT), \"::from_be(n), n)\n} else {\n    assert_eq!(\", stringify!($SelfT), \"::from_be(n), n.swap_bytes())\n}\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn from_be(x: Self) -> Self {\n                #[cfg(target_endian = \"big\")]\n                {\n                    x\n                }\n                #[cfg(not(target_endian = \"big\"))]\n                {\n                    x.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts an integer from little endian to the target's endianness.\n\nOn little endian this is a no-op. On big endian the bytes are\nswapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"little\\\") {\n    assert_eq!(\", stringify!($SelfT), \"::from_le(n), n)\n} else {\n    assert_eq!(\", stringify!($SelfT), \"::from_le(n), n.swap_bytes())\n}\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn from_le(x: Self) -> Self {\n                #[cfg(target_endian = \"little\")]\n                {\n                    x\n                }\n                #[cfg(not(target_endian = \"little\"))]\n                {\n                    x.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts `self` to big endian from the target's endianness.\n\nOn big endian this is a no-op. On little endian the bytes are\nswapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"big\\\") {\n    assert_eq!(n.to_be(), n)\n} else {\n    assert_eq!(n.to_be(), n.swap_bytes())\n}\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn to_be(self) -> Self { // or not to be?\n                #[cfg(target_endian = \"big\")]\n                {\n                    self\n                }\n                #[cfg(not(target_endian = \"big\"))]\n                {\n                    self.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Converts `self` to little endian from the target's endianness.\n\nOn little endian this is a no-op. On big endian the bytes are\nswapped.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"let n = 0x1A\", stringify!($SelfT), \";\n\nif cfg!(target_endian = \\\"little\\\") {\n    assert_eq!(n.to_le(), n)\n} else {\n    assert_eq!(n.to_le(), n.swap_bytes())\n}\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_ops\")]\n            #[inline]\n            pub const fn to_le(self) -> Self {\n                #[cfg(target_endian = \"little\")]\n                {\n                    self\n                }\n                #[cfg(not(target_endian = \"little\"))]\n                {\n                    self.swap_bytes()\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer addition. Computes `self + rhs`, returning `None`\nif overflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!((\", stringify!($SelfT), \"::max_value() - 2).checked_add(1), \",\n\"Some(\", stringify!($SelfT), \"::max_value() - 1));\nassert_eq!((\", stringify!($SelfT), \"::max_value() - 2).checked_add(3), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_add(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_add(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer subtraction. Computes `self - rhs`, returning\n`None` if overflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(1\", stringify!($SelfT), \".checked_sub(1), Some(0));\nassert_eq!(0\", stringify!($SelfT), \".checked_sub(1), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_sub(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_sub(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer multiplication. Computes `self * rhs`, returning\n`None` if overflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(5\", stringify!($SelfT), \".checked_mul(1), Some(5));\nassert_eq!(\", stringify!($SelfT), \"::max_value().checked_mul(2), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_mul(self, rhs: Self) -> Option<Self> {\n                let (a, b) = self.overflowing_mul(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked integer division. Computes `self / rhs`, returning `None`\nif `rhs == 0`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(128\", stringify!($SelfT), \".checked_div(2), Some(64));\nassert_eq!(1\", stringify!($SelfT), \".checked_div(0), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn checked_div(self, rhs: Self) -> Option<Self> {\n                match rhs {\n                    0 => None,\n                    rhs => Some(unsafe { intrinsics::unchecked_div(self, rhs) }),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked Euclidean division. Computes `self.div_euc(rhs)`, returning `None`\nif `rhs == 0`.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(128\", stringify!($SelfT), \".checked_div(2), Some(64));\nassert_eq!(1\", stringify!($SelfT), \".checked_div_euc(0), None);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn checked_div_euc(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 {\n                    None\n                } else {\n                    Some(self.div_euc(rhs))\n                }\n            }\n        }\n\n\n        doc_comment! {\n            concat!(\"Checked integer remainder. Computes `self % rhs`, returning `None`\nif `rhs == 0`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(5\", stringify!($SelfT), \".checked_rem(2), Some(1));\nassert_eq!(5\", stringify!($SelfT), \".checked_rem(0), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_rem(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 {\n                    None\n                } else {\n                    Some(unsafe { intrinsics::unchecked_rem(self, rhs) })\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked Euclidean modulo. Computes `self.mod_euc(rhs)`, returning `None`\nif `rhs == 0`.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(5\", stringify!($SelfT), \".checked_mod_euc(2), Some(1));\nassert_eq!(5\", stringify!($SelfT), \".checked_mod_euc(0), None);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn checked_mod_euc(self, rhs: Self) -> Option<Self> {\n                if rhs == 0 {\n                    None\n                } else {\n                    Some(self.mod_euc(rhs))\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked negation. Computes `-self`, returning `None` unless `self ==\n0`.\n\nNote that negating any positive integer will overflow.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0\", stringify!($SelfT), \".checked_neg(), Some(0));\nassert_eq!(1\", stringify!($SelfT), \".checked_neg(), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_neg(self) -> Option<Self> {\n                let (a, b) = self.overflowing_neg();\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked shift left. Computes `self << rhs`, returning `None`\nif `rhs` is larger than or equal to the number of bits in `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x1\", stringify!($SelfT), \".checked_shl(4), Some(0x10));\nassert_eq!(0x10\", stringify!($SelfT), \".checked_shl(129), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_shl(self, rhs: u32) -> Option<Self> {\n                let (a, b) = self.overflowing_shl(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked shift right. Computes `self >> rhs`, returning `None`\nif `rhs` is larger than or equal to the number of bits in `self`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(0x10\", stringify!($SelfT), \".checked_shr(4), Some(0x1));\nassert_eq!(0x10\", stringify!($SelfT), \".checked_shr(129), None);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn checked_shr(self, rhs: u32) -> Option<Self> {\n                let (a, b) = self.overflowing_shr(rhs);\n                if b {None} else {Some(a)}\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Checked exponentiation. Computes `self.pow(exp)`, returning `None` if\noverflow occurred.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(2\", stringify!($SelfT), \".checked_pow(5), Some(32));\nassert_eq!(\", stringify!($SelfT), \"::max_value().checked_pow(2), None);\", $EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn checked_pow(self, mut exp: u32) -> Option<Self> {\n                let mut base = self;\n                let mut acc: Self = 1;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        acc = acc.checked_mul(base)?;\n                    }\n                    exp /= 2;\n                    base = base.checked_mul(base)?;\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    acc = acc.checked_mul(base)?;\n                }\n\n                Some(acc)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer addition. Computes `self + rhs`, saturating at\nthe numeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".saturating_add(1), 101);\nassert_eq!(200u8.saturating_add(127), 255);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn saturating_add(self, rhs: Self) -> Self {\n                match self.checked_add(rhs) {\n                    Some(x) => x,\n                    None => Self::max_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer subtraction. Computes `self - rhs`, saturating\nat the numeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".saturating_sub(27), 73);\nassert_eq!(13\", stringify!($SelfT), \".saturating_sub(127), 0);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn saturating_sub(self, rhs: Self) -> Self {\n                match self.checked_sub(rhs) {\n                    Some(x) => x,\n                    None => Self::min_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer multiplication. Computes `self * rhs`,\nsaturating at the numeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(2\", stringify!($SelfT), \".saturating_mul(10), 20);\nassert_eq!((\", stringify!($SelfT), \"::MAX).saturating_mul(10), \", stringify!($SelfT),\n\"::MAX);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[inline]\n            pub fn saturating_mul(self, rhs: Self) -> Self {\n                self.checked_mul(rhs).unwrap_or(Self::max_value())\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Saturating integer exponentiation. Computes `self.pow(exp)`,\nsaturating at the numeric bounds instead of overflowing.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(4\", stringify!($SelfT), \".saturating_pow(3), 64);\nassert_eq!(\", stringify!($SelfT), \"::MAX.saturating_pow(2), \", stringify!($SelfT), \"::MAX);\",\n$EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn saturating_pow(self, exp: u32) -> Self {\n                match self.checked_pow(exp) {\n                    Some(x) => x,\n                    None => Self::max_value(),\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) addition. Computes `self + rhs`,\nwrapping around at the boundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(200\", stringify!($SelfT), \".wrapping_add(55), 255);\nassert_eq!(200\", stringify!($SelfT), \".wrapping_add(\", stringify!($SelfT), \"::max_value()), 199);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_add(self, rhs: Self) -> Self {\n                unsafe {\n                    intrinsics::overflowing_add(self, rhs)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) subtraction. Computes `self - rhs`,\nwrapping around at the boundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_sub(100), 0);\nassert_eq!(100\", stringify!($SelfT), \".wrapping_sub(\", stringify!($SelfT), \"::max_value()), 101);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_sub(self, rhs: Self) -> Self {\n                unsafe {\n                    intrinsics::overflowing_sub(self, rhs)\n                }\n            }\n        }\n\n        /// Wrapping (modular) multiplication. Computes `self *\n        /// rhs`, wrapping around at the boundary of the type.\n        ///\n        /// # Examples\n        ///\n        /// Basic usage:\n        ///\n        /// Please note that this example is shared between integer types.\n        /// Which explains why `u8` is used here.\n        ///\n        /// ```\n        /// assert_eq!(10u8.wrapping_mul(12), 120);\n        /// assert_eq!(25u8.wrapping_mul(12), 44);\n        /// ```\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n        #[inline]\n        pub const fn wrapping_mul(self, rhs: Self) -> Self {\n            unsafe {\n                intrinsics::overflowing_mul(self, rhs)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) division. Computes `self / rhs`.\nWrapped division on unsigned types is just normal division.\nThere's no way wrapping could ever happen.\nThis function exists, so that all operations\nare accounted for in the wrapping operations.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_div(10), 10);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[inline]\n            pub fn wrapping_div(self, rhs: Self) -> Self {\n                self / rhs\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping Euclidean division. Computes `self.div_euc(rhs)`.\nWrapped division on unsigned types is just normal division.\nThere's no way wrapping could ever happen.\nThis function exists, so that all operations\nare accounted for in the wrapping operations.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(100\", stringify!($SelfT), \".wrapping_div_euc(10), 10);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn wrapping_div_euc(self, rhs: Self) -> Self {\n                self / rhs\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) remainder. Computes `self % rhs`.\nWrapped remainder calculation on unsigned types is\njust the regular remainder calculation.\nThere's no way wrapping could ever happen.\nThis function exists, so that all operations\nare accounted for in the wrapping operations.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(100\", stringify!($SelfT), \".wrapping_rem(10), 0);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[inline]\n            pub fn wrapping_rem(self, rhs: Self) -> Self {\n                self % rhs\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping Euclidean modulo. Computes `self.mod_euc(rhs)`.\nWrapped modulo calculation on unsigned types is\njust the regular remainder calculation.\nThere's no way wrapping could ever happen.\nThis function exists, so that all operations\nare accounted for in the wrapping operations.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(100\", stringify!($SelfT), \".wrapping_mod_euc(10), 0);\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            pub fn wrapping_mod_euc(self, rhs: Self) -> Self {\n                self % rhs\n            }\n        }\n\n        /// Wrapping (modular) negation. Computes `-self`,\n        /// wrapping around at the boundary of the type.\n        ///\n        /// Since unsigned types do not have negative equivalents\n        /// all applications of this function will wrap (except for `-0`).\n        /// For values smaller than the corresponding signed type's maximum\n        /// the result is the same as casting the corresponding signed value.\n        /// Any larger values are equivalent to `MAX + 1 - (val - MAX - 1)` where\n        /// `MAX` is the corresponding signed type's maximum.\n        ///\n        /// # Examples\n        ///\n        /// Basic usage:\n        ///\n        /// Please note that this example is shared between integer types.\n        /// Which explains why `i8` is used here.\n        ///\n        /// ```\n        /// assert_eq!(100i8.wrapping_neg(), -100);\n        /// assert_eq!((-128i8).wrapping_neg(), -128);\n        /// ```\n        #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n        #[inline]\n        pub fn wrapping_neg(self) -> Self {\n            self.overflowing_neg().0\n        }\n\n        doc_comment! {\n            concat!(\"Panic-free bitwise shift-left; yields `self << mask(rhs)`,\nwhere `mask` removes any high-order bits of `rhs` that\nwould cause the shift to exceed the bitwidth of the type.\n\nNote that this is *not* the same as a rotate-left; the\nRHS of a wrapping shift-left is restricted to the range\nof the type, rather than the bits shifted out of the LHS\nbeing returned to the other end. The primitive integer\ntypes all implement a `rotate_left` function, which may\nbe what you want instead.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(1\", stringify!($SelfT), \".wrapping_shl(7), 128);\nassert_eq!(1\", stringify!($SelfT), \".wrapping_shl(128), 1);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_shl(self, rhs: u32) -> Self {\n                unsafe {\n                    intrinsics::unchecked_shl(self, (rhs & ($BITS - 1)) as $SelfT)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Panic-free bitwise shift-right; yields `self >> mask(rhs)`,\nwhere `mask` removes any high-order bits of `rhs` that\nwould cause the shift to exceed the bitwidth of the type.\n\nNote that this is *not* the same as a rotate-right; the\nRHS of a wrapping shift-right is restricted to the range\nof the type, rather than the bits shifted out of the LHS\nbeing returned to the other end. The primitive integer\ntypes all implement a `rotate_right` function, which may\nbe what you want instead.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(128\", stringify!($SelfT), \".wrapping_shr(7), 1);\nassert_eq!(128\", stringify!($SelfT), \".wrapping_shr(128), 128);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"num_wrapping\", since = \"1.2.0\")]\n            #[rustc_const_unstable(feature = \"const_int_wrapping\")]\n            #[inline]\n            pub const fn wrapping_shr(self, rhs: u32) -> Self {\n                unsafe {\n                    intrinsics::unchecked_shr(self, (rhs & ($BITS - 1)) as $SelfT)\n                }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Wrapping (modular) exponentiation. Computes `self.pow(exp)`,\nwrapping around at the boundary of the type.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(3\", stringify!($SelfT), \".wrapping_pow(5), 243);\nassert_eq!(3u8.wrapping_pow(6), 217);\", $EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn wrapping_pow(self, mut exp: u32) -> Self {\n                let mut base = self;\n                let mut acc: Self = 1;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        acc = acc.wrapping_mul(base);\n                    }\n                    exp /= 2;\n                    base = base.wrapping_mul(base);\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    acc = acc.wrapping_mul(base);\n                }\n\n                acc\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates `self` + `rhs`\n\nReturns a tuple of the addition along with a boolean indicating\nwhether an arithmetic overflow would occur. If an overflow would\nhave occurred then the wrapped value is returned.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_add(2), (7, false));\nassert_eq!(\", stringify!($SelfT), \"::MAX.overflowing_add(1), (0, true));\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_add(self, rhs: Self) -> (Self, bool) {\n                let (a, b) = unsafe {\n                    intrinsics::add_with_overflow(self as $ActualT,\n                                                  rhs as $ActualT)\n                };\n                (a as Self, b)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates `self` - `rhs`\n\nReturns a tuple of the subtraction along with a boolean indicating\nwhether an arithmetic overflow would occur. If an overflow would\nhave occurred then the wrapped value is returned.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"use std::\", stringify!($SelfT), \";\n\nassert_eq!(5\", stringify!($SelfT), \".overflowing_sub(2), (3, false));\nassert_eq!(0\", stringify!($SelfT), \".overflowing_sub(1), (\", stringify!($SelfT), \"::MAX, true));\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool) {\n                let (a, b) = unsafe {\n                    intrinsics::sub_with_overflow(self as $ActualT,\n                                                  rhs as $ActualT)\n                };\n                (a as Self, b)\n            }\n        }\n\n        /// Calculates the multiplication of `self` and `rhs`.\n        ///\n        /// Returns a tuple of the multiplication along with a boolean\n        /// indicating whether an arithmetic overflow would occur. If an\n        /// overflow would have occurred then the wrapped value is returned.\n        ///\n        /// # Examples\n        ///\n        /// Basic usage:\n        ///\n        /// Please note that this example is shared between integer types.\n        /// Which explains why `u32` is used here.\n        ///\n        /// ```\n        /// assert_eq!(5u32.overflowing_mul(2), (10, false));\n        /// assert_eq!(1_000_000_000u32.overflowing_mul(10), (1410065408, true));\n        /// ```\n        #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n        #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n        #[inline]\n        pub const fn overflowing_mul(self, rhs: Self) -> (Self, bool) {\n            let (a, b) = unsafe {\n                intrinsics::mul_with_overflow(self as $ActualT,\n                                              rhs as $ActualT)\n            };\n            (a as Self, b)\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the divisor when `self` is divided by `rhs`.\n\nReturns a tuple of the divisor along with a boolean indicating\nwhether an arithmetic overflow would occur. Note that for unsigned\nintegers overflow never occurs, so the second value is always\n`false`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"assert_eq!(5\", stringify!($SelfT), \".overflowing_div(2), (2, false));\", $EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_div(self, rhs: Self) -> (Self, bool) {\n                (self / rhs, false)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the quotient of Euclidean division `self.div_euc(rhs)`.\n\nReturns a tuple of the divisor along with a boolean indicating\nwhether an arithmetic overflow would occur. Note that for unsigned\nintegers overflow never occurs, so the second value is always\n`false`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage\n\n```\n#![feature(euclidean_division)]\nassert_eq!(5\", stringify!($SelfT), \".overflowing_div_euc(2), (2, false));\n```\"),\n            #[inline]\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            pub fn overflowing_div_euc(self, rhs: Self) -> (Self, bool) {\n                (self / rhs, false)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the remainder when `self` is divided by `rhs`.\n\nReturns a tuple of the remainder after dividing along with a boolean\nindicating whether an arithmetic overflow would occur. Note that for\nunsigned integers overflow never occurs, so the second value is\nalways `false`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"assert_eq!(5\", stringify!($SelfT), \".overflowing_rem(2), (1, false));\", $EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_rem(self, rhs: Self) -> (Self, bool) {\n                (self % rhs, false)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Calculates the remainder `self.mod_euc(rhs)` by Euclidean division.\n\nReturns a tuple of the modulo after dividing along with a boolean\nindicating whether an arithmetic overflow would occur. Note that for\nunsigned integers overflow never occurs, so the second value is\nalways `false`.\n\n# Panics\n\nThis function will panic if `rhs` is 0.\n\n# Examples\n\nBasic usage\n\n```\n#![feature(euclidean_division)]\nassert_eq!(5\", stringify!($SelfT), \".overflowing_mod_euc(2), (1, false));\n```\"),\n            #[inline]\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            pub fn overflowing_mod_euc(self, rhs: Self) -> (Self, bool) {\n                (self % rhs, false)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Negates self in an overflowing fashion.\n\nReturns `!self + 1` using wrapping operations to return the value\nthat represents the negation of this unsigned value. Note that for\npositive unsigned values overflow always occurs, but negating 0 does\nnot overflow.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"assert_eq!(0\", stringify!($SelfT), \".overflowing_neg(), (0, false));\nassert_eq!(2\", stringify!($SelfT), \".overflowing_neg(), (-2i32 as \", stringify!($SelfT),\n\", true));\", $EndFeature, \"\n```\"),\n            #[inline]\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            pub fn overflowing_neg(self) -> (Self, bool) {\n                ((!self).wrapping_add(1), self != 0)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts self left by `rhs` bits.\n\nReturns a tuple of the shifted version of self along with a boolean\nindicating whether the shift value was larger than or equal to the\nnumber of bits. If the shift value is too large, then value is\nmasked (N-1) where N is the number of bits, and this value is then\nused to perform the shift.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"assert_eq!(0x1\", stringify!($SelfT), \".overflowing_shl(4), (0x10, false));\nassert_eq!(0x1\", stringify!($SelfT), \".overflowing_shl(132), (0x10, true));\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_shl(self, rhs: u32) -> (Self, bool) {\n                (self.wrapping_shl(rhs), (rhs > ($BITS - 1)))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Shifts self right by `rhs` bits.\n\nReturns a tuple of the shifted version of self along with a boolean\nindicating whether the shift value was larger than or equal to the\nnumber of bits. If the shift value is too large, then value is\nmasked (N-1) where N is the number of bits, and this value is then\nused to perform the shift.\n\n# Examples\n\nBasic usage\n\n```\n\", $Feature, \"assert_eq!(0x10\", stringify!($SelfT), \".overflowing_shr(4), (0x1, false));\nassert_eq!(0x10\", stringify!($SelfT), \".overflowing_shr(132), (0x1, true));\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"wrapping\", since = \"1.7.0\")]\n            #[rustc_const_unstable(feature = \"const_int_overflowing\")]\n            #[inline]\n            pub const fn overflowing_shr(self, rhs: u32) -> (Self, bool) {\n                (self.wrapping_shr(rhs), (rhs > ($BITS - 1)))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Raises self to the power of `exp`, using exponentiation by squaring.\n\nReturns a tuple of the exponentiation along with a bool indicating\nwhether an overflow happened.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(no_panic_pow)]\n\", $Feature, \"assert_eq!(3\", stringify!($SelfT), \".overflowing_pow(5), (243, false));\nassert_eq!(3u8.overflowing_pow(6), (217, true));\", $EndFeature, \"\n```\"),\n            #[unstable(feature = \"no_panic_pow\", issue = \"48320\")]\n            #[inline]\n            pub fn overflowing_pow(self, mut exp: u32) -> (Self, bool) {\n                let mut base = self;\n                let mut acc: Self = 1;\n                let mut overflown = false;\n                // Scratch space for storing results of overflowing_mul.\n                let mut r;\n\n                while exp > 1 {\n                    if (exp & 1) == 1 {\n                        r = acc.overflowing_mul(base);\n                        acc = r.0;\n                        overflown |= r.1;\n                    }\n                    exp /= 2;\n                    r = base.overflowing_mul(base);\n                    base = r.0;\n                    overflown |= r.1;\n                }\n\n                // Deal with the final bit of the exponent separately, since\n                // squaring the base afterwards is not necessary and may cause a\n                // needless overflow.\n                if exp == 1 {\n                    r = acc.overflowing_mul(base);\n                    acc = r.0;\n                    overflown |= r.1;\n                }\n\n                (acc, overflown)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Raises self to the power of `exp`, using exponentiation by squaring.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(2\", stringify!($SelfT), \".pow(5), 32);\", $EndFeature, \"\n```\"),\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        #[inline]\n        #[rustc_inherit_overflow_checks]\n        pub fn pow(self, mut exp: u32) -> Self {\n            let mut base = self;\n            let mut acc = 1;\n\n            while exp > 1 {\n                if (exp & 1) == 1 {\n                    acc = acc * base;\n                }\n                exp /= 2;\n                base = base * base;\n            }\n\n            // Deal with the final bit of the exponent separately, since\n            // squaring the base afterwards is not necessary and may cause a\n            // needless overflow.\n            if exp == 1 {\n                acc = acc * base;\n            }\n\n            acc\n        }\n    }\n\n            doc_comment! {\n            concat!(\"Performs Euclidean division.\n\nFor unsigned types, this is just the same as `self / rhs`.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(7\", stringify!($SelfT), \".div_euc(4), 1); // or any other integer type\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn div_euc(self, rhs: Self) -> Self {\n                self / rhs\n            }\n        }\n\n\n        doc_comment! {\n            concat!(\"Calculates the remainder `self mod rhs` by Euclidean division.\n\nFor unsigned types, this is just the same as `self % rhs`.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(euclidean_division)]\nassert_eq!(7\", stringify!($SelfT), \".mod_euc(4), 3); // or any other integer type\n```\"),\n            #[unstable(feature = \"euclidean_division\", issue = \"49048\")]\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            pub fn mod_euc(self, rhs: Self) -> Self {\n                self % rhs\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns `true` if and only if `self == 2^k` for some `k`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert!(16\", stringify!($SelfT), \".is_power_of_two());\nassert!(!10\", stringify!($SelfT), \".is_power_of_two());\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn is_power_of_two(self) -> bool {\n                (self.wrapping_sub(1)) & self == 0 && !(self == 0)\n            }\n        }\n\n        // Returns one less than next power of two.\n        // (For 8u8 next power of two is 8u8 and for 6u8 it is 8u8)\n        //\n        // 8u8.one_less_than_next_power_of_two() == 7\n        // 6u8.one_less_than_next_power_of_two() == 7\n        //\n        // This method cannot overflow, as in the `next_power_of_two`\n        // overflow cases it instead ends up returning the maximum value\n        // of the type, and can return 0 for 0.\n        #[inline]\n        fn one_less_than_next_power_of_two(self) -> Self {\n            if self <= 1 { return 0; }\n\n            // Because `p > 0`, it cannot consist entirely of leading zeros.\n            // That means the shift is always in-bounds, and some processors\n            // (such as intel pre-haswell) have more efficient ctlz\n            // intrinsics when the argument is non-zero.\n            let p = self - 1;\n            let z = unsafe { intrinsics::ctlz_nonzero(p) };\n            <$SelfT>::max_value() >> z\n        }\n\n        doc_comment! {\n            concat!(\"Returns the smallest power of two greater than or equal to `self`.\n\nWhen return value overflows (i.e. `self > (1 << (N-1))` for type\n`uN`), it panics in debug mode and return value is wrapped to 0 in\nrelease mode (the only situation in which method can return 0).\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(2\", stringify!($SelfT), \".next_power_of_two(), 2);\nassert_eq!(3\", stringify!($SelfT), \".next_power_of_two(), 4);\", $EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            #[inline]\n            pub fn next_power_of_two(self) -> Self {\n                // Call the trait to get overflow checks\n                ops::Add::add(self.one_less_than_next_power_of_two(), 1)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the smallest power of two greater than or equal to `n`. If\nthe next power of two is greater than the type's maximum value,\n`None` is returned, otherwise the power of two is wrapped in `Some`.\n\n# Examples\n\nBasic usage:\n\n```\n\", $Feature, \"assert_eq!(2\", stringify!($SelfT),\n\".checked_next_power_of_two(), Some(2));\nassert_eq!(3\", stringify!($SelfT), \".checked_next_power_of_two(), Some(4));\nassert_eq!(\", stringify!($SelfT), \"::max_value().checked_next_power_of_two(), None);\",\n$EndFeature, \"\n```\"),\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            pub fn checked_next_power_of_two(self) -> Option<Self> {\n                self.one_less_than_next_power_of_two().checked_add(1)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Returns the smallest power of two greater than or equal to `n`. If\nthe next power of two is greater than the type's maximum value,\nthe return value is wrapped to `0`.\n\n# Examples\n\nBasic usage:\n\n```\n#![feature(wrapping_next_power_of_two)]\n\", $Feature, \"\nassert_eq!(2\", stringify!($SelfT), \".wrapping_next_power_of_two(), 2);\nassert_eq!(3\", stringify!($SelfT), \".wrapping_next_power_of_two(), 4);\nassert_eq!(\", stringify!($SelfT), \"::max_value().wrapping_next_power_of_two(), 0);\",\n$EndFeature, \"\n```\"),\n            #[unstable(feature = \"wrapping_next_power_of_two\", issue = \"32463\",\n                       reason = \"needs decision on wrapping behaviour\")]\n            pub fn wrapping_next_power_of_two(self) -> Self {\n                self.one_less_than_next_power_of_two().wrapping_add(1)\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Return the memory representation of this integer as a byte array in\nbig-endian (network) byte order.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_be_bytes();\nassert_eq!(bytes, \", $be_bytes, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_be_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                self.to_be().to_ne_bytes()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Return the memory representation of this integer as a byte array in\nlittle-endian byte order.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_le_bytes();\nassert_eq!(bytes, \", $le_bytes, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_le_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                self.to_le().to_ne_bytes()\n            }\n        }\n\n        doc_comment! {\n            concat!(\"\nReturn the memory representation of this integer as a byte array in\nnative byte order.\n\nAs the target platform's native endianness is used, portable code\nshould use [`to_be_bytes`] or [`to_le_bytes`], as appropriate,\ninstead.\n\n[`to_be_bytes`]: #method.to_be_bytes\n[`to_le_bytes`]: #method.to_le_bytes\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet bytes = \", $swap_op, stringify!($SelfT), \".to_ne_bytes();\nassert_eq!(bytes, if cfg!(target_endian = \\\"big\\\") {\n        \", $be_bytes, \"\n    } else {\n        \", $le_bytes, \"\n    });\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn to_ne_bytes(self) -> [u8; mem::size_of::<Self>()] {\n                unsafe { mem::transmute(self) }\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Create an integer value from its representation as a byte array in\nbig endian.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_be_bytes(\", $be_bytes, \");\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_be_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                Self::from_be(Self::from_ne_bytes(bytes))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"\nCreate an integer value from its representation as a byte array in\nlittle endian.\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_le_bytes(\", $le_bytes, \");\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_le_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                Self::from_le(Self::from_ne_bytes(bytes))\n            }\n        }\n\n        doc_comment! {\n            concat!(\"Create an integer value from its memory representation as a byte\narray in native endianness.\n\nAs the target platform's native endianness is used, portable code\nlikely wants to use [`from_be_bytes`] or [`from_le_bytes`], as\nappropriate instead.\n\n[`from_be_bytes`]: #method.from_be_bytes\n[`from_le_bytes`]: #method.from_le_bytes\n\n# Examples\n\n```\n#![feature(int_to_from_bytes)]\n\nlet value = \", stringify!($SelfT), \"::from_ne_bytes(if cfg!(target_endian = \\\"big\\\") {\n        \", $be_bytes, \"\n    } else {\n        \", $le_bytes, \"\n    });\nassert_eq!(value, \", $swap_op, \");\n```\"),\n            #[unstable(feature = \"int_to_from_bytes\", issue = \"52963\")]\n            #[rustc_const_unstable(feature = \"const_int_conversion\")]\n            #[inline]\n            pub const fn from_ne_bytes(bytes: [u8; mem::size_of::<Self>()]) -> Self {\n                unsafe { mem::transmute(bytes) }\n            }\n        }\n    }\n}\n\n#[lang = \"u8\"]\nimpl u8 {\n    uint_impl! { u8, u8, 8, 255, \"\", \"\", 2, \"0x82\", \"0xa\", \"0x12\", \"0x12\", \"0x48\", \"[0x12]\",\n        \"[0x12]\" }\n\n\n    /// Checks if the value is within the ASCII range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let ascii = 97u8;\n    /// let non_ascii = 150u8;\n    ///\n    /// assert!(ascii.is_ascii());\n    /// assert!(!non_ascii.is_ascii());\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn is_ascii(&self) -> bool {\n        *self & 128 == 0\n    }\n\n    /// Makes a copy of the value in its ASCII upper case equivalent.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To uppercase the value in-place, use [`make_ascii_uppercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let lowercase_a = 97u8;\n    ///\n    /// assert_eq!(65, lowercase_a.to_ascii_uppercase());\n    /// ```\n    ///\n    /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_uppercase(&self) -> u8 {\n        ASCII_UPPERCASE_MAP[*self as usize]\n    }\n\n    /// Makes a copy of the value in its ASCII lower case equivalent.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To lowercase the value in-place, use [`make_ascii_lowercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 65u8;\n    ///\n    /// assert_eq!(97, uppercase_a.to_ascii_lowercase());\n    /// ```\n    ///\n    /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_lowercase(&self) -> u8 {\n        ASCII_LOWERCASE_MAP[*self as usize]\n    }\n\n    /// Checks that two values are an ASCII case-insensitive match.\n    ///\n    /// This is equivalent to `to_ascii_lowercase(a) == to_ascii_lowercase(b)`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let lowercase_a = 97u8;\n    /// let uppercase_a = 65u8;\n    ///\n    /// assert!(lowercase_a.eq_ignore_ascii_case(&uppercase_a));\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn eq_ignore_ascii_case(&self, other: &u8) -> bool {\n        self.to_ascii_lowercase() == other.to_ascii_lowercase()\n    }\n\n    /// Converts this value to its ASCII upper case equivalent in-place.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new uppercased value without modifying the existing one, use\n    /// [`to_ascii_uppercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut byte = b'a';\n    ///\n    /// byte.make_ascii_uppercase();\n    ///\n    /// assert_eq!(b'A', byte);\n    /// ```\n    ///\n    /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_uppercase(&mut self) {\n        *self = self.to_ascii_uppercase();\n    }\n\n    /// Converts this value to its ASCII lower case equivalent in-place.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new lowercased value without modifying the existing one, use\n    /// [`to_ascii_lowercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut byte = b'A';\n    ///\n    /// byte.make_ascii_lowercase();\n    ///\n    /// assert_eq!(b'a', byte);\n    /// ```\n    ///\n    /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_lowercase(&mut self) {\n        *self = self.to_ascii_lowercase();\n    }\n\n    /// Checks if the value is an ASCII alphabetic character:\n    ///\n    /// - U+0041 'A' ... U+005A 'Z', or\n    /// - U+0061 'a' ... U+007A 'z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(uppercase_a.is_ascii_alphabetic());\n    /// assert!(uppercase_g.is_ascii_alphabetic());\n    /// assert!(a.is_ascii_alphabetic());\n    /// assert!(g.is_ascii_alphabetic());\n    /// assert!(!zero.is_ascii_alphabetic());\n    /// assert!(!percent.is_ascii_alphabetic());\n    /// assert!(!space.is_ascii_alphabetic());\n    /// assert!(!lf.is_ascii_alphabetic());\n    /// assert!(!esc.is_ascii_alphabetic());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_alphabetic(&self) -> bool {\n        if *self >= 0x80 { return false; }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            L | Lx | U | Ux => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII uppercase character:\n    /// U+0041 'A' ... U+005A 'Z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(uppercase_a.is_ascii_uppercase());\n    /// assert!(uppercase_g.is_ascii_uppercase());\n    /// assert!(!a.is_ascii_uppercase());\n    /// assert!(!g.is_ascii_uppercase());\n    /// assert!(!zero.is_ascii_uppercase());\n    /// assert!(!percent.is_ascii_uppercase());\n    /// assert!(!space.is_ascii_uppercase());\n    /// assert!(!lf.is_ascii_uppercase());\n    /// assert!(!esc.is_ascii_uppercase());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_uppercase(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            U | Ux => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII lowercase character:\n    /// U+0061 'a' ... U+007A 'z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(!uppercase_a.is_ascii_lowercase());\n    /// assert!(!uppercase_g.is_ascii_lowercase());\n    /// assert!(a.is_ascii_lowercase());\n    /// assert!(g.is_ascii_lowercase());\n    /// assert!(!zero.is_ascii_lowercase());\n    /// assert!(!percent.is_ascii_lowercase());\n    /// assert!(!space.is_ascii_lowercase());\n    /// assert!(!lf.is_ascii_lowercase());\n    /// assert!(!esc.is_ascii_lowercase());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_lowercase(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            L | Lx => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII alphanumeric character:\n    ///\n    /// - U+0041 'A' ... U+005A 'Z', or\n    /// - U+0061 'a' ... U+007A 'z', or\n    /// - U+0030 '0' ... U+0039 '9'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(uppercase_a.is_ascii_alphanumeric());\n    /// assert!(uppercase_g.is_ascii_alphanumeric());\n    /// assert!(a.is_ascii_alphanumeric());\n    /// assert!(g.is_ascii_alphanumeric());\n    /// assert!(zero.is_ascii_alphanumeric());\n    /// assert!(!percent.is_ascii_alphanumeric());\n    /// assert!(!space.is_ascii_alphanumeric());\n    /// assert!(!lf.is_ascii_alphanumeric());\n    /// assert!(!esc.is_ascii_alphanumeric());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_alphanumeric(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            D | L | Lx | U | Ux => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII decimal digit:\n    /// U+0030 '0' ... U+0039 '9'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(!uppercase_a.is_ascii_digit());\n    /// assert!(!uppercase_g.is_ascii_digit());\n    /// assert!(!a.is_ascii_digit());\n    /// assert!(!g.is_ascii_digit());\n    /// assert!(zero.is_ascii_digit());\n    /// assert!(!percent.is_ascii_digit());\n    /// assert!(!space.is_ascii_digit());\n    /// assert!(!lf.is_ascii_digit());\n    /// assert!(!esc.is_ascii_digit());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_digit(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            D => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII hexadecimal digit:\n    ///\n    /// - U+0030 '0' ... U+0039 '9', or\n    /// - U+0041 'A' ... U+0046 'F', or\n    /// - U+0061 'a' ... U+0066 'f'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(uppercase_a.is_ascii_hexdigit());\n    /// assert!(!uppercase_g.is_ascii_hexdigit());\n    /// assert!(a.is_ascii_hexdigit());\n    /// assert!(!g.is_ascii_hexdigit());\n    /// assert!(zero.is_ascii_hexdigit());\n    /// assert!(!percent.is_ascii_hexdigit());\n    /// assert!(!space.is_ascii_hexdigit());\n    /// assert!(!lf.is_ascii_hexdigit());\n    /// assert!(!esc.is_ascii_hexdigit());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_hexdigit(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            D | Lx | Ux => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII punctuation character:\n    ///\n    /// - U+0021 ... U+002F `! \" # $ % & ' ( ) * + , - . /`, or\n    /// - U+003A ... U+0040 `: ; < = > ? @`, or\n    /// - U+005B ... U+0060 ``[ \\ ] ^ _ ` ``, or\n    /// - U+007B ... U+007E `{ | } ~`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(!uppercase_a.is_ascii_punctuation());\n    /// assert!(!uppercase_g.is_ascii_punctuation());\n    /// assert!(!a.is_ascii_punctuation());\n    /// assert!(!g.is_ascii_punctuation());\n    /// assert!(!zero.is_ascii_punctuation());\n    /// assert!(percent.is_ascii_punctuation());\n    /// assert!(!space.is_ascii_punctuation());\n    /// assert!(!lf.is_ascii_punctuation());\n    /// assert!(!esc.is_ascii_punctuation());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_punctuation(&self) -> bool {\n        if *self >= 0x80 { return false }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            P => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII graphic character:\n    /// U+0021 '!' ... U+007E '~'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(uppercase_a.is_ascii_graphic());\n    /// assert!(uppercase_g.is_ascii_graphic());\n    /// assert!(a.is_ascii_graphic());\n    /// assert!(g.is_ascii_graphic());\n    /// assert!(zero.is_ascii_graphic());\n    /// assert!(percent.is_ascii_graphic());\n    /// assert!(!space.is_ascii_graphic());\n    /// assert!(!lf.is_ascii_graphic());\n    /// assert!(!esc.is_ascii_graphic());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_graphic(&self) -> bool {\n        if *self >= 0x80 { return false; }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            Ux | U | Lx | L | D | P => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII whitespace character:\n    /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,\n    /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.\n    ///\n    /// Rust uses the WhatWG Infra Standard's [definition of ASCII\n    /// whitespace][infra-aw]. There are several other definitions in\n    /// wide use. For instance, [the POSIX locale][pct] includes\n    /// U+000B VERTICAL TAB as well as all the above characters,\n    /// but\u2014from the very same specification\u2014[the default rule for\n    /// \"field splitting\" in the Bourne shell][bfs] considers *only*\n    /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.\n    ///\n    /// If you are writing a program that will process an existing\n    /// file format, check what that format's definition of whitespace is\n    /// before using this function.\n    ///\n    /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace\n    /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01\n    /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(!uppercase_a.is_ascii_whitespace());\n    /// assert!(!uppercase_g.is_ascii_whitespace());\n    /// assert!(!a.is_ascii_whitespace());\n    /// assert!(!g.is_ascii_whitespace());\n    /// assert!(!zero.is_ascii_whitespace());\n    /// assert!(!percent.is_ascii_whitespace());\n    /// assert!(space.is_ascii_whitespace());\n    /// assert!(lf.is_ascii_whitespace());\n    /// assert!(!esc.is_ascii_whitespace());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_whitespace(&self) -> bool {\n        if *self >= 0x80 { return false; }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            Cw | W => true,\n            _ => false\n        }\n    }\n\n    /// Checks if the value is an ASCII control character:\n    /// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.\n    /// Note that most ASCII whitespace characters are control\n    /// characters, but SPACE is not.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = b'A';\n    /// let uppercase_g = b'G';\n    /// let a = b'a';\n    /// let g = b'g';\n    /// let zero = b'0';\n    /// let percent = b'%';\n    /// let space = b' ';\n    /// let lf = b'\\n';\n    /// let esc = 0x1b_u8;\n    ///\n    /// assert!(!uppercase_a.is_ascii_control());\n    /// assert!(!uppercase_g.is_ascii_control());\n    /// assert!(!a.is_ascii_control());\n    /// assert!(!g.is_ascii_control());\n    /// assert!(!zero.is_ascii_control());\n    /// assert!(!percent.is_ascii_control());\n    /// assert!(!space.is_ascii_control());\n    /// assert!(lf.is_ascii_control());\n    /// assert!(esc.is_ascii_control());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_control(&self) -> bool {\n        if *self >= 0x80 { return false; }\n        match ASCII_CHARACTER_CLASS[*self as usize] {\n            C | Cw => true,\n            _ => false\n        }\n    }\n}\n\n#[lang = \"u16\"]\nimpl u16 {\n    uint_impl! { u16, u16, 16, 65535, \"\", \"\", 4, \"0xa003\", \"0x3a\", \"0x1234\", \"0x3412\", \"0x2c48\",\n        \"[0x34, 0x12]\", \"[0x12, 0x34]\" }\n}\n\n#[lang = \"u32\"]\nimpl u32 {\n    uint_impl! { u32, u32, 32, 4294967295, \"\", \"\", 8, \"0x10000b3\", \"0xb301\", \"0x12345678\",\n        \"0x78563412\", \"0x1e6a2c48\", \"[0x78, 0x56, 0x34, 0x12]\", \"[0x12, 0x34, 0x56, 0x78]\" }\n}\n\n#[lang = \"u64\"]\nimpl u64 {\n    uint_impl! { u64, u64, 64, 18446744073709551615, \"\", \"\", 12, \"0xaa00000000006e1\", \"0x6e10aa\",\n        \"0x1234567890123456\", \"0x5634129078563412\", \"0x6a2c48091e6a2c48\",\n        \"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n        \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]\" }\n}\n\n#[lang = \"u128\"]\nimpl u128 {\n    uint_impl! { u128, u128, 128, 340282366920938463463374607431768211455, \"\", \"\", 16,\n        \"0x13f40000000000000000000000004f76\", \"0x4f7613f4\", \"0x12345678901234567890123456789012\",\n        \"0x12907856341290785634129078563412\", \"0x48091e6a2c48091e6a2c48091e6a2c48\",\n        \"[0x12, 0x90, 0x78, 0x56, 0x34, 0x12, 0x90, 0x78, \\\n          0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n        \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56, \\\n          0x78, 0x90, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12]\" }\n}\n\n#[cfg(target_pointer_width = \"16\")]\n#[lang = \"usize\"]\nimpl usize {\n    uint_impl! { usize, u16, 16, 65536, \"\", \"\", 4, \"0xa003\", \"0x3a\", \"0x1234\", \"0x3412\", \"0x2c48\",\n        \"[0x34, 0x12]\", \"[0x12, 0x34]\" }\n}\n#[cfg(target_pointer_width = \"32\")]\n#[lang = \"usize\"]\nimpl usize {\n    uint_impl! { usize, u32, 32, 4294967295, \"\", \"\", 8, \"0x10000b3\", \"0xb301\", \"0x12345678\",\n        \"0x78563412\", \"0x1e6a2c48\", \"[0x78, 0x56, 0x34, 0x12]\", \"[0x12, 0x34, 0x56, 0x78]\" }\n}\n\n#[cfg(target_pointer_width = \"64\")]\n#[lang = \"usize\"]\nimpl usize {\n    uint_impl! { usize, u64, 64, 18446744073709551615, \"\", \"\", 12, \"0xaa00000000006e1\", \"0x6e10aa\",\n        \"0x1234567890123456\", \"0x5634129078563412\", \"0x6a2c48091e6a2c48\",\n        \"[0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]\",\n         \"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]\" }\n}\n\n/// A classification of floating point numbers.\n///\n/// This `enum` is used as the return type for [`f32::classify`] and [`f64::classify`]. See\n/// their documentation for more.\n///\n/// [`f32::classify`]: ../../std/primitive.f32.html#method.classify\n/// [`f64::classify`]: ../../std/primitive.f64.html#method.classify\n///\n/// # Examples\n///\n/// ```\n/// use std::num::FpCategory;\n/// use std::f32;\n///\n/// let num = 12.4_f32;\n/// let inf = f32::INFINITY;\n/// let zero = 0f32;\n/// let sub: f32 = 1.1754942e-38;\n/// let nan = f32::NAN;\n///\n/// assert_eq!(num.classify(), FpCategory::Normal);\n/// assert_eq!(inf.classify(), FpCategory::Infinite);\n/// assert_eq!(zero.classify(), FpCategory::Zero);\n/// assert_eq!(nan.classify(), FpCategory::Nan);\n/// assert_eq!(sub.classify(), FpCategory::Subnormal);\n/// ```\n#[derive(Copy, Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum FpCategory {\n    /// \"Not a Number\", often obtained by dividing by zero.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Nan,\n\n    /// Positive or negative infinity.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Infinite,\n\n    /// Positive or negative zero.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Zero,\n\n    /// De-normalized floating point representation (less precise than `Normal`).\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Subnormal,\n\n    /// A regular floating point number.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Normal,\n}\n\nmacro_rules! from_str_radix_int_impl {\n    ($($t:ty)*) => {$(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl FromStr for $t {\n            type Err = ParseIntError;\n            fn from_str(src: &str) -> Result<Self, ParseIntError> {\n                from_str_radix(src, 10)\n            }\n        }\n    )*}\n}\nfrom_str_radix_int_impl! { isize i8 i16 i32 i64 i128 usize u8 u16 u32 u64 u128 }\n\n/// The error type returned when a checked integral type conversion fails.\n#[unstable(feature = \"try_from\", issue = \"33417\")]\n#[derive(Debug, Copy, Clone, PartialEq, Eq)]\npub struct TryFromIntError(());\n\nimpl TryFromIntError {\n    #[unstable(feature = \"int_error_internals\",\n               reason = \"available through Error trait and this method should \\\n                         not be exposed publicly\",\n               issue = \"0\")]\n    #[doc(hidden)]\n    pub fn __description(&self) -> &str {\n        \"out of range integral type conversion attempted\"\n    }\n}\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl fmt::Display for TryFromIntError {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        self.__description().fmt(fmt)\n    }\n}\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl From<!> for TryFromIntError {\n    fn from(never: !) -> TryFromIntError {\n        never\n    }\n}\n\n// no possible bounds violation\nmacro_rules! try_from_unbounded {\n    ($source:ty, $($target:ty),*) => {$(\n        #[unstable(feature = \"try_from\", issue = \"33417\")]\n        impl TryFrom<$source> for $target {\n            type Error = TryFromIntError;\n\n            #[inline]\n            fn try_from(value: $source) -> Result<Self, Self::Error> {\n                Ok(value as $target)\n            }\n        }\n    )*}\n}\n\n// only negative bounds\nmacro_rules! try_from_lower_bounded {\n    ($source:ty, $($target:ty),*) => {$(\n        #[unstable(feature = \"try_from\", issue = \"33417\")]\n        impl TryFrom<$source> for $target {\n            type Error = TryFromIntError;\n\n            #[inline]\n            fn try_from(u: $source) -> Result<$target, TryFromIntError> {\n                if u >= 0 {\n                    Ok(u as $target)\n                } else {\n                    Err(TryFromIntError(()))\n                }\n            }\n        }\n    )*}\n}\n\n// unsigned to signed (only positive bound)\nmacro_rules! try_from_upper_bounded {\n    ($source:ty, $($target:ty),*) => {$(\n        #[unstable(feature = \"try_from\", issue = \"33417\")]\n        impl TryFrom<$source> for $target {\n            type Error = TryFromIntError;\n\n            #[inline]\n            fn try_from(u: $source) -> Result<$target, TryFromIntError> {\n                if u > (<$target>::max_value() as $source) {\n                    Err(TryFromIntError(()))\n                } else {\n                    Ok(u as $target)\n                }\n            }\n        }\n    )*}\n}\n\n// all other cases\nmacro_rules! try_from_both_bounded {\n    ($source:ty, $($target:ty),*) => {$(\n        #[unstable(feature = \"try_from\", issue = \"33417\")]\n        impl TryFrom<$source> for $target {\n            type Error = TryFromIntError;\n\n            #[inline]\n            fn try_from(u: $source) -> Result<$target, TryFromIntError> {\n                let min = <$target>::min_value() as $source;\n                let max = <$target>::max_value() as $source;\n                if u < min || u > max {\n                    Err(TryFromIntError(()))\n                } else {\n                    Ok(u as $target)\n                }\n            }\n        }\n    )*}\n}\n\nmacro_rules! rev {\n    ($mac:ident, $source:ty, $($target:ty),*) => {$(\n        $mac!($target, $source);\n    )*}\n}\n\n/// intra-sign conversions\ntry_from_upper_bounded!(u16, u8);\ntry_from_upper_bounded!(u32, u16, u8);\ntry_from_upper_bounded!(u64, u32, u16, u8);\ntry_from_upper_bounded!(u128, u64, u32, u16, u8);\n\ntry_from_both_bounded!(i16, i8);\ntry_from_both_bounded!(i32, i16, i8);\ntry_from_both_bounded!(i64, i32, i16, i8);\ntry_from_both_bounded!(i128, i64, i32, i16, i8);\n\n// unsigned-to-signed\ntry_from_upper_bounded!(u8, i8);\ntry_from_upper_bounded!(u16, i8, i16);\ntry_from_upper_bounded!(u32, i8, i16, i32);\ntry_from_upper_bounded!(u64, i8, i16, i32, i64);\ntry_from_upper_bounded!(u128, i8, i16, i32, i64, i128);\n\n// signed-to-unsigned\ntry_from_lower_bounded!(i8, u8, u16, u32, u64, u128);\ntry_from_lower_bounded!(i16, u16, u32, u64, u128);\ntry_from_lower_bounded!(i32, u32, u64, u128);\ntry_from_lower_bounded!(i64, u64, u128);\ntry_from_lower_bounded!(i128, u128);\ntry_from_both_bounded!(i16, u8);\ntry_from_both_bounded!(i32, u16, u8);\ntry_from_both_bounded!(i64, u32, u16, u8);\ntry_from_both_bounded!(i128, u64, u32, u16, u8);\n\n// usize/isize\ntry_from_upper_bounded!(usize, isize);\ntry_from_lower_bounded!(isize, usize);\n\n#[cfg(target_pointer_width = \"16\")]\nmod ptr_try_from_impls {\n    use super::TryFromIntError;\n    use convert::TryFrom;\n\n    try_from_upper_bounded!(usize, u8);\n    try_from_unbounded!(usize, u16, u32, u64, u128);\n    try_from_upper_bounded!(usize, i8, i16);\n    try_from_unbounded!(usize, i32, i64, i128);\n\n    try_from_both_bounded!(isize, u8);\n    try_from_lower_bounded!(isize, u16, u32, u64, u128);\n    try_from_both_bounded!(isize, i8);\n    try_from_unbounded!(isize, i16, i32, i64, i128);\n\n    rev!(try_from_upper_bounded, usize, u32, u64, u128);\n    rev!(try_from_lower_bounded, usize, i8, i16);\n    rev!(try_from_both_bounded, usize, i32, i64, i128);\n\n    rev!(try_from_upper_bounded, isize, u16, u32, u64, u128);\n    rev!(try_from_both_bounded, isize, i32, i64, i128);\n}\n\n#[cfg(target_pointer_width = \"32\")]\nmod ptr_try_from_impls {\n    use super::TryFromIntError;\n    use convert::TryFrom;\n\n    try_from_upper_bounded!(usize, u8, u16);\n    try_from_unbounded!(usize, u32, u64, u128);\n    try_from_upper_bounded!(usize, i8, i16, i32);\n    try_from_unbounded!(usize, i64, i128);\n\n    try_from_both_bounded!(isize, u8, u16);\n    try_from_lower_bounded!(isize, u32, u64, u128);\n    try_from_both_bounded!(isize, i8, i16);\n    try_from_unbounded!(isize, i32, i64, i128);\n\n    rev!(try_from_unbounded, usize, u32);\n    rev!(try_from_upper_bounded, usize, u64, u128);\n    rev!(try_from_lower_bounded, usize, i8, i16, i32);\n    rev!(try_from_both_bounded, usize, i64, i128);\n\n    rev!(try_from_unbounded, isize, u16);\n    rev!(try_from_upper_bounded, isize, u32, u64, u128);\n    rev!(try_from_unbounded, isize, i32);\n    rev!(try_from_both_bounded, isize, i64, i128);\n}\n\n#[cfg(target_pointer_width = \"64\")]\nmod ptr_try_from_impls {\n    use super::TryFromIntError;\n    use convert::TryFrom;\n\n    try_from_upper_bounded!(usize, u8, u16, u32);\n    try_from_unbounded!(usize, u64, u128);\n    try_from_upper_bounded!(usize, i8, i16, i32, i64);\n    try_from_unbounded!(usize, i128);\n\n    try_from_both_bounded!(isize, u8, u16, u32);\n    try_from_lower_bounded!(isize, u64, u128);\n    try_from_both_bounded!(isize, i8, i16, i32);\n    try_from_unbounded!(isize, i64, i128);\n\n    rev!(try_from_unbounded, usize, u32, u64);\n    rev!(try_from_upper_bounded, usize, u128);\n    rev!(try_from_lower_bounded, usize, i8, i16, i32, i64);\n    rev!(try_from_both_bounded, usize, i128);\n\n    rev!(try_from_unbounded, isize, u16, u32);\n    rev!(try_from_upper_bounded, isize, u64, u128);\n    rev!(try_from_unbounded, isize, i32, i64);\n    rev!(try_from_both_bounded, isize, i128);\n}\n\n#[doc(hidden)]\ntrait FromStrRadixHelper: PartialOrd + Copy {\n    fn min_value() -> Self;\n    fn max_value() -> Self;\n    fn from_u32(u: u32) -> Self;\n    fn checked_mul(&self, other: u32) -> Option<Self>;\n    fn checked_sub(&self, other: u32) -> Option<Self>;\n    fn checked_add(&self, other: u32) -> Option<Self>;\n}\n\nmacro_rules! doit {\n    ($($t:ty)*) => ($(impl FromStrRadixHelper for $t {\n        #[inline]\n        fn min_value() -> Self { Self::min_value() }\n        #[inline]\n        fn max_value() -> Self { Self::max_value() }\n        #[inline]\n        fn from_u32(u: u32) -> Self { u as Self }\n        #[inline]\n        fn checked_mul(&self, other: u32) -> Option<Self> {\n            Self::checked_mul(*self, other as Self)\n        }\n        #[inline]\n        fn checked_sub(&self, other: u32) -> Option<Self> {\n            Self::checked_sub(*self, other as Self)\n        }\n        #[inline]\n        fn checked_add(&self, other: u32) -> Option<Self> {\n            Self::checked_add(*self, other as Self)\n        }\n    })*)\n}\ndoit! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }\n\nfn from_str_radix<T: FromStrRadixHelper>(src: &str, radix: u32) -> Result<T, ParseIntError> {\n    use self::IntErrorKind::*;\n    use self::ParseIntError as PIE;\n\n    assert!(radix >= 2 && radix <= 36,\n           \"from_str_radix_int: must lie in the range `[2, 36]` - found {}\",\n           radix);\n\n    if src.is_empty() {\n        return Err(PIE { kind: Empty });\n    }\n\n    let is_signed_ty = T::from_u32(0) > T::min_value();\n\n    // all valid digits are ascii, so we will just iterate over the utf8 bytes\n    // and cast them to chars. .to_digit() will safely return None for anything\n    // other than a valid ascii digit for the given radix, including the first-byte\n    // of multi-byte sequences\n    let src = src.as_bytes();\n\n    let (is_positive, digits) = match src[0] {\n        b'+' => (true, &src[1..]),\n        b'-' if is_signed_ty => (false, &src[1..]),\n        _ => (true, src),\n    };\n\n    if digits.is_empty() {\n        return Err(PIE { kind: Empty });\n    }\n\n    let mut result = T::from_u32(0);\n    if is_positive {\n        // The number is positive\n        for &c in digits {\n            let x = match (c as char).to_digit(radix) {\n                Some(x) => x,\n                None => return Err(PIE { kind: InvalidDigit }),\n            };\n            result = match result.checked_mul(radix) {\n                Some(result) => result,\n                None => return Err(PIE { kind: Overflow }),\n            };\n            result = match result.checked_add(x) {\n                Some(result) => result,\n                None => return Err(PIE { kind: Overflow }),\n            };\n        }\n    } else {\n        // The number is negative\n        for &c in digits {\n            let x = match (c as char).to_digit(radix) {\n                Some(x) => x,\n                None => return Err(PIE { kind: InvalidDigit }),\n            };\n            result = match result.checked_mul(radix) {\n                Some(result) => result,\n                None => return Err(PIE { kind: Underflow }),\n            };\n            result = match result.checked_sub(x) {\n                Some(result) => result,\n                None => return Err(PIE { kind: Underflow }),\n            };\n        }\n    }\n    Ok(result)\n}\n\n/// An error which can be returned when parsing an integer.\n///\n/// This error is used as the error type for the `from_str_radix()` functions\n/// on the primitive integer types, such as [`i8::from_str_radix`].\n///\n/// # Potential causes\n///\n/// Among other causes, `ParseIntError` can be thrown because of leading or trailing whitespace\n/// in the string e.g. when it is obtained from the standard input.\n/// Using the [`str.trim()`] method ensures that no whitespace remains before parsing.\n///\n/// [`str.trim()`]: ../../std/primitive.str.html#method.trim\n/// [`i8::from_str_radix`]: ../../std/primitive.i8.html#method.from_str_radix\n#[derive(Debug, Clone, PartialEq, Eq)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct ParseIntError {\n    kind: IntErrorKind,\n}\n\n#[derive(Debug, Clone, PartialEq, Eq)]\nenum IntErrorKind {\n    Empty,\n    InvalidDigit,\n    Overflow,\n    Underflow,\n}\n\nimpl ParseIntError {\n    #[unstable(feature = \"int_error_internals\",\n               reason = \"available through Error trait and this method should \\\n                         not be exposed publicly\",\n               issue = \"0\")]\n    #[doc(hidden)]\n    pub fn __description(&self) -> &str {\n        match self.kind {\n            IntErrorKind::Empty => \"cannot parse integer from empty string\",\n            IntErrorKind::InvalidDigit => \"invalid digit found in string\",\n            IntErrorKind::Overflow => \"number too large to fit in target type\",\n            IntErrorKind::Underflow => \"number too small to fit in target type\",\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for ParseIntError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.__description().fmt(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use num::dec2flt::ParseFloatError;\n\n// Conversion traits for primitive integer and float types\n// Conversions T -> T are covered by a blanket impl and therefore excluded\n// Some conversions from and to usize/isize are not implemented due to portability concerns\nmacro_rules! impl_from {\n    ($Small: ty, $Large: ty, #[$attr:meta], $doc: expr) => {\n        #[$attr]\n        #[doc = $doc]\n        impl From<$Small> for $Large {\n            #[inline]\n            fn from(small: $Small) -> $Large {\n                small as $Large\n            }\n        }\n    };\n    ($Small: ty, $Large: ty, #[$attr:meta]) => {\n        impl_from!($Small,\n                   $Large,\n                   #[$attr],\n                   concat!(\"Converts `\",\n                           stringify!($Small),\n                           \"` to `\",\n                           stringify!($Large),\n                           \"` losslessly.\"));\n    }\n}\n\nmacro_rules! impl_from_bool {\n    ($target: ty, #[$attr:meta]) => {\n        impl_from!(bool, $target, #[$attr], concat!(\"Converts a `bool` to a `\",\n            stringify!($target), \"`. The resulting value is `0` for `false` and `1` for `true`\nvalues.\n\n# Examples\n\n```\nassert_eq!(\", stringify!($target), \"::from(true), 1);\nassert_eq!(\", stringify!($target), \"::from(false), 0);\n```\"));\n    };\n}\n\n// Bool -> Any\nimpl_from_bool! { u8, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { u16, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { u32, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { u64, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { u128, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { usize, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { i8, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { i16, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { i32, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { i64, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { i128, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\nimpl_from_bool! { isize, #[stable(feature = \"from_bool\", since = \"1.28.0\")] }\n\n// Unsigned -> Unsigned\nimpl_from! { u8, u16, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, u32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, u64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, u128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u8, usize, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u16, u32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u16, u64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u16, u128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u32, u64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u32, u128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u64, u128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\n\n// Signed -> Signed\nimpl_from! { i8, i16, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i8, i32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i8, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i8, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { i8, isize, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i16, i32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i16, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i16, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { i32, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { i32, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { i64, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\n\n// Unsigned -> Signed\nimpl_from! { u8, i16, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, i32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u8, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u16, i32, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u16, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u16, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u32, i64, #[stable(feature = \"lossless_int_conv\", since = \"1.5.0\")] }\nimpl_from! { u32, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\nimpl_from! { u64, i128, #[stable(feature = \"i128\", since = \"1.26.0\")] }\n\n// The C99 standard defines bounds on INTPTR_MIN, INTPTR_MAX, and UINTPTR_MAX\n// which imply that pointer-sized integers must be at least 16 bits:\n// https://port70.net/~nsz/c/c99/n1256.html#7.18.2.4\nimpl_from! { u16, usize, #[stable(feature = \"lossless_iusize_conv\", since = \"1.26.0\")] }\nimpl_from! { u8, isize, #[stable(feature = \"lossless_iusize_conv\", since = \"1.26.0\")] }\nimpl_from! { i16, isize, #[stable(feature = \"lossless_iusize_conv\", since = \"1.26.0\")] }\n\n// RISC-V defines the possibility of a 128-bit address space (RV128).\n\n// CHERI proposes 256-bit \u201ccapabilities\u201d. Unclear if this would be relevant to usize/isize.\n// https://www.cl.cam.ac.uk/research/security/ctsrd/pdfs/20171017a-cheri-poster.pdf\n// http://www.csl.sri.com/users/neumann/2012resolve-cheri.pdf\n\n\n// Note: integers can only be represented with full precision in a float if\n// they fit in the significand, which is 24 bits in f32 and 53 bits in f64.\n// Lossy float conversions are not implemented at this time.\n\n// Signed -> Float\nimpl_from! { i8, f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { i8, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { i16, f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { i16, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { i32, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\n\n// Unsigned -> Float\nimpl_from! { u8, f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { u8, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { u16, f32, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { u16, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\nimpl_from! { u32, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\n\n// Float -> Float\nimpl_from! { f32, f64, #[stable(feature = \"lossless_float_conv\", since = \"1.6.0\")] }\n\nstatic ASCII_LOWERCASE_MAP: [u8; 256] = [\n    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,\n    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,\n    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,\n    b' ', b'!', b'\"', b'#', b'$', b'%', b'&', b'\\'',\n    b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',\n    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',\n    b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',\n    b'@',\n\n          b'a', b'b', b'c', b'd', b'e', b'f', b'g',\n    b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',\n    b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',\n    b'x', b'y', b'z',\n\n                      b'[', b'\\\\', b']', b'^', b'_',\n    b'`', b'a', b'b', b'c', b'd', b'e', b'f', b'g',\n    b'h', b'i', b'j', b'k', b'l', b'm', b'n', b'o',\n    b'p', b'q', b'r', b's', b't', b'u', b'v', b'w',\n    b'x', b'y', b'z', b'{', b'|', b'}', b'~', 0x7f,\n    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,\n    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,\n    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,\n    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,\n    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,\n    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,\n    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,\n    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,\n    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,\n    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,\n    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,\n    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,\n    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,\n    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,\n    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,\n    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,\n];\n\nstatic ASCII_UPPERCASE_MAP: [u8; 256] = [\n    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,\n    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,\n    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,\n    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,\n    b' ', b'!', b'\"', b'#', b'$', b'%', b'&', b'\\'',\n    b'(', b')', b'*', b'+', b',', b'-', b'.', b'/',\n    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7',\n    b'8', b'9', b':', b';', b'<', b'=', b'>', b'?',\n    b'@', b'A', b'B', b'C', b'D', b'E', b'F', b'G',\n    b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',\n    b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',\n    b'X', b'Y', b'Z', b'[', b'\\\\', b']', b'^', b'_',\n    b'`',\n\n          b'A', b'B', b'C', b'D', b'E', b'F', b'G',\n    b'H', b'I', b'J', b'K', b'L', b'M', b'N', b'O',\n    b'P', b'Q', b'R', b'S', b'T', b'U', b'V', b'W',\n    b'X', b'Y', b'Z',\n\n                      b'{', b'|', b'}', b'~', 0x7f,\n    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,\n    0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,\n    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97,\n    0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f,\n    0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,\n    0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf,\n    0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7,\n    0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,\n    0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,\n    0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf,\n    0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7,\n    0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf,\n    0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7,\n    0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,\n    0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,\n    0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,\n];\n\nenum AsciiCharacterClass {\n    C,  // control\n    Cw, // control whitespace\n    W,  // whitespace\n    D,  // digit\n    L,  // lowercase\n    Lx, // lowercase hex digit\n    U,  // uppercase\n    Ux, // uppercase hex digit\n    P,  // punctuation\n}\nuse self::AsciiCharacterClass::*;\n\nstatic ASCII_CHARACTER_CLASS: [AsciiCharacterClass; 128] = [\n//  _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _a _b _c _d _e _f\n    C, C, C, C, C, C, C, C, C, Cw,Cw,C, Cw,Cw,C, C, // 0_\n    C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, C, // 1_\n    W, P, P, P, P, P, P, P, P, P, P, P, P, P, P, P, // 2_\n    D, D, D, D, D, D, D, D, D, D, P, P, P, P, P, P, // 3_\n    P, Ux,Ux,Ux,Ux,Ux,Ux,U, U, U, U, U, U, U, U, U, // 4_\n    U, U, U, U, U, U, U, U, U, U, U, P, P, P, P, P, // 5_\n    P, Lx,Lx,Lx,Lx,Lx,Lx,L, L, L, L, L, L, L, L, L, // 6_\n    L, L, L, L, L, L, L, L, L, L, L, P, P, P, P, C, // 7_\n];\n","// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Slice management and manipulation\n//!\n//! For more details see [`std::slice`].\n//!\n//! [`std::slice`]: ../../std/slice/index.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n// How this module is organized.\n//\n// The library infrastructure for slices is fairly messy. There's\n// a lot of stuff defined here. Let's keep it clean.\n//\n// The layout of this file is thus:\n//\n// * Inherent methods. This is where most of the slice API resides.\n// * Implementations of a few common traits with important slice ops.\n// * Definitions of a bunch of iterators.\n// * Free functions.\n// * The `raw` and `bytes` submodules.\n// * Boilerplate trait implementations.\n\nuse cmp::Ordering::{self, Less, Equal, Greater};\nuse cmp;\nuse fmt;\nuse intrinsics::assume;\nuse isize;\nuse iter::*;\nuse ops::{FnMut, Try, self};\nuse option::Option;\nuse option::Option::{None, Some};\nuse result::Result;\nuse result::Result::{Ok, Err};\nuse ptr;\nuse mem;\nuse marker::{Copy, Send, Sync, Sized, self};\nuse iter_private::TrustedRandomAccess;\n\n#[unstable(feature = \"slice_internals\", issue = \"0\",\n           reason = \"exposed from core to be reused in std; use the memchr crate\")]\n/// Pure rust memchr implementation, taken from rust-memchr\npub mod memchr;\n\nmod rotate;\nmod sort;\n\n#[repr(C)]\nunion Repr<'a, T: 'a> {\n    rust: &'a [T],\n    rust_mut: &'a mut [T],\n    raw: FatPtr<T>,\n}\n\n#[repr(C)]\nstruct FatPtr<T> {\n    data: *const T,\n    len: usize,\n}\n\n//\n// Extension traits\n//\n\n#[lang = \"slice\"]\n#[cfg(not(test))]\nimpl<T> [T] {\n    /// Returns the number of elements in the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert_eq!(a.len(), 3);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    #[rustc_const_unstable(feature = \"const_slice_len\")]\n    pub const fn len(&self) -> usize {\n        unsafe {\n            Repr { rust: self }.raw.len\n        }\n    }\n\n    /// Returns `true` if the slice has a length of 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert!(!a.is_empty());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    #[rustc_const_unstable(feature = \"const_slice_len\")]\n    pub const fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n\n    /// Returns the first element of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert_eq!(Some(&10), v.first());\n    ///\n    /// let w: &[i32] = &[];\n    /// assert_eq!(None, w.first());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn first(&self) -> Option<&T> {\n        self.get(0)\n    }\n\n    /// Returns a mutable pointer to the first element of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [0, 1, 2];\n    ///\n    /// if let Some(first) = x.first_mut() {\n    ///     *first = 5;\n    /// }\n    /// assert_eq!(x, &[5, 1, 2]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn first_mut(&mut self) -> Option<&mut T> {\n        self.get_mut(0)\n    }\n\n    /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &[0, 1, 2];\n    ///\n    /// if let Some((first, elements)) = x.split_first() {\n    ///     assert_eq!(first, &0);\n    ///     assert_eq!(elements, &[1, 2]);\n    /// }\n    /// ```\n    #[stable(feature = \"slice_splits\", since = \"1.5.0\")]\n    #[inline]\n    pub fn split_first(&self) -> Option<(&T, &[T])> {\n        if self.is_empty() { None } else { Some((&self[0], &self[1..])) }\n    }\n\n    /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [0, 1, 2];\n    ///\n    /// if let Some((first, elements)) = x.split_first_mut() {\n    ///     *first = 3;\n    ///     elements[0] = 4;\n    ///     elements[1] = 5;\n    /// }\n    /// assert_eq!(x, &[3, 4, 5]);\n    /// ```\n    #[stable(feature = \"slice_splits\", since = \"1.5.0\")]\n    #[inline]\n    pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])> {\n        if self.is_empty() { None } else {\n            let split = self.split_at_mut(1);\n            Some((&mut split.0[0], split.1))\n        }\n    }\n\n    /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &[0, 1, 2];\n    ///\n    /// if let Some((last, elements)) = x.split_last() {\n    ///     assert_eq!(last, &2);\n    ///     assert_eq!(elements, &[0, 1]);\n    /// }\n    /// ```\n    #[stable(feature = \"slice_splits\", since = \"1.5.0\")]\n    #[inline]\n    pub fn split_last(&self) -> Option<(&T, &[T])> {\n        let len = self.len();\n        if len == 0 { None } else { Some((&self[len - 1], &self[..(len - 1)])) }\n    }\n\n    /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [0, 1, 2];\n    ///\n    /// if let Some((last, elements)) = x.split_last_mut() {\n    ///     *last = 3;\n    ///     elements[0] = 4;\n    ///     elements[1] = 5;\n    /// }\n    /// assert_eq!(x, &[4, 5, 3]);\n    /// ```\n    #[stable(feature = \"slice_splits\", since = \"1.5.0\")]\n    #[inline]\n    pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])> {\n        let len = self.len();\n        if len == 0 { None } else {\n            let split = self.split_at_mut(len - 1);\n            Some((&mut split.1[0], split.0))\n        }\n\n    }\n\n    /// Returns the last element of the slice, or `None` if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert_eq!(Some(&30), v.last());\n    ///\n    /// let w: &[i32] = &[];\n    /// assert_eq!(None, w.last());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn last(&self) -> Option<&T> {\n        let last_idx = self.len().checked_sub(1)?;\n        self.get(last_idx)\n    }\n\n    /// Returns a mutable pointer to the last item in the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [0, 1, 2];\n    ///\n    /// if let Some(last) = x.last_mut() {\n    ///     *last = 10;\n    /// }\n    /// assert_eq!(x, &[0, 1, 10]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn last_mut(&mut self) -> Option<&mut T> {\n        let last_idx = self.len().checked_sub(1)?;\n        self.get_mut(last_idx)\n    }\n\n    /// Returns a reference to an element or subslice depending on the type of\n    /// index.\n    ///\n    /// - If given a position, returns a reference to the element at that\n    ///   position or `None` if out of bounds.\n    /// - If given a range, returns the subslice corresponding to that range,\n    ///   or `None` if out of bounds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert_eq!(Some(&40), v.get(1));\n    /// assert_eq!(Some(&[10, 40][..]), v.get(0..2));\n    /// assert_eq!(None, v.get(3));\n    /// assert_eq!(None, v.get(0..4));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn get<I>(&self, index: I) -> Option<&I::Output>\n        where I: SliceIndex<Self>\n    {\n        index.get(self)\n    }\n\n    /// Returns a mutable reference to an element or subslice depending on the\n    /// type of index (see [`get`]) or `None` if the index is out of bounds.\n    ///\n    /// [`get`]: #method.get\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [0, 1, 2];\n    ///\n    /// if let Some(elem) = x.get_mut(1) {\n    ///     *elem = 42;\n    /// }\n    /// assert_eq!(x, &[0, 42, 2]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output>\n        where I: SliceIndex<Self>\n    {\n        index.get_mut(self)\n    }\n\n    /// Returns a reference to an element or subslice, without doing bounds\n    /// checking.\n    ///\n    /// This is generally not recommended, use with caution! For a safe\n    /// alternative see [`get`].\n    ///\n    /// [`get`]: #method.get\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &[1, 2, 4];\n    ///\n    /// unsafe {\n    ///     assert_eq!(x.get_unchecked(1), &2);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub unsafe fn get_unchecked<I>(&self, index: I) -> &I::Output\n        where I: SliceIndex<Self>\n    {\n        index.get_unchecked(self)\n    }\n\n    /// Returns a mutable reference to an element or subslice, without doing\n    /// bounds checking.\n    ///\n    /// This is generally not recommended, use with caution! For a safe\n    /// alternative see [`get_mut`].\n    ///\n    /// [`get_mut`]: #method.get_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [1, 2, 4];\n    ///\n    /// unsafe {\n    ///     let elem = x.get_unchecked_mut(1);\n    ///     *elem = 13;\n    /// }\n    /// assert_eq!(x, &[1, 13, 4]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut I::Output\n        where I: SliceIndex<Self>\n    {\n        index.get_unchecked_mut(self)\n    }\n\n    /// Returns a raw pointer to the slice's buffer.\n    ///\n    /// The caller must ensure that the slice outlives the pointer this\n    /// function returns, or else it will end up pointing to garbage.\n    ///\n    /// Modifying the container referenced by this slice may cause its buffer\n    /// to be reallocated, which would also make any pointers to it invalid.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &[1, 2, 4];\n    /// let x_ptr = x.as_ptr();\n    ///\n    /// unsafe {\n    ///     for i in 0..x.len() {\n    ///         assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    #[rustc_const_unstable(feature = \"const_slice_as_ptr\")]\n    pub const fn as_ptr(&self) -> *const T {\n        self as *const [T] as *const T\n    }\n\n    /// Returns an unsafe mutable pointer to the slice's buffer.\n    ///\n    /// The caller must ensure that the slice outlives the pointer this\n    /// function returns, or else it will end up pointing to garbage.\n    ///\n    /// Modifying the container referenced by this slice may cause its buffer\n    /// to be reallocated, which would also make any pointers to it invalid.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [1, 2, 4];\n    /// let x_ptr = x.as_mut_ptr();\n    ///\n    /// unsafe {\n    ///     for i in 0..x.len() {\n    ///         *x_ptr.add(i) += 2;\n    ///     }\n    /// }\n    /// assert_eq!(x, &[3, 4, 6]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn as_mut_ptr(&mut self) -> *mut T {\n        self as *mut [T] as *mut T\n    }\n\n    /// Swaps two elements in the slice.\n    ///\n    /// # Arguments\n    ///\n    /// * a - The index of the first element\n    /// * b - The index of the second element\n    ///\n    /// # Panics\n    ///\n    /// Panics if `a` or `b` are out of bounds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [\"a\", \"b\", \"c\", \"d\"];\n    /// v.swap(1, 3);\n    /// assert!(v == [\"a\", \"d\", \"c\", \"b\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn swap(&mut self, a: usize, b: usize) {\n        unsafe {\n            // Can't take two mutable loans from one vector, so instead just cast\n            // them to their raw pointers to do the swap\n            let pa: *mut T = &mut self[a];\n            let pb: *mut T = &mut self[b];\n            ptr::swap(pa, pb);\n        }\n    }\n\n    /// Reverses the order of elements in the slice, in place.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [1, 2, 3];\n    /// v.reverse();\n    /// assert!(v == [3, 2, 1]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn reverse(&mut self) {\n        let mut i: usize = 0;\n        let ln = self.len();\n\n        // For very small types, all the individual reads in the normal\n        // path perform poorly.  We can do better, given efficient unaligned\n        // load/store, by loading a larger chunk and reversing a register.\n\n        // Ideally LLVM would do this for us, as it knows better than we do\n        // whether unaligned reads are efficient (since that changes between\n        // different ARM versions, for example) and what the best chunk size\n        // would be.  Unfortunately, as of LLVM 4.0 (2017-05) it only unrolls\n        // the loop, so we need to do this ourselves.  (Hypothesis: reverse\n        // is troublesome because the sides can be aligned differently --\n        // will be, when the length is odd -- so there's no way of emitting\n        // pre- and postludes to use fully-aligned SIMD in the middle.)\n\n        let fast_unaligned =\n            cfg!(any(target_arch = \"x86\", target_arch = \"x86_64\"));\n\n        if fast_unaligned && mem::size_of::<T>() == 1 {\n            // Use the llvm.bswap intrinsic to reverse u8s in a usize\n            let chunk = mem::size_of::<usize>();\n            while i + chunk - 1 < ln / 2 {\n                unsafe {\n                    let pa: *mut T = self.get_unchecked_mut(i);\n                    let pb: *mut T = self.get_unchecked_mut(ln - i - chunk);\n                    let va = ptr::read_unaligned(pa as *mut usize);\n                    let vb = ptr::read_unaligned(pb as *mut usize);\n                    ptr::write_unaligned(pa as *mut usize, vb.swap_bytes());\n                    ptr::write_unaligned(pb as *mut usize, va.swap_bytes());\n                }\n                i += chunk;\n            }\n        }\n\n        if fast_unaligned && mem::size_of::<T>() == 2 {\n            // Use rotate-by-16 to reverse u16s in a u32\n            let chunk = mem::size_of::<u32>() / 2;\n            while i + chunk - 1 < ln / 2 {\n                unsafe {\n                    let pa: *mut T = self.get_unchecked_mut(i);\n                    let pb: *mut T = self.get_unchecked_mut(ln - i - chunk);\n                    let va = ptr::read_unaligned(pa as *mut u32);\n                    let vb = ptr::read_unaligned(pb as *mut u32);\n                    ptr::write_unaligned(pa as *mut u32, vb.rotate_left(16));\n                    ptr::write_unaligned(pb as *mut u32, va.rotate_left(16));\n                }\n                i += chunk;\n            }\n        }\n\n        while i < ln / 2 {\n            // Unsafe swap to avoid the bounds check in safe swap.\n            unsafe {\n                let pa: *mut T = self.get_unchecked_mut(i);\n                let pb: *mut T = self.get_unchecked_mut(ln - i - 1);\n                ptr::swap(pa, pb);\n            }\n            i += 1;\n        }\n    }\n\n    /// Returns an iterator over the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &[1, 2, 4];\n    /// let mut iterator = x.iter();\n    ///\n    /// assert_eq!(iterator.next(), Some(&1));\n    /// assert_eq!(iterator.next(), Some(&2));\n    /// assert_eq!(iterator.next(), Some(&4));\n    /// assert_eq!(iterator.next(), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn iter(&self) -> Iter<T> {\n        unsafe {\n            let ptr = self.as_ptr();\n            assume(!ptr.is_null());\n\n            let end = if mem::size_of::<T>() == 0 {\n                (ptr as *const u8).wrapping_add(self.len()) as *const T\n            } else {\n                ptr.add(self.len())\n            };\n\n            Iter {\n                ptr,\n                end,\n                _marker: marker::PhantomData\n            }\n        }\n    }\n\n    /// Returns an iterator that allows modifying each value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = &mut [1, 2, 4];\n    /// for elem in x.iter_mut() {\n    ///     *elem += 2;\n    /// }\n    /// assert_eq!(x, &[3, 4, 6]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn iter_mut(&mut self) -> IterMut<T> {\n        unsafe {\n            let ptr = self.as_mut_ptr();\n            assume(!ptr.is_null());\n\n            let end = if mem::size_of::<T>() == 0 {\n                (ptr as *mut u8).wrapping_add(self.len()) as *mut T\n            } else {\n                ptr.add(self.len())\n            };\n\n            IterMut {\n                ptr,\n                end,\n                _marker: marker::PhantomData\n            }\n        }\n    }\n\n    /// Returns an iterator over all contiguous windows of length\n    /// `size`. The windows overlap. If the slice is shorter than\n    /// `size`, the iterator returns no values.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = ['r', 'u', 's', 't'];\n    /// let mut iter = slice.windows(2);\n    /// assert_eq!(iter.next().unwrap(), &['r', 'u']);\n    /// assert_eq!(iter.next().unwrap(), &['u', 's']);\n    /// assert_eq!(iter.next().unwrap(), &['s', 't']);\n    /// assert!(iter.next().is_none());\n    /// ```\n    ///\n    /// If the slice is shorter than `size`:\n    ///\n    /// ```\n    /// let slice = ['f', 'o', 'o'];\n    /// let mut iter = slice.windows(4);\n    /// assert!(iter.next().is_none());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn windows(&self, size: usize) -> Windows<T> {\n        assert!(size != 0);\n        Windows { v: self, size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the\n    /// beginning of the slice.\n    ///\n    /// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the\n    /// slice, then the last chunk will not have length `chunk_size`.\n    ///\n    /// See [`chunks_exact`] for a variant of this iterator that returns chunks of always exactly\n    /// `chunk_size` elements, and [`rchunks`] for the same iterator but starting at the end of the\n    /// slice of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = ['l', 'o', 'r', 'e', 'm'];\n    /// let mut iter = slice.chunks(2);\n    /// assert_eq!(iter.next().unwrap(), &['l', 'o']);\n    /// assert_eq!(iter.next().unwrap(), &['r', 'e']);\n    /// assert_eq!(iter.next().unwrap(), &['m']);\n    /// assert!(iter.next().is_none());\n    /// ```\n    ///\n    /// [`chunks_exact`]: #method.chunks_exact\n    /// [`rchunks`]: #method.rchunks\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn chunks(&self, chunk_size: usize) -> Chunks<T> {\n        assert!(chunk_size != 0);\n        Chunks { v: self, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the\n    /// beginning of the slice.\n    ///\n    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the\n    /// length of the slice, then the last chunk will not have length `chunk_size`.\n    ///\n    /// See [`chunks_exact_mut`] for a variant of this iterator that returns chunks of always\n    /// exactly `chunk_size` elements, and [`rchunks_mut`] for the same iterator but starting at\n    /// the end of the slice of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = &mut [0, 0, 0, 0, 0];\n    /// let mut count = 1;\n    ///\n    /// for chunk in v.chunks_mut(2) {\n    ///     for elem in chunk.iter_mut() {\n    ///         *elem += count;\n    ///     }\n    ///     count += 1;\n    /// }\n    /// assert_eq!(v, &[1, 1, 2, 2, 3]);\n    /// ```\n    ///\n    /// [`chunks_exact_mut`]: #method.chunks_exact_mut\n    /// [`rchunks_mut`]: #method.rchunks_mut\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {\n        assert!(chunk_size != 0);\n        ChunksMut { v: self, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the\n    /// beginning of the slice.\n    ///\n    /// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the\n    /// slice, then the last up to `chunk_size-1` elements will be omitted and can be retrieved\n    /// from the `remainder` function of the iterator.\n    ///\n    /// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the\n    /// resulting code better than in the case of [`chunks`].\n    ///\n    /// See [`chunks`] for a variant of this iterator that also returns the remainder as a smaller\n    /// chunk, and [`rchunks_exact`] for the same iterator but starting at the end of the slice of\n    /// the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = ['l', 'o', 'r', 'e', 'm'];\n    /// let mut iter = slice.chunks_exact(2);\n    /// assert_eq!(iter.next().unwrap(), &['l', 'o']);\n    /// assert_eq!(iter.next().unwrap(), &['r', 'e']);\n    /// assert!(iter.next().is_none());\n    /// assert_eq!(iter.remainder(), &['m']);\n    /// ```\n    ///\n    /// [`chunks`]: #method.chunks\n    /// [`rchunks_exact`]: #method.rchunks_exact\n    #[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\n    #[inline]\n    pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<T> {\n        assert!(chunk_size != 0);\n        let rem = self.len() % chunk_size;\n        let len = self.len() - rem;\n        let (fst, snd) = self.split_at(len);\n        ChunksExact { v: fst, rem: snd, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the\n    /// beginning of the slice.\n    ///\n    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the\n    /// length of the slice, then the last up to `chunk_size-1` elements will be omitted and can be\n    /// retrieved from the `into_remainder` function of the iterator.\n    ///\n    /// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the\n    /// resulting code better than in the case of [`chunks_mut`].\n    ///\n    /// See [`chunks_mut`] for a variant of this iterator that also returns the remainder as a\n    /// smaller chunk, and [`rchunks_exact_mut`] for the same iterator but starting at the end of\n    /// the slice of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = &mut [0, 0, 0, 0, 0];\n    /// let mut count = 1;\n    ///\n    /// for chunk in v.chunks_exact_mut(2) {\n    ///     for elem in chunk.iter_mut() {\n    ///         *elem += count;\n    ///     }\n    ///     count += 1;\n    /// }\n    /// assert_eq!(v, &[1, 1, 2, 2, 0]);\n    /// ```\n    ///\n    /// [`chunks_mut`]: #method.chunks_mut\n    /// [`rchunks_exact_mut`]: #method.rchunks_exact_mut\n    #[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\n    #[inline]\n    pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<T> {\n        assert!(chunk_size != 0);\n        let rem = self.len() % chunk_size;\n        let len = self.len() - rem;\n        let (fst, snd) = self.split_at_mut(len);\n        ChunksExactMut { v: fst, rem: snd, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end\n    /// of the slice.\n    ///\n    /// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the\n    /// slice, then the last chunk will not have length `chunk_size`.\n    ///\n    /// See [`rchunks_exact`] for a variant of this iterator that returns chunks of always exactly\n    /// `chunk_size` elements, and [`chunks`] for the same iterator but starting at the beginning\n    /// of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = ['l', 'o', 'r', 'e', 'm'];\n    /// let mut iter = slice.rchunks(2);\n    /// assert_eq!(iter.next().unwrap(), &['e', 'm']);\n    /// assert_eq!(iter.next().unwrap(), &['o', 'r']);\n    /// assert_eq!(iter.next().unwrap(), &['l']);\n    /// assert!(iter.next().is_none());\n    /// ```\n    ///\n    /// [`rchunks_exact`]: #method.rchunks_exact\n    /// [`chunks`]: #method.chunks\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    #[inline]\n    pub fn rchunks(&self, chunk_size: usize) -> RChunks<T> {\n        assert!(chunk_size != 0);\n        RChunks { v: self, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end\n    /// of the slice.\n    ///\n    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the\n    /// length of the slice, then the last chunk will not have length `chunk_size`.\n    ///\n    /// See [`rchunks_exact_mut`] for a variant of this iterator that returns chunks of always\n    /// exactly `chunk_size` elements, and [`chunks_mut`] for the same iterator but starting at the\n    /// beginning of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = &mut [0, 0, 0, 0, 0];\n    /// let mut count = 1;\n    ///\n    /// for chunk in v.rchunks_mut(2) {\n    ///     for elem in chunk.iter_mut() {\n    ///         *elem += count;\n    ///     }\n    ///     count += 1;\n    /// }\n    /// assert_eq!(v, &[3, 2, 2, 1, 1]);\n    /// ```\n    ///\n    /// [`rchunks_exact_mut`]: #method.rchunks_exact_mut\n    /// [`chunks_mut`]: #method.chunks_mut\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    #[inline]\n    pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<T> {\n        assert!(chunk_size != 0);\n        RChunksMut { v: self, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the\n    /// beginning of the slice.\n    ///\n    /// The chunks are slices and do not overlap. If `chunk_size` does not divide the length of the\n    /// slice, then the last up to `chunk_size-1` elements will be omitted and can be retrieved\n    /// from the `remainder` function of the iterator.\n    ///\n    /// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the\n    /// resulting code better than in the case of [`chunks`].\n    ///\n    /// See [`rchunks`] for a variant of this iterator that also returns the remainder as a smaller\n    /// chunk, and [`chunks_exact`] for the same iterator but starting at the beginning of the\n    /// slice of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = ['l', 'o', 'r', 'e', 'm'];\n    /// let mut iter = slice.rchunks_exact(2);\n    /// assert_eq!(iter.next().unwrap(), &['e', 'm']);\n    /// assert_eq!(iter.next().unwrap(), &['o', 'r']);\n    /// assert!(iter.next().is_none());\n    /// assert_eq!(iter.remainder(), &['l']);\n    /// ```\n    ///\n    /// [`rchunks`]: #method.rchunks\n    /// [`chunks_exact`]: #method.chunks_exact\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    #[inline]\n    pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<T> {\n        assert!(chunk_size != 0);\n        let rem = self.len() % chunk_size;\n        let (fst, snd) = self.split_at(rem);\n        RChunksExact { v: snd, rem: fst, chunk_size }\n    }\n\n    /// Returns an iterator over `chunk_size` elements of the slice at a time, starting at the end\n    /// of the slice.\n    ///\n    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does not divide the\n    /// length of the slice, then the last up to `chunk_size-1` elements will be omitted and can be\n    /// retrieved from the `into_remainder` function of the iterator.\n    ///\n    /// Due to each chunk having exactly `chunk_size` elements, the compiler can often optimize the\n    /// resulting code better than in the case of [`chunks_mut`].\n    ///\n    /// See [`rchunks_mut`] for a variant of this iterator that also returns the remainder as a\n    /// smaller chunk, and [`chunks_exact_mut`] for the same iterator but starting at the beginning\n    /// of the slice of the slice.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `chunk_size` is 0.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = &mut [0, 0, 0, 0, 0];\n    /// let mut count = 1;\n    ///\n    /// for chunk in v.rchunks_exact_mut(2) {\n    ///     for elem in chunk.iter_mut() {\n    ///         *elem += count;\n    ///     }\n    ///     count += 1;\n    /// }\n    /// assert_eq!(v, &[0, 2, 2, 1, 1]);\n    /// ```\n    ///\n    /// [`rchunks_mut`]: #method.rchunks_mut\n    /// [`chunks_exact_mut`]: #method.chunks_exact_mut\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    #[inline]\n    pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<T> {\n        assert!(chunk_size != 0);\n        let rem = self.len() % chunk_size;\n        let (fst, snd) = self.split_at_mut(rem);\n        RChunksExactMut { v: snd, rem: fst, chunk_size }\n    }\n\n    /// Divides one slice into two at an index.\n    ///\n    /// The first will contain all indices from `[0, mid)` (excluding\n    /// the index `mid` itself) and the second will contain all\n    /// indices from `[mid, len)` (excluding the index `len` itself).\n    ///\n    /// # Panics\n    ///\n    /// Panics if `mid > len`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [1, 2, 3, 4, 5, 6];\n    ///\n    /// {\n    ///    let (left, right) = v.split_at(0);\n    ///    assert!(left == []);\n    ///    assert!(right == [1, 2, 3, 4, 5, 6]);\n    /// }\n    ///\n    /// {\n    ///     let (left, right) = v.split_at(2);\n    ///     assert!(left == [1, 2]);\n    ///     assert!(right == [3, 4, 5, 6]);\n    /// }\n    ///\n    /// {\n    ///     let (left, right) = v.split_at(6);\n    ///     assert!(left == [1, 2, 3, 4, 5, 6]);\n    ///     assert!(right == []);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split_at(&self, mid: usize) -> (&[T], &[T]) {\n        (&self[..mid], &self[mid..])\n    }\n\n    /// Divides one mutable slice into two at an index.\n    ///\n    /// The first will contain all indices from `[0, mid)` (excluding\n    /// the index `mid` itself) and the second will contain all\n    /// indices from `[mid, len)` (excluding the index `len` itself).\n    ///\n    /// # Panics\n    ///\n    /// Panics if `mid > len`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [1, 0, 3, 0, 5, 6];\n    /// // scoped to restrict the lifetime of the borrows\n    /// {\n    ///     let (left, right) = v.split_at_mut(2);\n    ///     assert!(left == [1, 0]);\n    ///     assert!(right == [3, 0, 5, 6]);\n    ///     left[1] = 2;\n    ///     right[1] = 4;\n    /// }\n    /// assert!(v == [1, 2, 3, 4, 5, 6]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {\n        let len = self.len();\n        let ptr = self.as_mut_ptr();\n\n        unsafe {\n            assert!(mid <= len);\n\n            (from_raw_parts_mut(ptr, mid),\n             from_raw_parts_mut(ptr.add(mid), len - mid))\n        }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred`. The matched element is not contained in the subslices.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = [10, 40, 33, 20];\n    /// let mut iter = slice.split(|num| num % 3 == 0);\n    ///\n    /// assert_eq!(iter.next().unwrap(), &[10, 40]);\n    /// assert_eq!(iter.next().unwrap(), &[20]);\n    /// assert!(iter.next().is_none());\n    /// ```\n    ///\n    /// If the first element is matched, an empty slice will be the first item\n    /// returned by the iterator. Similarly, if the last element in the slice\n    /// is matched, an empty slice will be the last item returned by the\n    /// iterator:\n    ///\n    /// ```\n    /// let slice = [10, 40, 33];\n    /// let mut iter = slice.split(|num| num % 3 == 0);\n    ///\n    /// assert_eq!(iter.next().unwrap(), &[10, 40]);\n    /// assert_eq!(iter.next().unwrap(), &[]);\n    /// assert!(iter.next().is_none());\n    /// ```\n    ///\n    /// If two matched elements are directly adjacent, an empty slice will be\n    /// present between them:\n    ///\n    /// ```\n    /// let slice = [10, 6, 33, 20];\n    /// let mut iter = slice.split(|num| num % 3 == 0);\n    ///\n    /// assert_eq!(iter.next().unwrap(), &[10]);\n    /// assert_eq!(iter.next().unwrap(), &[]);\n    /// assert_eq!(iter.next().unwrap(), &[20]);\n    /// assert!(iter.next().is_none());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split<F>(&self, pred: F) -> Split<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        Split {\n            v: self,\n            pred,\n            finished: false\n        }\n    }\n\n    /// Returns an iterator over mutable subslices separated by elements that\n    /// match `pred`. The matched element is not contained in the subslices.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [10, 40, 30, 20, 60, 50];\n    ///\n    /// for group in v.split_mut(|num| *num % 3 == 0) {\n    ///     group[0] = 1;\n    /// }\n    /// assert_eq!(v, [1, 40, 30, 1, 60, 1]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        SplitMut { v: self, pred, finished: false }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred`, starting at the end of the slice and working backwards.\n    /// The matched element is not contained in the subslices.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let slice = [11, 22, 33, 0, 44, 55];\n    /// let mut iter = slice.rsplit(|num| *num == 0);\n    ///\n    /// assert_eq!(iter.next().unwrap(), &[44, 55]);\n    /// assert_eq!(iter.next().unwrap(), &[11, 22, 33]);\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// As with `split()`, if the first or last element is matched, an empty\n    /// slice will be the first (or last) item returned by the iterator.\n    ///\n    /// ```\n    /// let v = &[0, 1, 1, 2, 3, 5, 8];\n    /// let mut it = v.rsplit(|n| *n % 2 == 0);\n    /// assert_eq!(it.next().unwrap(), &[]);\n    /// assert_eq!(it.next().unwrap(), &[3, 5]);\n    /// assert_eq!(it.next().unwrap(), &[1, 1]);\n    /// assert_eq!(it.next().unwrap(), &[]);\n    /// assert_eq!(it.next(), None);\n    /// ```\n    #[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\n    #[inline]\n    pub fn rsplit<F>(&self, pred: F) -> RSplit<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        RSplit { inner: self.split(pred) }\n    }\n\n    /// Returns an iterator over mutable subslices separated by elements that\n    /// match `pred`, starting at the end of the slice and working\n    /// backwards. The matched element is not contained in the subslices.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [100, 400, 300, 200, 600, 500];\n    ///\n    /// let mut count = 0;\n    /// for group in v.rsplit_mut(|num| *num % 3 == 0) {\n    ///     count += 1;\n    ///     group[0] = count;\n    /// }\n    /// assert_eq!(v, [3, 400, 300, 2, 600, 1]);\n    /// ```\n    ///\n    #[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\n    #[inline]\n    pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        RSplitMut { inner: self.split_mut(pred) }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred`, limited to returning at most `n` items. The matched element is\n    /// not contained in the subslices.\n    ///\n    /// The last element returned, if any, will contain the remainder of the\n    /// slice.\n    ///\n    /// # Examples\n    ///\n    /// Print the slice split once by numbers divisible by 3 (i.e. `[10, 40]`,\n    /// `[20, 60, 50]`):\n    ///\n    /// ```\n    /// let v = [10, 40, 30, 20, 60, 50];\n    ///\n    /// for group in v.splitn(2, |num| *num % 3 == 0) {\n    ///     println!(\"{:?}\", group);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        SplitN {\n            inner: GenericSplitN {\n                iter: self.split(pred),\n                count: n\n            }\n        }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred`, limited to returning at most `n` items. The matched element is\n    /// not contained in the subslices.\n    ///\n    /// The last element returned, if any, will contain the remainder of the\n    /// slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [10, 40, 30, 20, 60, 50];\n    ///\n    /// for group in v.splitn_mut(2, |num| *num % 3 == 0) {\n    ///     group[0] = 1;\n    /// }\n    /// assert_eq!(v, [1, 40, 30, 1, 60, 50]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        SplitNMut {\n            inner: GenericSplitN {\n                iter: self.split_mut(pred),\n                count: n\n            }\n        }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred` limited to returning at most `n` items. This starts at the end of\n    /// the slice and works backwards.  The matched element is not contained in\n    /// the subslices.\n    ///\n    /// The last element returned, if any, will contain the remainder of the\n    /// slice.\n    ///\n    /// # Examples\n    ///\n    /// Print the slice split once, starting from the end, by numbers divisible\n    /// by 3 (i.e. `[50]`, `[10, 40, 30, 20]`):\n    ///\n    /// ```\n    /// let v = [10, 40, 30, 20, 60, 50];\n    ///\n    /// for group in v.rsplitn(2, |num| *num % 3 == 0) {\n    ///     println!(\"{:?}\", group);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        RSplitN {\n            inner: GenericSplitN {\n                iter: self.rsplit(pred),\n                count: n\n            }\n        }\n    }\n\n    /// Returns an iterator over subslices separated by elements that match\n    /// `pred` limited to returning at most `n` items. This starts at the end of\n    /// the slice and works backwards. The matched element is not contained in\n    /// the subslices.\n    ///\n    /// The last element returned, if any, will contain the remainder of the\n    /// slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut s = [10, 40, 30, 20, 60, 50];\n    ///\n    /// for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {\n    ///     group[0] = 1;\n    /// }\n    /// assert_eq!(s, [1, 40, 30, 20, 60, 1]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F>\n        where F: FnMut(&T) -> bool\n    {\n        RSplitNMut {\n            inner: GenericSplitN {\n                iter: self.rsplit_mut(pred),\n                count: n\n            }\n        }\n    }\n\n    /// Returns `true` if the slice contains an element with the given value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert!(v.contains(&30));\n    /// assert!(!v.contains(&50));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn contains(&self, x: &T) -> bool\n        where T: PartialEq\n    {\n        x.slice_contains(self)\n    }\n\n    /// Returns `true` if `needle` is a prefix of the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert!(v.starts_with(&[10]));\n    /// assert!(v.starts_with(&[10, 40]));\n    /// assert!(!v.starts_with(&[50]));\n    /// assert!(!v.starts_with(&[10, 50]));\n    /// ```\n    ///\n    /// Always returns `true` if `needle` is an empty slice:\n    ///\n    /// ```\n    /// let v = &[10, 40, 30];\n    /// assert!(v.starts_with(&[]));\n    /// let v: &[u8] = &[];\n    /// assert!(v.starts_with(&[]));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn starts_with(&self, needle: &[T]) -> bool\n        where T: PartialEq\n    {\n        let n = needle.len();\n        self.len() >= n && needle == &self[..n]\n    }\n\n    /// Returns `true` if `needle` is a suffix of the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let v = [10, 40, 30];\n    /// assert!(v.ends_with(&[30]));\n    /// assert!(v.ends_with(&[40, 30]));\n    /// assert!(!v.ends_with(&[50]));\n    /// assert!(!v.ends_with(&[50, 30]));\n    /// ```\n    ///\n    /// Always returns `true` if `needle` is an empty slice:\n    ///\n    /// ```\n    /// let v = &[10, 40, 30];\n    /// assert!(v.ends_with(&[]));\n    /// let v: &[u8] = &[];\n    /// assert!(v.ends_with(&[]));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ends_with(&self, needle: &[T]) -> bool\n        where T: PartialEq\n    {\n        let (m, n) = (self.len(), needle.len());\n        m >= n && needle == &self[m-n..]\n    }\n\n    /// Binary searches this sorted slice for a given element.\n    ///\n    /// If the value is found then [`Result::Ok`] is returned, containing the\n    /// index of the matching element. If there are multiple matches, then any\n    /// one of the matches could be returned. If the value is not found then\n    /// [`Result::Err`] is returned, containing the index where a matching\n    /// element could be inserted while maintaining sorted order.\n    ///\n    /// # Examples\n    ///\n    /// Looks up a series of four elements. The first is found, with a\n    /// uniquely determined position; the second and third are not\n    /// found; the fourth could match any position in `[1, 4]`.\n    ///\n    /// ```\n    /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];\n    ///\n    /// assert_eq!(s.binary_search(&13),  Ok(9));\n    /// assert_eq!(s.binary_search(&4),   Err(7));\n    /// assert_eq!(s.binary_search(&100), Err(13));\n    /// let r = s.binary_search(&1);\n    /// assert!(match r { Ok(1..=4) => true, _ => false, });\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn binary_search(&self, x: &T) -> Result<usize, usize>\n        where T: Ord\n    {\n        self.binary_search_by(|p| p.cmp(x))\n    }\n\n    /// Binary searches this sorted slice with a comparator function.\n    ///\n    /// The comparator function should implement an order consistent\n    /// with the sort order of the underlying slice, returning an\n    /// order code that indicates whether its argument is `Less`,\n    /// `Equal` or `Greater` the desired target.\n    ///\n    /// If the value is found then [`Result::Ok`] is returned, containing the\n    /// index of the matching element. If there are multiple matches, then any\n    /// one of the matches could be returned. If the value is not found then\n    /// [`Result::Err`] is returned, containing the index where a matching\n    /// element could be inserted while maintaining sorted order.\n    ///\n    /// # Examples\n    ///\n    /// Looks up a series of four elements. The first is found, with a\n    /// uniquely determined position; the second and third are not\n    /// found; the fourth could match any position in `[1, 4]`.\n    ///\n    /// ```\n    /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];\n    ///\n    /// let seek = 13;\n    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));\n    /// let seek = 4;\n    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));\n    /// let seek = 100;\n    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));\n    /// let seek = 1;\n    /// let r = s.binary_search_by(|probe| probe.cmp(&seek));\n    /// assert!(match r { Ok(1..=4) => true, _ => false, });\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn binary_search_by<'a, F>(&'a self, mut f: F) -> Result<usize, usize>\n        where F: FnMut(&'a T) -> Ordering\n    {\n        let s = self;\n        let mut size = s.len();\n        if size == 0 {\n            return Err(0);\n        }\n        let mut base = 0usize;\n        while size > 1 {\n            let half = size / 2;\n            let mid = base + half;\n            // mid is always in [0, size), that means mid is >= 0 and < size.\n            // mid >= 0: by definition\n            // mid < size: mid = size / 2 + size / 4 + size / 8 ...\n            let cmp = f(unsafe { s.get_unchecked(mid) });\n            base = if cmp == Greater { base } else { mid };\n            size -= half;\n        }\n        // base is always in [0, size) because base <= mid.\n        let cmp = f(unsafe { s.get_unchecked(base) });\n        if cmp == Equal { Ok(base) } else { Err(base + (cmp == Less) as usize) }\n\n    }\n\n    /// Binary searches this sorted slice with a key extraction function.\n    ///\n    /// Assumes that the slice is sorted by the key, for instance with\n    /// [`sort_by_key`] using the same key extraction function.\n    ///\n    /// If the value is found then [`Result::Ok`] is returned, containing the\n    /// index of the matching element. If there are multiple matches, then any\n    /// one of the matches could be returned. If the value is not found then\n    /// [`Result::Err`] is returned, containing the index where a matching\n    /// element could be inserted while maintaining sorted order.\n    ///\n    /// [`sort_by_key`]: #method.sort_by_key\n    ///\n    /// # Examples\n    ///\n    /// Looks up a series of four elements in a slice of pairs sorted by\n    /// their second elements. The first is found, with a uniquely\n    /// determined position; the second and third are not found; the\n    /// fourth could match any position in `[1, 4]`.\n    ///\n    /// ```\n    /// let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),\n    ///          (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),\n    ///          (1, 21), (2, 34), (4, 55)];\n    ///\n    /// assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b),  Ok(9));\n    /// assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b),   Err(7));\n    /// assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13));\n    /// let r = s.binary_search_by_key(&1, |&(a,b)| b);\n    /// assert!(match r { Ok(1..=4) => true, _ => false, });\n    /// ```\n    #[stable(feature = \"slice_binary_search_by_key\", since = \"1.10.0\")]\n    #[inline]\n    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, mut f: F) -> Result<usize, usize>\n        where F: FnMut(&'a T) -> B,\n              B: Ord\n    {\n        self.binary_search_by(|k| f(k).cmp(b))\n    }\n\n    /// Sorts the slice, but may not preserve the order of equal elements.\n    ///\n    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),\n    /// and `O(n log n)` worst-case.\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,\n    /// which combines the fast average case of randomized quicksort with the fast worst case of\n    /// heapsort, while achieving linear time on slices with certain patterns. It uses some\n    /// randomization to avoid degenerate cases, but with a fixed seed to always provide\n    /// deterministic behavior.\n    ///\n    /// It is typically faster than stable sorting, except in a few special cases, e.g. when the\n    /// slice consists of several concatenated sorted sequences.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [-5, 4, 1, -3, 2];\n    ///\n    /// v.sort_unstable();\n    /// assert!(v == [-5, -3, 1, 2, 4]);\n    /// ```\n    ///\n    /// [pdqsort]: https://github.com/orlp/pdqsort\n    #[stable(feature = \"sort_unstable\", since = \"1.20.0\")]\n    #[inline]\n    pub fn sort_unstable(&mut self)\n        where T: Ord\n    {\n        sort::quicksort(self, |a, b| a.lt(b));\n    }\n\n    /// Sorts the slice with a comparator function, but may not preserve the order of equal\n    /// elements.\n    ///\n    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),\n    /// and `O(n log n)` worst-case.\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,\n    /// which combines the fast average case of randomized quicksort with the fast worst case of\n    /// heapsort, while achieving linear time on slices with certain patterns. It uses some\n    /// randomization to avoid degenerate cases, but with a fixed seed to always provide\n    /// deterministic behavior.\n    ///\n    /// It is typically faster than stable sorting, except in a few special cases, e.g. when the\n    /// slice consists of several concatenated sorted sequences.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [5, 4, 1, 3, 2];\n    /// v.sort_unstable_by(|a, b| a.cmp(b));\n    /// assert!(v == [1, 2, 3, 4, 5]);\n    ///\n    /// // reverse sorting\n    /// v.sort_unstable_by(|a, b| b.cmp(a));\n    /// assert!(v == [5, 4, 3, 2, 1]);\n    /// ```\n    ///\n    /// [pdqsort]: https://github.com/orlp/pdqsort\n    #[stable(feature = \"sort_unstable\", since = \"1.20.0\")]\n    #[inline]\n    pub fn sort_unstable_by<F>(&mut self, mut compare: F)\n        where F: FnMut(&T, &T) -> Ordering\n    {\n        sort::quicksort(self, |a, b| compare(a, b) == Ordering::Less);\n    }\n\n    /// Sorts the slice with a key extraction function, but may not preserve the order of equal\n    /// elements.\n    ///\n    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),\n    /// and `O(m n log(m n))` worst-case, where the key function is `O(m)`.\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,\n    /// which combines the fast average case of randomized quicksort with the fast worst case of\n    /// heapsort, while achieving linear time on slices with certain patterns. It uses some\n    /// randomization to avoid degenerate cases, but with a fixed seed to always provide\n    /// deterministic behavior.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [-5i32, 4, 1, -3, 2];\n    ///\n    /// v.sort_unstable_by_key(|k| k.abs());\n    /// assert!(v == [1, 2, -3, 4, -5]);\n    /// ```\n    ///\n    /// [pdqsort]: https://github.com/orlp/pdqsort\n    #[stable(feature = \"sort_unstable\", since = \"1.20.0\")]\n    #[inline]\n    pub fn sort_unstable_by_key<K, F>(&mut self, mut f: F)\n        where F: FnMut(&T) -> K, K: Ord\n    {\n        sort::quicksort(self, |a, b| f(a).lt(&f(b)));\n    }\n\n    /// Moves all consecutive repeated elements to the end of the slice according to the\n    /// [`PartialEq`] trait implementation.\n    ///\n    /// Returns two slices. The first contains no consecutive repeated elements.\n    /// The second contains all the duplicates in no specified order.\n    ///\n    /// If the slice is sorted, the first returned slice contains no duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(slice_partition_dedup)]\n    ///\n    /// let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];\n    ///\n    /// let (dedup, duplicates) = slice.partition_dedup();\n    ///\n    /// assert_eq!(dedup, [1, 2, 3, 2, 1]);\n    /// assert_eq!(duplicates, [2, 3, 1]);\n    /// ```\n    #[unstable(feature = \"slice_partition_dedup\", issue = \"54279\")]\n    #[inline]\n    pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])\n        where T: PartialEq\n    {\n        self.partition_dedup_by(|a, b| a == b)\n    }\n\n    /// Moves all but the first of consecutive elements to the end of the slice satisfying\n    /// a given equality relation.\n    ///\n    /// Returns two slices. The first contains no consecutive repeated elements.\n    /// The second contains all the duplicates in no specified order.\n    ///\n    /// The `same_bucket` function is passed references to two elements from the slice and\n    /// must determine if the elements compare equal. The elements are passed in opposite order\n    /// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is moved\n    /// at the end of the slice.\n    ///\n    /// If the slice is sorted, the first returned slice contains no duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(slice_partition_dedup)]\n    ///\n    /// let mut slice = [\"foo\", \"Foo\", \"BAZ\", \"Bar\", \"bar\", \"baz\", \"BAZ\"];\n    ///\n    /// let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));\n    ///\n    /// assert_eq!(dedup, [\"foo\", \"BAZ\", \"Bar\", \"baz\"]);\n    /// assert_eq!(duplicates, [\"bar\", \"Foo\", \"BAZ\"]);\n    /// ```\n    #[unstable(feature = \"slice_partition_dedup\", issue = \"54279\")]\n    #[inline]\n    pub fn partition_dedup_by<F>(&mut self, mut same_bucket: F) -> (&mut [T], &mut [T])\n        where F: FnMut(&mut T, &mut T) -> bool\n    {\n        // Although we have a mutable reference to `self`, we cannot make\n        // *arbitrary* changes. The `same_bucket` calls could panic, so we\n        // must ensure that the slice is in a valid state at all times.\n        //\n        // The way that we handle this is by using swaps; we iterate\n        // over all the elements, swapping as we go so that at the end\n        // the elements we wish to keep are in the front, and those we\n        // wish to reject are at the back. We can then split the slice.\n        // This operation is still O(n).\n        //\n        // Example: We start in this state, where `r` represents \"next\n        // read\" and `w` represents \"next_write`.\n        //\n        //           r\n        //     +---+---+---+---+---+---+\n        //     | 0 | 1 | 1 | 2 | 3 | 3 |\n        //     +---+---+---+---+---+---+\n        //           w\n        //\n        // Comparing self[r] against self[w-1], this is not a duplicate, so\n        // we swap self[r] and self[w] (no effect as r==w) and then increment both\n        // r and w, leaving us with:\n        //\n        //               r\n        //     +---+---+---+---+---+---+\n        //     | 0 | 1 | 1 | 2 | 3 | 3 |\n        //     +---+---+---+---+---+---+\n        //               w\n        //\n        // Comparing self[r] against self[w-1], this value is a duplicate,\n        // so we increment `r` but leave everything else unchanged:\n        //\n        //                   r\n        //     +---+---+---+---+---+---+\n        //     | 0 | 1 | 1 | 2 | 3 | 3 |\n        //     +---+---+---+---+---+---+\n        //               w\n        //\n        // Comparing self[r] against self[w-1], this is not a duplicate,\n        // so swap self[r] and self[w] and advance r and w:\n        //\n        //                       r\n        //     +---+---+---+---+---+---+\n        //     | 0 | 1 | 2 | 1 | 3 | 3 |\n        //     +---+---+---+---+---+---+\n        //                   w\n        //\n        // Not a duplicate, repeat:\n        //\n        //                           r\n        //     +---+---+---+---+---+---+\n        //     | 0 | 1 | 2 | 3 | 1 | 3 |\n        //     +---+---+---+---+---+---+\n        //                       w\n        //\n        // Duplicate, advance r. End of slice. Split at w.\n\n        let len = self.len();\n        if len <= 1 {\n            return (self, &mut [])\n        }\n\n        let ptr = self.as_mut_ptr();\n        let mut next_read: usize = 1;\n        let mut next_write: usize = 1;\n\n        unsafe {\n            // Avoid bounds checks by using raw pointers.\n            while next_read < len {\n                let ptr_read = ptr.add(next_read);\n                let prev_ptr_write = ptr.add(next_write - 1);\n                if !same_bucket(&mut *ptr_read, &mut *prev_ptr_write) {\n                    if next_read != next_write {\n                        let ptr_write = prev_ptr_write.offset(1);\n                        mem::swap(&mut *ptr_read, &mut *ptr_write);\n                    }\n                    next_write += 1;\n                }\n                next_read += 1;\n            }\n        }\n\n        self.split_at_mut(next_write)\n    }\n\n    /// Moves all but the first of consecutive elements to the end of the slice that resolve\n    /// to the same key.\n    ///\n    /// Returns two slices. The first contains no consecutive repeated elements.\n    /// The second contains all the duplicates in no specified order.\n    ///\n    /// If the slice is sorted, the first returned slice contains no duplicates.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(slice_partition_dedup)]\n    ///\n    /// let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];\n    ///\n    /// let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);\n    ///\n    /// assert_eq!(dedup, [10, 20, 30, 20, 11]);\n    /// assert_eq!(duplicates, [21, 30, 13]);\n    /// ```\n    #[unstable(feature = \"slice_partition_dedup\", issue = \"54279\")]\n    #[inline]\n    pub fn partition_dedup_by_key<K, F>(&mut self, mut key: F) -> (&mut [T], &mut [T])\n        where F: FnMut(&mut T) -> K,\n              K: PartialEq,\n    {\n        self.partition_dedup_by(|a, b| key(a) == key(b))\n    }\n\n    /// Rotates the slice in-place such that the first `mid` elements of the\n    /// slice move to the end while the last `self.len() - mid` elements move to\n    /// the front. After calling `rotate_left`, the element previously at index\n    /// `mid` will become the first element in the slice.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if `mid` is greater than the length of the\n    /// slice. Note that `mid == self.len()` does _not_ panic and is a no-op\n    /// rotation.\n    ///\n    /// # Complexity\n    ///\n    /// Takes linear (in `self.len()`) time.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];\n    /// a.rotate_left(2);\n    /// assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);\n    /// ```\n    ///\n    /// Rotating a subslice:\n    ///\n    /// ```\n    /// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];\n    /// a[1..5].rotate_left(1);\n    /// assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);\n   /// ```\n    #[stable(feature = \"slice_rotate\", since = \"1.26.0\")]\n    pub fn rotate_left(&mut self, mid: usize) {\n        assert!(mid <= self.len());\n        let k = self.len() - mid;\n\n        unsafe {\n            let p = self.as_mut_ptr();\n            rotate::ptr_rotate(mid, p.add(mid), k);\n        }\n    }\n\n    /// Rotates the slice in-place such that the first `self.len() - k`\n    /// elements of the slice move to the end while the last `k` elements move\n    /// to the front. After calling `rotate_right`, the element previously at\n    /// index `self.len() - k` will become the first element in the slice.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if `k` is greater than the length of the\n    /// slice. Note that `k == self.len()` does _not_ panic and is a no-op\n    /// rotation.\n    ///\n    /// # Complexity\n    ///\n    /// Takes linear (in `self.len()`) time.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];\n    /// a.rotate_right(2);\n    /// assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);\n    /// ```\n    ///\n    /// Rotate a subslice:\n    ///\n    /// ```\n    /// let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];\n    /// a[1..5].rotate_right(1);\n    /// assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);\n    /// ```\n    #[stable(feature = \"slice_rotate\", since = \"1.26.0\")]\n    pub fn rotate_right(&mut self, k: usize) {\n        assert!(k <= self.len());\n        let mid = self.len() - k;\n\n        unsafe {\n            let p = self.as_mut_ptr();\n            rotate::ptr_rotate(mid, p.add(mid), k);\n        }\n    }\n\n    /// Copies the elements from `src` into `self`.\n    ///\n    /// The length of `src` must be the same as `self`.\n    ///\n    /// If `src` implements `Copy`, it can be more performant to use\n    /// [`copy_from_slice`].\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if the two slices have different lengths.\n    ///\n    /// # Examples\n    ///\n    /// Cloning two elements from a slice into another:\n    ///\n    /// ```\n    /// let src = [1, 2, 3, 4];\n    /// let mut dst = [0, 0];\n    ///\n    /// // Because the slices have to be the same length,\n    /// // we slice the source slice from four elements\n    /// // to two. It will panic if we don't do this.\n    /// dst.clone_from_slice(&src[2..]);\n    ///\n    /// assert_eq!(src, [1, 2, 3, 4]);\n    /// assert_eq!(dst, [3, 4]);\n    /// ```\n    ///\n    /// Rust enforces that there can only be one mutable reference with no\n    /// immutable references to a particular piece of data in a particular\n    /// scope. Because of this, attempting to use `clone_from_slice` on a\n    /// single slice will result in a compile failure:\n    ///\n    /// ```compile_fail\n    /// let mut slice = [1, 2, 3, 4, 5];\n    ///\n    /// slice[..2].clone_from_slice(&slice[3..]); // compile fail!\n    /// ```\n    ///\n    /// To work around this, we can use [`split_at_mut`] to create two distinct\n    /// sub-slices from a slice:\n    ///\n    /// ```\n    /// let mut slice = [1, 2, 3, 4, 5];\n    ///\n    /// {\n    ///     let (left, right) = slice.split_at_mut(2);\n    ///     left.clone_from_slice(&right[1..]);\n    /// }\n    ///\n    /// assert_eq!(slice, [4, 5, 3, 4, 5]);\n    /// ```\n    ///\n    /// [`copy_from_slice`]: #method.copy_from_slice\n    /// [`split_at_mut`]: #method.split_at_mut\n    #[stable(feature = \"clone_from_slice\", since = \"1.7.0\")]\n    pub fn clone_from_slice(&mut self, src: &[T]) where T: Clone {\n        assert!(self.len() == src.len(),\n                \"destination and source slices have different lengths\");\n        // NOTE: We need to explicitly slice them to the same length\n        // for bounds checking to be elided, and the optimizer will\n        // generate memcpy for simple cases (for example T = u8).\n        let len = self.len();\n        let src = &src[..len];\n        for i in 0..len {\n            self[i].clone_from(&src[i]);\n        }\n\n    }\n\n    /// Copies all elements from `src` into `self`, using a memcpy.\n    ///\n    /// The length of `src` must be the same as `self`.\n    ///\n    /// If `src` does not implement `Copy`, use [`clone_from_slice`].\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if the two slices have different lengths.\n    ///\n    /// # Examples\n    ///\n    /// Copying two elements from a slice into another:\n    ///\n    /// ```\n    /// let src = [1, 2, 3, 4];\n    /// let mut dst = [0, 0];\n    ///\n    /// // Because the slices have to be the same length,\n    /// // we slice the source slice from four elements\n    /// // to two. It will panic if we don't do this.\n    /// dst.copy_from_slice(&src[2..]);\n    ///\n    /// assert_eq!(src, [1, 2, 3, 4]);\n    /// assert_eq!(dst, [3, 4]);\n    /// ```\n    ///\n    /// Rust enforces that there can only be one mutable reference with no\n    /// immutable references to a particular piece of data in a particular\n    /// scope. Because of this, attempting to use `copy_from_slice` on a\n    /// single slice will result in a compile failure:\n    ///\n    /// ```compile_fail\n    /// let mut slice = [1, 2, 3, 4, 5];\n    ///\n    /// slice[..2].copy_from_slice(&slice[3..]); // compile fail!\n    /// ```\n    ///\n    /// To work around this, we can use [`split_at_mut`] to create two distinct\n    /// sub-slices from a slice:\n    ///\n    /// ```\n    /// let mut slice = [1, 2, 3, 4, 5];\n    ///\n    /// {\n    ///     let (left, right) = slice.split_at_mut(2);\n    ///     left.copy_from_slice(&right[1..]);\n    /// }\n    ///\n    /// assert_eq!(slice, [4, 5, 3, 4, 5]);\n    /// ```\n    ///\n    /// [`clone_from_slice`]: #method.clone_from_slice\n    /// [`split_at_mut`]: #method.split_at_mut\n    #[stable(feature = \"copy_from_slice\", since = \"1.9.0\")]\n    pub fn copy_from_slice(&mut self, src: &[T]) where T: Copy {\n        assert_eq!(self.len(), src.len(),\n                   \"destination and source slices have different lengths\");\n        unsafe {\n            ptr::copy_nonoverlapping(\n                src.as_ptr(), self.as_mut_ptr(), self.len());\n        }\n    }\n\n    /// Copies elements from one part of the slice to another part of itself,\n    /// using a memmove.\n    ///\n    /// `src` is the range within `self` to copy from. `dest` is the starting\n    /// index of the range within `self` to copy to, which will have the same\n    /// length as `src`. The two ranges may overlap. The ends of the two ranges\n    /// must be less than or equal to `self.len()`.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if either range exceeds the end of the slice,\n    /// or if the end of `src` is before the start.\n    ///\n    /// # Examples\n    ///\n    /// Copying four bytes within a slice:\n    ///\n    /// ```\n    /// # #![feature(copy_within)]\n    /// let mut bytes = *b\"Hello, World!\";\n    ///\n    /// bytes.copy_within(1..5, 8);\n    ///\n    /// assert_eq!(&bytes, b\"Hello, Wello!\");\n    /// ```\n    #[unstable(feature = \"copy_within\", issue = \"54236\")]\n    pub fn copy_within<R: ops::RangeBounds<usize>>(&mut self, src: R, dest: usize)\n    where\n        T: Copy,\n    {\n        let src_start = match src.start_bound() {\n            ops::Bound::Included(&n) => n,\n            ops::Bound::Excluded(&n) => n\n                .checked_add(1)\n                .unwrap_or_else(|| slice_index_overflow_fail()),\n            ops::Bound::Unbounded => 0,\n        };\n        let src_end = match src.end_bound() {\n            ops::Bound::Included(&n) => n\n                .checked_add(1)\n                .unwrap_or_else(|| slice_index_overflow_fail()),\n            ops::Bound::Excluded(&n) => n,\n            ops::Bound::Unbounded => self.len(),\n        };\n        assert!(src_start <= src_end, \"src end is before src start\");\n        assert!(src_end <= self.len(), \"src is out of bounds\");\n        let count = src_end - src_start;\n        assert!(dest <= self.len() - count, \"dest is out of bounds\");\n        unsafe {\n            ptr::copy(\n                self.get_unchecked(src_start),\n                self.get_unchecked_mut(dest),\n                count,\n            );\n        }\n    }\n\n    /// Swaps all elements in `self` with those in `other`.\n    ///\n    /// The length of `other` must be the same as `self`.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if the two slices have different lengths.\n    ///\n    /// # Example\n    ///\n    /// Swapping two elements across slices:\n    ///\n    /// ```\n    /// let mut slice1 = [0, 0];\n    /// let mut slice2 = [1, 2, 3, 4];\n    ///\n    /// slice1.swap_with_slice(&mut slice2[2..]);\n    ///\n    /// assert_eq!(slice1, [3, 4]);\n    /// assert_eq!(slice2, [1, 2, 0, 0]);\n    /// ```\n    ///\n    /// Rust enforces that there can only be one mutable reference to a\n    /// particular piece of data in a particular scope. Because of this,\n    /// attempting to use `swap_with_slice` on a single slice will result in\n    /// a compile failure:\n    ///\n    /// ```compile_fail\n    /// let mut slice = [1, 2, 3, 4, 5];\n    /// slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!\n    /// ```\n    ///\n    /// To work around this, we can use [`split_at_mut`] to create two distinct\n    /// mutable sub-slices from a slice:\n    ///\n    /// ```\n    /// let mut slice = [1, 2, 3, 4, 5];\n    ///\n    /// {\n    ///     let (left, right) = slice.split_at_mut(2);\n    ///     left.swap_with_slice(&mut right[1..]);\n    /// }\n    ///\n    /// assert_eq!(slice, [4, 5, 3, 1, 2]);\n    /// ```\n    ///\n    /// [`split_at_mut`]: #method.split_at_mut\n    #[stable(feature = \"swap_with_slice\", since = \"1.27.0\")]\n    pub fn swap_with_slice(&mut self, other: &mut [T]) {\n        assert!(self.len() == other.len(),\n                \"destination and source slices have different lengths\");\n        unsafe {\n            ptr::swap_nonoverlapping(\n                self.as_mut_ptr(), other.as_mut_ptr(), self.len());\n        }\n    }\n\n    /// Function to calculate lengths of the middle and trailing slice for `align_to{,_mut}`.\n    fn align_to_offsets<U>(&self) -> (usize, usize) {\n        // What we gonna do about `rest` is figure out what multiple of `U`s we can put in a\n        // lowest number of `T`s. And how many `T`s we need for each such \"multiple\".\n        //\n        // Consider for example T=u8 U=u16. Then we can put 1 U in 2 Ts. Simple. Now, consider\n        // for example a case where size_of::<T> = 16, size_of::<U> = 24. We can put 2 Us in\n        // place of every 3 Ts in the `rest` slice. A bit more complicated.\n        //\n        // Formula to calculate this is:\n        //\n        // Us = lcm(size_of::<T>, size_of::<U>) / size_of::<U>\n        // Ts = lcm(size_of::<T>, size_of::<U>) / size_of::<T>\n        //\n        // Expanded and simplified:\n        //\n        // Us = size_of::<T> / gcd(size_of::<T>, size_of::<U>)\n        // Ts = size_of::<U> / gcd(size_of::<T>, size_of::<U>)\n        //\n        // Luckily since all this is constant-evaluated... performance here matters not!\n        #[inline]\n        fn gcd(a: usize, b: usize) -> usize {\n            // iterative stein\u2019s algorithm\n            // We should still make this `const fn` (and revert to recursive algorithm if we do)\n            // because relying on llvm to consteval all this is\u2026 well, it makes me uncomfortable.\n            let (ctz_a, mut ctz_b) = unsafe {\n                if a == 0 { return b; }\n                if b == 0 { return a; }\n                (::intrinsics::cttz_nonzero(a), ::intrinsics::cttz_nonzero(b))\n            };\n            let k = ctz_a.min(ctz_b);\n            let mut a = a >> ctz_a;\n            let mut b = b;\n            loop {\n                // remove all factors of 2 from b\n                b >>= ctz_b;\n                if a > b {\n                    ::mem::swap(&mut a, &mut b);\n                }\n                b = b - a;\n                unsafe {\n                    if b == 0 {\n                        break;\n                    }\n                    ctz_b = ::intrinsics::cttz_nonzero(b);\n                }\n            }\n            a << k\n        }\n        let gcd: usize = gcd(::mem::size_of::<T>(), ::mem::size_of::<U>());\n        let ts: usize = ::mem::size_of::<U>() / gcd;\n        let us: usize = ::mem::size_of::<T>() / gcd;\n\n        // Armed with this knowledge, we can find how many `U`s we can fit!\n        let us_len = self.len() / ts * us;\n        // And how many `T`s will be in the trailing slice!\n        let ts_len = self.len() % ts;\n        (us_len, ts_len)\n    }\n\n    /// Transmute the slice to a slice of another type, ensuring alignment of the types is\n    /// maintained.\n    ///\n    /// This method splits the slice into three distinct slices: prefix, correctly aligned middle\n    /// slice of a new type, and the suffix slice. The method does a best effort to make the\n    /// middle slice the greatest length possible for a given type and input slice, but only\n    /// your algorithm's performance should depend on that, not its correctness.\n    ///\n    /// This method has no purpose when either input element `T` or output element `U` are\n    /// zero-sized and will return the original slice without splitting anything.\n    ///\n    /// # Unsafety\n    ///\n    /// This method is essentially a `transmute` with respect to the elements in the returned\n    /// middle slice, so all the usual caveats pertaining to `transmute::<T, U>` also apply here.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// unsafe {\n    ///     let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];\n    ///     let (prefix, shorts, suffix) = bytes.align_to::<u16>();\n    ///     // less_efficient_algorithm_for_bytes(prefix);\n    ///     // more_efficient_algorithm_for_aligned_shorts(shorts);\n    ///     // less_efficient_algorithm_for_bytes(suffix);\n    /// }\n    /// ```\n    #[stable(feature = \"slice_align_to\", since = \"1.30.0\")]\n    pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T]) {\n        // Note that most of this function will be constant-evaluated,\n        if ::mem::size_of::<U>() == 0 || ::mem::size_of::<T>() == 0 {\n            // handle ZSTs specially, which is \u2013 don't handle them at all.\n            return (self, &[], &[]);\n        }\n\n        // First, find at what point do we split between the first and 2nd slice. Easy with\n        // ptr.align_offset.\n        let ptr = self.as_ptr();\n        let offset = ::ptr::align_offset(ptr, ::mem::align_of::<U>());\n        if offset > self.len() {\n            (self, &[], &[])\n        } else {\n            let (left, rest) = self.split_at(offset);\n            // now `rest` is definitely aligned, so `from_raw_parts_mut` below is okay\n            let (us_len, ts_len) = rest.align_to_offsets::<U>();\n            (left,\n             from_raw_parts(rest.as_ptr() as *const U, us_len),\n             from_raw_parts(rest.as_ptr().add(rest.len() - ts_len), ts_len))\n        }\n    }\n\n    /// Transmute the slice to a slice of another type, ensuring alignment of the types is\n    /// maintained.\n    ///\n    /// This method splits the slice into three distinct slices: prefix, correctly aligned middle\n    /// slice of a new type, and the suffix slice. The method does a best effort to make the\n    /// middle slice the greatest length possible for a given type and input slice, but only\n    /// your algorithm's performance should depend on that, not its correctness.\n    ///\n    /// This method has no purpose when either input element `T` or output element `U` are\n    /// zero-sized and will return the original slice without splitting anything.\n    ///\n    /// # Unsafety\n    ///\n    /// This method is essentially a `transmute` with respect to the elements in the returned\n    /// middle slice, so all the usual caveats pertaining to `transmute::<T, U>` also apply here.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// unsafe {\n    ///     let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];\n    ///     let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();\n    ///     // less_efficient_algorithm_for_bytes(prefix);\n    ///     // more_efficient_algorithm_for_aligned_shorts(shorts);\n    ///     // less_efficient_algorithm_for_bytes(suffix);\n    /// }\n    /// ```\n    #[stable(feature = \"slice_align_to\", since = \"1.30.0\")]\n    pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T]) {\n        // Note that most of this function will be constant-evaluated,\n        if ::mem::size_of::<U>() == 0 || ::mem::size_of::<T>() == 0 {\n            // handle ZSTs specially, which is \u2013 don't handle them at all.\n            return (self, &mut [], &mut []);\n        }\n\n        // First, find at what point do we split between the first and 2nd slice. Easy with\n        // ptr.align_offset.\n        let ptr = self.as_ptr();\n        let offset = ::ptr::align_offset(ptr, ::mem::align_of::<U>());\n        if offset > self.len() {\n            (self, &mut [], &mut [])\n        } else {\n            let (left, rest) = self.split_at_mut(offset);\n            // now `rest` is definitely aligned, so `from_raw_parts_mut` below is okay\n            let (us_len, ts_len) = rest.align_to_offsets::<U>();\n            let mut_ptr = rest.as_mut_ptr();\n            (left,\n             from_raw_parts_mut(mut_ptr as *mut U, us_len),\n             from_raw_parts_mut(mut_ptr.add(rest.len() - ts_len), ts_len))\n        }\n    }\n}\n\n#[lang = \"slice_u8\"]\n#[cfg(not(test))]\nimpl [u8] {\n    /// Checks if all bytes in this slice are within the ASCII range.\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn is_ascii(&self) -> bool {\n        self.iter().all(|b| b.is_ascii())\n    }\n\n    /// Checks that two slices are an ASCII case-insensitive match.\n    ///\n    /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,\n    /// but without allocating and copying temporaries.\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool {\n        self.len() == other.len() &&\n            self.iter().zip(other).all(|(a, b)| {\n                a.eq_ignore_ascii_case(b)\n            })\n    }\n\n    /// Converts this slice to its ASCII upper case equivalent in-place.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new uppercased value without modifying the existing one, use\n    /// [`to_ascii_uppercase`].\n    ///\n    /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_uppercase(&mut self) {\n        for byte in self {\n            byte.make_ascii_uppercase();\n        }\n    }\n\n    /// Converts this slice to its ASCII lower case equivalent in-place.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new lowercased value without modifying the existing one, use\n    /// [`to_ascii_lowercase`].\n    ///\n    /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_lowercase(&mut self) {\n        for byte in self {\n            byte.make_ascii_lowercase();\n        }\n    }\n\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented = \"slice indices are of type `usize` or ranges of `usize`\"]\nimpl<T, I> ops::Index<I> for [T]\n    where I: SliceIndex<[T]>\n{\n    type Output = I::Output;\n\n    #[inline]\n    fn index(&self, index: I) -> &I::Output {\n        index.index(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented = \"slice indices are of type `usize` or ranges of `usize`\"]\nimpl<T, I> ops::IndexMut<I> for [T]\n    where I: SliceIndex<[T]>\n{\n    #[inline]\n    fn index_mut(&mut self, index: I) -> &mut I::Output {\n        index.index_mut(self)\n    }\n}\n\n#[inline(never)]\n#[cold]\nfn slice_index_len_fail(index: usize, len: usize) -> ! {\n    panic!(\"index {} out of range for slice of length {}\", index, len);\n}\n\n#[inline(never)]\n#[cold]\nfn slice_index_order_fail(index: usize, end: usize) -> ! {\n    panic!(\"slice index starts at {} but ends at {}\", index, end);\n}\n\n#[inline(never)]\n#[cold]\nfn slice_index_overflow_fail() -> ! {\n    panic!(\"attempted to index slice up to maximum usize\");\n}\n\nmod private_slice_index {\n    use super::ops;\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    pub trait Sealed {}\n\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for usize {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::Range<usize> {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::RangeTo<usize> {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::RangeFrom<usize> {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::RangeFull {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::RangeInclusive<usize> {}\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    impl Sealed for ops::RangeToInclusive<usize> {}\n}\n\n/// A helper trait used for indexing operations.\n#[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n#[rustc_on_unimplemented = \"slice indices are of type `usize` or ranges of `usize`\"]\npub trait SliceIndex<T: ?Sized>: private_slice_index::Sealed {\n    /// The output type returned by methods.\n    #[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\n    type Output: ?Sized;\n\n    /// Returns a shared reference to the output at this location, if in\n    /// bounds.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    fn get(self, slice: &T) -> Option<&Self::Output>;\n\n    /// Returns a mutable reference to the output at this location, if in\n    /// bounds.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    fn get_mut(self, slice: &mut T) -> Option<&mut Self::Output>;\n\n    /// Returns a shared reference to the output at this location, without\n    /// performing any bounds checking.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    unsafe fn get_unchecked(self, slice: &T) -> &Self::Output;\n\n    /// Returns a mutable reference to the output at this location, without\n    /// performing any bounds checking.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    unsafe fn get_unchecked_mut(self, slice: &mut T) -> &mut Self::Output;\n\n    /// Returns a shared reference to the output at this location, panicking\n    /// if out of bounds.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    fn index(self, slice: &T) -> &Self::Output;\n\n    /// Returns a mutable reference to the output at this location, panicking\n    /// if out of bounds.\n    #[unstable(feature = \"slice_index_methods\", issue = \"0\")]\n    fn index_mut(self, slice: &mut T) -> &mut Self::Output;\n}\n\n#[stable(feature = \"slice_get_slice_impls\", since = \"1.15.0\")]\nimpl<T> SliceIndex<[T]> for usize {\n    type Output = T;\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&T> {\n        if self < slice.len() {\n            unsafe {\n                Some(self.get_unchecked(slice))\n            }\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut T> {\n        if self < slice.len() {\n            unsafe {\n                Some(self.get_unchecked_mut(slice))\n            }\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &T {\n        &*slice.as_ptr().add(self)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut T {\n        &mut *slice.as_mut_ptr().add(self)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &T {\n        // NB: use intrinsic indexing\n        &(*slice)[self]\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut T {\n        // NB: use intrinsic indexing\n        &mut (*slice)[self]\n    }\n}\n\n#[stable(feature = \"slice_get_slice_impls\", since = \"1.15.0\")]\nimpl<T> SliceIndex<[T]> for  ops::Range<usize> {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        if self.start > self.end || self.end > slice.len() {\n            None\n        } else {\n            unsafe {\n                Some(self.get_unchecked(slice))\n            }\n        }\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        if self.start > self.end || self.end > slice.len() {\n            None\n        } else {\n            unsafe {\n                Some(self.get_unchecked_mut(slice))\n            }\n        }\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        from_raw_parts(slice.as_ptr().add(self.start), self.end - self.start)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        from_raw_parts_mut(slice.as_mut_ptr().add(self.start), self.end - self.start)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        if self.start > self.end {\n            slice_index_order_fail(self.start, self.end);\n        } else if self.end > slice.len() {\n            slice_index_len_fail(self.end, slice.len());\n        }\n        unsafe {\n            self.get_unchecked(slice)\n        }\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        if self.start > self.end {\n            slice_index_order_fail(self.start, self.end);\n        } else if self.end > slice.len() {\n            slice_index_len_fail(self.end, slice.len());\n        }\n        unsafe {\n            self.get_unchecked_mut(slice)\n        }\n    }\n}\n\n#[stable(feature = \"slice_get_slice_impls\", since = \"1.15.0\")]\nimpl<T> SliceIndex<[T]> for ops::RangeTo<usize> {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        (0..self.end).get(slice)\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        (0..self.end).get_mut(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        (0..self.end).get_unchecked(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        (0..self.end).get_unchecked_mut(slice)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        (0..self.end).index(slice)\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        (0..self.end).index_mut(slice)\n    }\n}\n\n#[stable(feature = \"slice_get_slice_impls\", since = \"1.15.0\")]\nimpl<T> SliceIndex<[T]> for ops::RangeFrom<usize> {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        (self.start..slice.len()).get(slice)\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        (self.start..slice.len()).get_mut(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        (self.start..slice.len()).get_unchecked(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        (self.start..slice.len()).get_unchecked_mut(slice)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        (self.start..slice.len()).index(slice)\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        (self.start..slice.len()).index_mut(slice)\n    }\n}\n\n#[stable(feature = \"slice_get_slice_impls\", since = \"1.15.0\")]\nimpl<T> SliceIndex<[T]> for ops::RangeFull {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        Some(slice)\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        Some(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        slice\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        slice\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        slice\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        slice\n    }\n}\n\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<T> SliceIndex<[T]> for ops::RangeInclusive<usize> {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        if *self.end() == usize::max_value() { None }\n        else { (*self.start()..self.end() + 1).get(slice) }\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        if *self.end() == usize::max_value() { None }\n        else { (*self.start()..self.end() + 1).get_mut(slice) }\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        (*self.start()..self.end() + 1).get_unchecked(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        (*self.start()..self.end() + 1).get_unchecked_mut(slice)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        if *self.end() == usize::max_value() { slice_index_overflow_fail(); }\n        (*self.start()..self.end() + 1).index(slice)\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        if *self.end() == usize::max_value() { slice_index_overflow_fail(); }\n        (*self.start()..self.end() + 1).index_mut(slice)\n    }\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<T> SliceIndex<[T]> for ops::RangeToInclusive<usize> {\n    type Output = [T];\n\n    #[inline]\n    fn get(self, slice: &[T]) -> Option<&[T]> {\n        (0..=self.end).get(slice)\n    }\n\n    #[inline]\n    fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]> {\n        (0..=self.end).get_mut(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked(self, slice: &[T]) -> &[T] {\n        (0..=self.end).get_unchecked(slice)\n    }\n\n    #[inline]\n    unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T] {\n        (0..=self.end).get_unchecked_mut(slice)\n    }\n\n    #[inline]\n    fn index(self, slice: &[T]) -> &[T] {\n        (0..=self.end).index(slice)\n    }\n\n    #[inline]\n    fn index_mut(self, slice: &mut [T]) -> &mut [T] {\n        (0..=self.end).index_mut(slice)\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Common traits\n////////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Default for &[T] {\n    /// Creates an empty slice.\n    fn default() -> Self { &[] }\n}\n\n#[stable(feature = \"mut_slice_default\", since = \"1.5.0\")]\nimpl<T> Default for &mut [T] {\n    /// Creates a mutable empty slice.\n    fn default() -> Self { &mut [] }\n}\n\n//\n// Iterators\n//\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> IntoIterator for &'a [T] {\n    type Item = &'a T;\n    type IntoIter = Iter<'a, T>;\n\n    fn into_iter(self) -> Iter<'a, T> {\n        self.iter()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> IntoIterator for &'a mut [T] {\n    type Item = &'a mut T;\n    type IntoIter = IterMut<'a, T>;\n\n    fn into_iter(self) -> IterMut<'a, T> {\n        self.iter_mut()\n    }\n}\n\n// Macro helper functions\n#[inline(always)]\nfn size_from_ptr<T>(_: *const T) -> usize {\n    mem::size_of::<T>()\n}\n\n// Inlining is_empty and len makes a huge performance difference\nmacro_rules! is_empty {\n    // The way we encode the length of a ZST iterator, this works both for ZST\n    // and non-ZST.\n    ($self: ident) => {$self.ptr == $self.end}\n}\n// To get rid of some bounds checks (see `position`), we compute the length in a somewhat\n// unexpected way. (Tested by `codegen/slice-position-bounds-check`.)\nmacro_rules! len {\n    ($self: ident) => {{\n        let start = $self.ptr;\n        let diff = ($self.end as usize).wrapping_sub(start as usize);\n        let size = size_from_ptr(start);\n        if size == 0 {\n            diff\n        } else {\n            // Using division instead of `offset_from` helps LLVM remove bounds checks\n            diff / size\n        }\n    }}\n}\n\n// The shared definition of the `Iter` and `IterMut` iterators\nmacro_rules! iterator {\n    (struct $name:ident -> $ptr:ty, $elem:ty, $raw_mut:tt, $( $mut_:tt )*) => {\n        impl<'a, T> $name<'a, T> {\n            // Helper function for creating a slice from the iterator.\n            #[inline(always)]\n            fn make_slice(&self) -> &'a [T] {\n                unsafe { from_raw_parts(self.ptr, len!(self)) }\n            }\n\n            // Helper function for moving the start of the iterator forwards by `offset` elements,\n            // returning the old start.\n            // Unsafe because the offset must be in-bounds or one-past-the-end.\n            #[inline(always)]\n            unsafe fn post_inc_start(&mut self, offset: isize) -> * $raw_mut T {\n                if mem::size_of::<T>() == 0 {\n                    // This is *reducing* the length.  `ptr` never changes with ZST.\n                    self.end = (self.end as * $raw_mut u8).wrapping_offset(-offset) as * $raw_mut T;\n                    self.ptr\n                } else {\n                    let old = self.ptr;\n                    self.ptr = self.ptr.offset(offset);\n                    old\n                }\n            }\n\n            // Helper function for moving the end of the iterator backwards by `offset` elements,\n            // returning the new end.\n            // Unsafe because the offset must be in-bounds or one-past-the-end.\n            #[inline(always)]\n            unsafe fn pre_dec_end(&mut self, offset: isize) -> * $raw_mut T {\n                if mem::size_of::<T>() == 0 {\n                    self.end = (self.end as * $raw_mut u8).wrapping_offset(-offset) as * $raw_mut T;\n                    self.ptr\n                } else {\n                    self.end = self.end.offset(-offset);\n                    self.end\n                }\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, T> ExactSizeIterator for $name<'a, T> {\n            #[inline(always)]\n            fn len(&self) -> usize {\n                len!(self)\n            }\n\n            #[inline(always)]\n            fn is_empty(&self) -> bool {\n                is_empty!(self)\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, T> Iterator for $name<'a, T> {\n            type Item = $elem;\n\n            #[inline]\n            fn next(&mut self) -> Option<$elem> {\n                // could be implemented with slices, but this avoids bounds checks\n                unsafe {\n                    assume(!self.ptr.is_null());\n                    if mem::size_of::<T>() != 0 {\n                        assume(!self.end.is_null());\n                    }\n                    if is_empty!(self) {\n                        None\n                    } else {\n                        Some(& $( $mut_ )* *self.post_inc_start(1))\n                    }\n                }\n            }\n\n            #[inline]\n            fn size_hint(&self) -> (usize, Option<usize>) {\n                let exact = len!(self);\n                (exact, Some(exact))\n            }\n\n            #[inline]\n            fn count(self) -> usize {\n                len!(self)\n            }\n\n            #[inline]\n            fn nth(&mut self, n: usize) -> Option<$elem> {\n                if n >= len!(self) {\n                    // This iterator is now empty.\n                    if mem::size_of::<T>() == 0 {\n                        // We have to do it this way as `ptr` may never be 0, but `end`\n                        // could be (due to wrapping).\n                        self.end = self.ptr;\n                    } else {\n                        self.ptr = self.end;\n                    }\n                    return None;\n                }\n                // We are in bounds. `offset` does the right thing even for ZSTs.\n                unsafe {\n                    let elem = Some(& $( $mut_ )* *self.ptr.add(n));\n                    self.post_inc_start((n as isize).wrapping_add(1));\n                    elem\n                }\n            }\n\n            #[inline]\n            fn last(mut self) -> Option<$elem> {\n                self.next_back()\n            }\n\n            #[inline]\n            fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n                Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n            {\n                // manual unrolling is needed when there are conditional exits from the loop\n                let mut accum = init;\n                unsafe {\n                    while len!(self) >= 4 {\n                        accum = f(accum, & $( $mut_ )* *self.post_inc_start(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.post_inc_start(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.post_inc_start(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.post_inc_start(1))?;\n                    }\n                    while !is_empty!(self) {\n                        accum = f(accum, & $( $mut_ )* *self.post_inc_start(1))?;\n                    }\n                }\n                Try::from_ok(accum)\n            }\n\n            #[inline]\n            fn fold<Acc, Fold>(mut self, init: Acc, mut f: Fold) -> Acc\n                where Fold: FnMut(Acc, Self::Item) -> Acc,\n            {\n                // Let LLVM unroll this, rather than using the default\n                // impl that would force the manual unrolling above\n                let mut accum = init;\n                while let Some(x) = self.next() {\n                    accum = f(accum, x);\n                }\n                accum\n            }\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn position<P>(&mut self, mut predicate: P) -> Option<usize> where\n                Self: Sized,\n                P: FnMut(Self::Item) -> bool,\n            {\n                // The addition might panic on overflow.\n                let n = len!(self);\n                self.try_fold(0, move |i, x| {\n                    if predicate(x) { Err(i) }\n                    else { Ok(i + 1) }\n                }).err()\n                    .map(|i| {\n                        unsafe { assume(i < n) };\n                        i\n                    })\n            }\n\n            #[inline]\n            fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where\n                P: FnMut(Self::Item) -> bool,\n                Self: Sized + ExactSizeIterator + DoubleEndedIterator\n            {\n                // No need for an overflow check here, because `ExactSizeIterator`\n                let n = len!(self);\n                self.try_rfold(n, move |i, x| {\n                    let i = i - 1;\n                    if predicate(x) { Err(i) }\n                    else { Ok(i) }\n                }).err()\n                    .map(|i| {\n                        unsafe { assume(i < n) };\n                        i\n                    })\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, T> DoubleEndedIterator for $name<'a, T> {\n            #[inline]\n            fn next_back(&mut self) -> Option<$elem> {\n                // could be implemented with slices, but this avoids bounds checks\n                unsafe {\n                    assume(!self.ptr.is_null());\n                    if mem::size_of::<T>() != 0 {\n                        assume(!self.end.is_null());\n                    }\n                    if is_empty!(self) {\n                        None\n                    } else {\n                        Some(& $( $mut_ )* *self.pre_dec_end(1))\n                    }\n                }\n            }\n\n            #[inline]\n            fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n                Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n            {\n                // manual unrolling is needed when there are conditional exits from the loop\n                let mut accum = init;\n                unsafe {\n                    while len!(self) >= 4 {\n                        accum = f(accum, & $( $mut_ )* *self.pre_dec_end(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.pre_dec_end(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.pre_dec_end(1))?;\n                        accum = f(accum, & $( $mut_ )* *self.pre_dec_end(1))?;\n                    }\n                    // inlining is_empty everywhere makes a huge performance difference\n                    while !is_empty!(self) {\n                        accum = f(accum, & $( $mut_ )* *self.pre_dec_end(1))?;\n                    }\n                }\n                Try::from_ok(accum)\n            }\n\n            #[inline]\n            fn rfold<Acc, Fold>(mut self, init: Acc, mut f: Fold) -> Acc\n                where Fold: FnMut(Acc, Self::Item) -> Acc,\n            {\n                // Let LLVM unroll this, rather than using the default\n                // impl that would force the manual unrolling above\n                let mut accum = init;\n                while let Some(x) = self.next_back() {\n                    accum = f(accum, x);\n                }\n                accum\n            }\n        }\n\n        #[stable(feature = \"fused\", since = \"1.26.0\")]\n        impl<'a, T> FusedIterator for $name<'a, T> {}\n\n        #[unstable(feature = \"trusted_len\", issue = \"37572\")]\n        unsafe impl<'a, T> TrustedLen for $name<'a, T> {}\n    }\n}\n\n/// Immutable slice iterator\n///\n/// This struct is created by the [`iter`] method on [slices].\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // First, we declare a type which has `iter` method to get the `Iter` struct (&[usize here]):\n/// let slice = &[1, 2, 3];\n///\n/// // Then, we iterate over it:\n/// for element in slice.iter() {\n///     println!(\"{}\", element);\n/// }\n/// ```\n///\n/// [`iter`]: ../../std/primitive.slice.html#method.iter\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Iter<'a, T: 'a> {\n    ptr: *const T,\n    end: *const T, // If T is a ZST, this is actually ptr+len.  This encoding is picked so that\n                   // ptr == end is a quick test for the Iterator being empty, that works\n                   // for both ZST and non-ZST.\n    _marker: marker::PhantomData<&'a T>,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug> fmt::Debug for Iter<'_, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"Iter\")\n            .field(&self.as_slice())\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Sync> Sync for Iter<'_, T> {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Sync> Send for Iter<'_, T> {}\n\nimpl<'a, T> Iter<'a, T> {\n    /// View the underlying data as a subslice of the original data.\n    ///\n    /// This has the same lifetime as the original slice, and so the\n    /// iterator can continue to be used while this exists.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // First, we declare a type which has the `iter` method to get the `Iter`\n    /// // struct (&[usize here]):\n    /// let slice = &[1, 2, 3];\n    ///\n    /// // Then, we get the iterator:\n    /// let mut iter = slice.iter();\n    /// // So if we print what `as_slice` method returns here, we have \"[1, 2, 3]\":\n    /// println!(\"{:?}\", iter.as_slice());\n    ///\n    /// // Next, we move to the second element of the slice:\n    /// iter.next();\n    /// // Now `as_slice` returns \"[2, 3]\":\n    /// println!(\"{:?}\", iter.as_slice());\n    /// ```\n    #[stable(feature = \"iter_to_slice\", since = \"1.4.0\")]\n    pub fn as_slice(&self) -> &'a [T] {\n        self.make_slice()\n    }\n}\n\niterator!{struct Iter -> *const T, &'a T, const, /* no mut */}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Clone for Iter<'_, T> {\n    fn clone(&self) -> Self { Iter { ptr: self.ptr, end: self.end, _marker: self._marker } }\n}\n\n#[stable(feature = \"slice_iter_as_ref\", since = \"1.13.0\")]\nimpl<T> AsRef<[T]> for Iter<'_, T> {\n    fn as_ref(&self) -> &[T] {\n        self.as_slice()\n    }\n}\n\n/// Mutable slice iterator.\n///\n/// This struct is created by the [`iter_mut`] method on [slices].\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // First, we declare a type which has `iter_mut` method to get the `IterMut`\n/// // struct (&[usize here]):\n/// let mut slice = &mut [1, 2, 3];\n///\n/// // Then, we iterate over it and increment each element value:\n/// for element in slice.iter_mut() {\n///     *element += 1;\n/// }\n///\n/// // We now have \"[2, 3, 4]\":\n/// println!(\"{:?}\", slice);\n/// ```\n///\n/// [`iter_mut`]: ../../std/primitive.slice.html#method.iter_mut\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IterMut<'a, T: 'a> {\n    ptr: *mut T,\n    end: *mut T, // If T is a ZST, this is actually ptr+len.  This encoding is picked so that\n                 // ptr == end is a quick test for the Iterator being empty, that works\n                 // for both ZST and non-ZST.\n    _marker: marker::PhantomData<&'a mut T>,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug> fmt::Debug for IterMut<'_, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"IterMut\")\n            .field(&self.make_slice())\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Sync> Sync for IterMut<'_, T> {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: Send> Send for IterMut<'_, T> {}\n\nimpl<'a, T> IterMut<'a, T> {\n    /// View the underlying data as a subslice of the original data.\n    ///\n    /// To avoid creating `&mut` references that alias, this is forced\n    /// to consume the iterator.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // First, we declare a type which has `iter_mut` method to get the `IterMut`\n    /// // struct (&[usize here]):\n    /// let mut slice = &mut [1, 2, 3];\n    ///\n    /// {\n    ///     // Then, we get the iterator:\n    ///     let mut iter = slice.iter_mut();\n    ///     // We move to next element:\n    ///     iter.next();\n    ///     // So if we print what `into_slice` method returns here, we have \"[2, 3]\":\n    ///     println!(\"{:?}\", iter.into_slice());\n    /// }\n    ///\n    /// // Now let's modify a value of the slice:\n    /// {\n    ///     // First we get back the iterator:\n    ///     let mut iter = slice.iter_mut();\n    ///     // We change the value of the first element of the slice returned by the `next` method:\n    ///     *iter.next().unwrap() += 1;\n    /// }\n    /// // Now slice is \"[2, 2, 3]\":\n    /// println!(\"{:?}\", slice);\n    /// ```\n    #[stable(feature = \"iter_to_slice\", since = \"1.4.0\")]\n    pub fn into_slice(self) -> &'a mut [T] {\n        unsafe { from_raw_parts_mut(self.ptr, len!(self)) }\n    }\n}\n\niterator!{struct IterMut -> *mut T, &'a mut T, mut, mut}\n\n/// An internal abstraction over the splitting iterators, so that\n/// splitn, splitn_mut etc can be implemented once.\n#[doc(hidden)]\ntrait SplitIter: DoubleEndedIterator {\n    /// Marks the underlying iterator as complete, extracting the remaining\n    /// portion of the slice.\n    fn finish(&mut self) -> Option<Self::Item>;\n}\n\n/// An iterator over subslices separated by elements that match a predicate\n/// function.\n///\n/// This struct is created by the [`split`] method on [slices].\n///\n/// [`split`]: ../../std/primitive.slice.html#method.split\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Split<'a, T:'a, P> where P: FnMut(&T) -> bool {\n    v: &'a [T],\n    pred: P,\n    finished: bool\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for Split<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Split\")\n            .field(\"v\", &self.v)\n            .field(\"finished\", &self.finished)\n            .finish()\n    }\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T, P> Clone for Split<'_, T, P> where P: Clone + FnMut(&T) -> bool {\n    fn clone(&self) -> Self {\n        Split {\n            v: self.v,\n            pred: self.pred.clone(),\n            finished: self.finished,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T, P> Iterator for Split<'a, T, P> where P: FnMut(&T) -> bool {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.finished { return None; }\n\n        match self.v.iter().position(|x| (self.pred)(x)) {\n            None => self.finish(),\n            Some(idx) => {\n                let ret = Some(&self.v[..idx]);\n                self.v = &self.v[idx + 1..];\n                ret\n            }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.finished {\n            (0, Some(0))\n        } else {\n            (1, Some(self.v.len() + 1))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T, P> DoubleEndedIterator for Split<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.finished { return None; }\n\n        match self.v.iter().rposition(|x| (self.pred)(x)) {\n            None => self.finish(),\n            Some(idx) => {\n                let ret = Some(&self.v[idx + 1..]);\n                self.v = &self.v[..idx];\n                ret\n            }\n        }\n    }\n}\n\nimpl<'a, T, P> SplitIter for Split<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn finish(&mut self) -> Option<&'a [T]> {\n        if self.finished { None } else { self.finished = true; Some(self.v) }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T, P> FusedIterator for Split<'_, T, P> where P: FnMut(&T) -> bool {}\n\n/// An iterator over the subslices of the vector which are separated\n/// by elements that match `pred`.\n///\n/// This struct is created by the [`split_mut`] method on [slices].\n///\n/// [`split_mut`]: ../../std/primitive.slice.html#method.split_mut\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct SplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {\n    v: &'a mut [T],\n    pred: P,\n    finished: bool\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for SplitMut<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SplitMut\")\n            .field(\"v\", &self.v)\n            .field(\"finished\", &self.finished)\n            .finish()\n    }\n}\n\nimpl<'a, T, P> SplitIter for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn finish(&mut self) -> Option<&'a mut [T]> {\n        if self.finished {\n            None\n        } else {\n            self.finished = true;\n            Some(mem::replace(&mut self.v, &mut []))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T, P> Iterator for SplitMut<'a, T, P> where P: FnMut(&T) -> bool {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        if self.finished { return None; }\n\n        let idx_opt = { // work around borrowck limitations\n            let pred = &mut self.pred;\n            self.v.iter().position(|x| (*pred)(x))\n        };\n        match idx_opt {\n            None => self.finish(),\n            Some(idx) => {\n                let tmp = mem::replace(&mut self.v, &mut []);\n                let (head, tail) = tmp.split_at_mut(idx);\n                self.v = &mut tail[1..];\n                Some(head)\n            }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.finished {\n            (0, Some(0))\n        } else {\n            // if the predicate doesn't match anything, we yield one slice\n            // if it matches every element, we yield len+1 empty slices.\n            (1, Some(self.v.len() + 1))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T, P> DoubleEndedIterator for SplitMut<'a, T, P> where\n    P: FnMut(&T) -> bool,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        if self.finished { return None; }\n\n        let idx_opt = { // work around borrowck limitations\n            let pred = &mut self.pred;\n            self.v.iter().rposition(|x| (*pred)(x))\n        };\n        match idx_opt {\n            None => self.finish(),\n            Some(idx) => {\n                let tmp = mem::replace(&mut self.v, &mut []);\n                let (head, tail) = tmp.split_at_mut(idx);\n                self.v = head;\n                Some(&mut tail[1..])\n            }\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T, P> FusedIterator for SplitMut<'_, T, P> where P: FnMut(&T) -> bool {}\n\n/// An iterator over subslices separated by elements that match a predicate\n/// function, starting from the end of the slice.\n///\n/// This struct is created by the [`rsplit`] method on [slices].\n///\n/// [`rsplit`]: ../../std/primitive.slice.html#method.rsplit\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\n#[derive(Clone)] // Is this correct, or does it incorrectly require `T: Clone`?\npub struct RSplit<'a, T:'a, P> where P: FnMut(&T) -> bool {\n    inner: Split<'a, T, P>\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for RSplit<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RSplit\")\n            .field(\"v\", &self.inner.v)\n            .field(\"finished\", &self.inner.finished)\n            .finish()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> Iterator for RSplit<'a, T, P> where P: FnMut(&T) -> bool {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        self.inner.next_back()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> DoubleEndedIterator for RSplit<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        self.inner.next()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> SplitIter for RSplit<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn finish(&mut self) -> Option<&'a [T]> {\n        self.inner.finish()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<T, P> FusedIterator for RSplit<'_, T, P> where P: FnMut(&T) -> bool {}\n\n/// An iterator over the subslices of the vector which are separated\n/// by elements that match `pred`, starting from the end of the slice.\n///\n/// This struct is created by the [`rsplit_mut`] method on [slices].\n///\n/// [`rsplit_mut`]: ../../std/primitive.slice.html#method.rsplit_mut\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\npub struct RSplitMut<'a, T:'a, P> where P: FnMut(&T) -> bool {\n    inner: SplitMut<'a, T, P>\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for RSplitMut<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RSplitMut\")\n            .field(\"v\", &self.inner.v)\n            .field(\"finished\", &self.inner.finished)\n            .finish()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> SplitIter for RSplitMut<'a, T, P> where P: FnMut(&T) -> bool {\n    #[inline]\n    fn finish(&mut self) -> Option<&'a mut [T]> {\n        self.inner.finish()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> Iterator for RSplitMut<'a, T, P> where P: FnMut(&T) -> bool {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        self.inner.next_back()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<'a, T, P> DoubleEndedIterator for RSplitMut<'a, T, P> where\n    P: FnMut(&T) -> bool,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        self.inner.next()\n    }\n}\n\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\nimpl<T, P> FusedIterator for RSplitMut<'_, T, P> where P: FnMut(&T) -> bool {}\n\n/// An private iterator over subslices separated by elements that\n/// match a predicate function, splitting at most a fixed number of\n/// times.\n#[derive(Debug)]\nstruct GenericSplitN<I> {\n    iter: I,\n    count: usize,\n}\n\nimpl<T, I: SplitIter<Item=T>> Iterator for GenericSplitN<I> {\n    type Item = T;\n\n    #[inline]\n    fn next(&mut self) -> Option<T> {\n        match self.count {\n            0 => None,\n            1 => { self.count -= 1; self.iter.finish() }\n            _ => { self.count -= 1; self.iter.next() }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (lower, upper_opt) = self.iter.size_hint();\n        (lower, upper_opt.map(|upper| cmp::min(self.count, upper)))\n    }\n}\n\n/// An iterator over subslices separated by elements that match a predicate\n/// function, limited to a given number of splits.\n///\n/// This struct is created by the [`splitn`] method on [slices].\n///\n/// [`splitn`]: ../../std/primitive.slice.html#method.splitn\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct SplitN<'a, T: 'a, P> where P: FnMut(&T) -> bool {\n    inner: GenericSplitN<Split<'a, T, P>>\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for SplitN<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SplitN\")\n            .field(\"inner\", &self.inner)\n            .finish()\n    }\n}\n\n/// An iterator over subslices separated by elements that match a\n/// predicate function, limited to a given number of splits, starting\n/// from the end of the slice.\n///\n/// This struct is created by the [`rsplitn`] method on [slices].\n///\n/// [`rsplitn`]: ../../std/primitive.slice.html#method.rsplitn\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RSplitN<'a, T: 'a, P> where P: FnMut(&T) -> bool {\n    inner: GenericSplitN<RSplit<'a, T, P>>\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for RSplitN<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RSplitN\")\n            .field(\"inner\", &self.inner)\n            .finish()\n    }\n}\n\n/// An iterator over subslices separated by elements that match a predicate\n/// function, limited to a given number of splits.\n///\n/// This struct is created by the [`splitn_mut`] method on [slices].\n///\n/// [`splitn_mut`]: ../../std/primitive.slice.html#method.splitn_mut\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct SplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {\n    inner: GenericSplitN<SplitMut<'a, T, P>>\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for SplitNMut<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SplitNMut\")\n            .field(\"inner\", &self.inner)\n            .finish()\n    }\n}\n\n/// An iterator over subslices separated by elements that match a\n/// predicate function, limited to a given number of splits, starting\n/// from the end of the slice.\n///\n/// This struct is created by the [`rsplitn_mut`] method on [slices].\n///\n/// [`rsplitn_mut`]: ../../std/primitive.slice.html#method.rsplitn_mut\n/// [slices]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RSplitNMut<'a, T: 'a, P> where P: FnMut(&T) -> bool {\n    inner: GenericSplitN<RSplitMut<'a, T, P>>\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: fmt::Debug, P> fmt::Debug for RSplitNMut<'_, T, P> where P: FnMut(&T) -> bool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RSplitNMut\")\n            .field(\"inner\", &self.inner)\n            .finish()\n    }\n}\n\nmacro_rules! forward_iterator {\n    ($name:ident: $elem:ident, $iter_of:ty) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, $elem, P> Iterator for $name<'a, $elem, P> where\n            P: FnMut(&T) -> bool\n        {\n            type Item = $iter_of;\n\n            #[inline]\n            fn next(&mut self) -> Option<$iter_of> {\n                self.inner.next()\n            }\n\n            #[inline]\n            fn size_hint(&self) -> (usize, Option<usize>) {\n                self.inner.size_hint()\n            }\n        }\n\n        #[stable(feature = \"fused\", since = \"1.26.0\")]\n        impl<'a, $elem, P> FusedIterator for $name<'a, $elem, P>\n            where P: FnMut(&T) -> bool {}\n    }\n}\n\nforward_iterator! { SplitN: T, &'a [T] }\nforward_iterator! { RSplitN: T, &'a [T] }\nforward_iterator! { SplitNMut: T, &'a mut [T] }\nforward_iterator! { RSplitNMut: T, &'a mut [T] }\n\n/// An iterator over overlapping subslices of length `size`.\n///\n/// This struct is created by the [`windows`] method on [slices].\n///\n/// [`windows`]: ../../std/primitive.slice.html#method.windows\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Windows<'a, T:'a> {\n    v: &'a [T],\n    size: usize\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Clone for Windows<'_, T> {\n    fn clone(&self) -> Self {\n        Windows {\n            v: self.v,\n            size: self.size,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> Iterator for Windows<'a, T> {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.size > self.v.len() {\n            None\n        } else {\n            let ret = Some(&self.v[..self.size]);\n            self.v = &self.v[1..];\n            ret\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.size > self.v.len() {\n            (0, Some(0))\n        } else {\n            let size = self.v.len() - self.size + 1;\n            (size, Some(size))\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let (end, overflow) = self.size.overflowing_add(n);\n        if end > self.v.len() || overflow {\n            self.v = &[];\n            None\n        } else {\n            let nth = &self.v[n..end];\n            self.v = &self.v[n+1..];\n            Some(nth)\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        if self.size > self.v.len() {\n            None\n        } else {\n            let start = self.v.len() - self.size;\n            Some(&self.v[start..])\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> DoubleEndedIterator for Windows<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.size > self.v.len() {\n            None\n        } else {\n            let ret = Some(&self.v[self.v.len()-self.size..]);\n            self.v = &self.v[..self.v.len()-1];\n            ret\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for Windows<'_, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for Windows<'_, T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for Windows<'_, T> {}\n\n#[doc(hidden)]\nunsafe impl<'a, T> TrustedRandomAccess for Windows<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {\n        from_raw_parts(self.v.as_ptr().add(i), self.size)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a\n/// time), starting at the beginning of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last slice\n/// of the iteration will be the remainder.\n///\n/// This struct is created by the [`chunks`] method on [slices].\n///\n/// [`chunks`]: ../../std/primitive.slice.html#method.chunks\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Chunks<'a, T:'a> {\n    v: &'a [T],\n    chunk_size: usize\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Clone for Chunks<'_, T> {\n    fn clone(&self) -> Self {\n        Chunks {\n            v: self.v,\n            chunk_size: self.chunk_size,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> Iterator for Chunks<'a, T> {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let chunksz = cmp::min(self.v.len(), self.chunk_size);\n            let (fst, snd) = self.v.split_at(chunksz);\n            self.v = snd;\n            Some(fst)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.v.is_empty() {\n            (0, Some(0))\n        } else {\n            let n = self.v.len() / self.chunk_size;\n            let rem = self.v.len() % self.chunk_size;\n            let n = if rem > 0 { n+1 } else { n };\n            (n, Some(n))\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let (start, overflow) = n.overflowing_mul(self.chunk_size);\n        if start >= self.v.len() || overflow {\n            self.v = &[];\n            None\n        } else {\n            let end = match start.checked_add(self.chunk_size) {\n                Some(sum) => cmp::min(self.v.len(), sum),\n                None => self.v.len(),\n            };\n            let nth = &self.v[start..end];\n            self.v = &self.v[end..];\n            Some(nth)\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;\n            Some(&self.v[start..])\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> DoubleEndedIterator for Chunks<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let remainder = self.v.len() % self.chunk_size;\n            let chunksz = if remainder != 0 { remainder } else { self.chunk_size };\n            let (fst, snd) = self.v.split_at(self.v.len() - chunksz);\n            self.v = fst;\n            Some(snd)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for Chunks<'_, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for Chunks<'_, T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for Chunks<'_, T> {}\n\n#[doc(hidden)]\nunsafe impl<'a, T> TrustedRandomAccess for Chunks<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {\n        let start = i * self.chunk_size;\n        let end = match start.checked_add(self.chunk_size) {\n            None => self.v.len(),\n            Some(end) => cmp::min(end, self.v.len()),\n        };\n        from_raw_parts(self.v.as_ptr().add(start), end - start)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`\n/// elements at a time), starting at the beginning of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last slice\n/// of the iteration will be the remainder.\n///\n/// This struct is created by the [`chunks_mut`] method on [slices].\n///\n/// [`chunks_mut`]: ../../std/primitive.slice.html#method.chunks_mut\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct ChunksMut<'a, T:'a> {\n    v: &'a mut [T],\n    chunk_size: usize\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> Iterator for ChunksMut<'a, T> {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let sz = cmp::min(self.v.len(), self.chunk_size);\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(sz);\n            self.v = tail;\n            Some(head)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.v.is_empty() {\n            (0, Some(0))\n        } else {\n            let n = self.v.len() / self.chunk_size;\n            let rem = self.v.len() % self.chunk_size;\n            let n = if rem > 0 { n + 1 } else { n };\n            (n, Some(n))\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {\n        let (start, overflow) = n.overflowing_mul(self.chunk_size);\n        if start >= self.v.len() || overflow {\n            self.v = &mut [];\n            None\n        } else {\n            let end = match start.checked_add(self.chunk_size) {\n                Some(sum) => cmp::min(self.v.len(), sum),\n                None => self.v.len(),\n            };\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(end);\n            let (_, nth) =  head.split_at_mut(start);\n            self.v = tail;\n            Some(nth)\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let start = (self.v.len() - 1) / self.chunk_size * self.chunk_size;\n            Some(&mut self.v[start..])\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T> DoubleEndedIterator for ChunksMut<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let remainder = self.v.len() % self.chunk_size;\n            let sz = if remainder != 0 { remainder } else { self.chunk_size };\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let tmp_len = tmp.len();\n            let (head, tail) = tmp.split_at_mut(tmp_len - sz);\n            self.v = head;\n            Some(tail)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ExactSizeIterator for ChunksMut<'_, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for ChunksMut<'_, T> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<T> FusedIterator for ChunksMut<'_, T> {}\n\n#[doc(hidden)]\nunsafe impl<'a, T> TrustedRandomAccess for ChunksMut<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {\n        let start = i * self.chunk_size;\n        let end = match start.checked_add(self.chunk_size) {\n            None => self.v.len(),\n            Some(end) => cmp::min(end, self.v.len()),\n        };\n        from_raw_parts_mut(self.v.as_mut_ptr().add(start), end - start)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a\n/// time), starting at the beginning of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last\n/// up to `chunk_size-1` elements will be omitted but can be retrieved from\n/// the [`remainder`] function from the iterator.\n///\n/// This struct is created by the [`chunks_exact`] method on [slices].\n///\n/// [`chunks_exact`]: ../../std/primitive.slice.html#method.chunks_exact\n/// [`remainder`]: ../../std/slice/struct.ChunksExact.html#method.remainder\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\npub struct ChunksExact<'a, T:'a> {\n    v: &'a [T],\n    rem: &'a [T],\n    chunk_size: usize\n}\n\nimpl<'a, T> ChunksExact<'a, T> {\n    /// Return the remainder of the original slice that is not going to be\n    /// returned by the iterator. The returned slice has at most `chunk_size-1`\n    /// elements.\n    #[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\n    pub fn remainder(&self) -> &'a [T] {\n        self.rem\n    }\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<T> Clone for ChunksExact<'_, T> {\n    fn clone(&self) -> Self {\n        ChunksExact {\n            v: self.v,\n            rem: self.rem,\n            chunk_size: self.chunk_size,\n        }\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for ChunksExact<'a, T> {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let (fst, snd) = self.v.split_at(self.chunk_size);\n            self.v = snd;\n            Some(fst)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.v.len() / self.chunk_size;\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let (start, overflow) = n.overflowing_mul(self.chunk_size);\n        if start >= self.v.len() || overflow {\n            self.v = &[];\n            None\n        } else {\n            let (_, snd) = self.v.split_at(start);\n            self.v = snd;\n            self.next()\n        }\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<Self::Item> {\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for ChunksExact<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let (fst, snd) = self.v.split_at(self.v.len() - self.chunk_size);\n            self.v = fst;\n            Some(snd)\n        }\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<T> ExactSizeIterator for ChunksExact<'_, T> {\n    fn is_empty(&self) -> bool {\n        self.v.is_empty()\n    }\n}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for ChunksExact<'_, T> {}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<T> FusedIterator for ChunksExact<'_, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for ChunksExact<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {\n        let start = i * self.chunk_size;\n        from_raw_parts(self.v.as_ptr().add(start), self.chunk_size)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`\n/// elements at a time), starting at the beginning of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last up to\n/// `chunk_size-1` elements will be omitted but can be retrieved from the\n/// [`into_remainder`] function from the iterator.\n///\n/// This struct is created by the [`chunks_exact_mut`] method on [slices].\n///\n/// [`chunks_exact_mut`]: ../../std/primitive.slice.html#method.chunks_exact_mut\n/// [`into_remainder`]: ../../std/slice/struct.ChunksExactMut.html#method.into_remainder\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\npub struct ChunksExactMut<'a, T:'a> {\n    v: &'a mut [T],\n    rem: &'a mut [T],\n    chunk_size: usize\n}\n\nimpl<'a, T> ChunksExactMut<'a, T> {\n    /// Return the remainder of the original slice that is not going to be\n    /// returned by the iterator. The returned slice has at most `chunk_size-1`\n    /// elements.\n    #[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\n    pub fn into_remainder(self) -> &'a mut [T] {\n        self.rem\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for ChunksExactMut<'a, T> {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(self.chunk_size);\n            self.v = tail;\n            Some(head)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.v.len() / self.chunk_size;\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {\n        let (start, overflow) = n.overflowing_mul(self.chunk_size);\n        if start >= self.v.len() || overflow {\n            self.v = &mut [];\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (_, snd) = tmp.split_at_mut(start);\n            self.v = snd;\n            self.next()\n        }\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<Self::Item> {\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for ChunksExactMut<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let tmp_len = tmp.len();\n            let (head, tail) = tmp.split_at_mut(tmp_len - self.chunk_size);\n            self.v = head;\n            Some(tail)\n        }\n    }\n}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<T> ExactSizeIterator for ChunksExactMut<'_, T> {\n    fn is_empty(&self) -> bool {\n        self.v.is_empty()\n    }\n}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<T> TrustedLen for ChunksExactMut<'_, T> {}\n\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nimpl<T> FusedIterator for ChunksExactMut<'_, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for ChunksExactMut<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {\n        let start = i * self.chunk_size;\n        from_raw_parts_mut(self.v.as_mut_ptr().add(start), self.chunk_size)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a\n/// time), starting at the end of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last slice\n/// of the iteration will be the remainder.\n///\n/// This struct is created by the [`rchunks`] method on [slices].\n///\n/// [`rchunks`]: ../../std/primitive.slice.html#method.rchunks\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\npub struct RChunks<'a, T:'a> {\n    v: &'a [T],\n    chunk_size: usize\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Clone for RChunks<'a, T> {\n    fn clone(&self) -> RChunks<'a, T> {\n        RChunks {\n            v: self.v,\n            chunk_size: self.chunk_size,\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for RChunks<'a, T> {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let chunksz = cmp::min(self.v.len(), self.chunk_size);\n            let (fst, snd) = self.v.split_at(self.v.len() - chunksz);\n            self.v = fst;\n            Some(snd)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.v.is_empty() {\n            (0, Some(0))\n        } else {\n            let n = self.v.len() / self.chunk_size;\n            let rem = self.v.len() % self.chunk_size;\n            let n = if rem > 0 { n+1 } else { n };\n            (n, Some(n))\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let (end, overflow) = n.overflowing_mul(self.chunk_size);\n        if end >= self.v.len() || overflow {\n            self.v = &[];\n            None\n        } else {\n            // Can't underflow because of the check above\n            let end = self.v.len() - end;\n            let start = match end.checked_sub(self.chunk_size) {\n                Some(sum) => sum,\n                None => 0,\n            };\n            let nth = &self.v[start..end];\n            self.v = &self.v[0..start];\n            Some(nth)\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let rem = self.v.len() % self.chunk_size;\n            let end = if rem == 0 { self.chunk_size } else { rem };\n            Some(&self.v[0..end])\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for RChunks<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let remainder = self.v.len() % self.chunk_size;\n            let chunksz = if remainder != 0 { remainder } else { self.chunk_size };\n            let (fst, snd) = self.v.split_at(chunksz);\n            self.v = snd;\n            Some(fst)\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> ExactSizeIterator for RChunks<'a, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<'a, T> TrustedLen for RChunks<'a, T> {}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> FusedIterator for RChunks<'a, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for RChunks<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {\n        let end = self.v.len() - i * self.chunk_size;\n        let start = match end.checked_sub(self.chunk_size) {\n            None => 0,\n            Some(start) => start,\n        };\n        from_raw_parts(self.v.as_ptr().add(start), end - start)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`\n/// elements at a time), starting at the end of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last slice\n/// of the iteration will be the remainder.\n///\n/// This struct is created by the [`rchunks_mut`] method on [slices].\n///\n/// [`rchunks_mut`]: ../../std/primitive.slice.html#method.rchunks_mut\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\npub struct RChunksMut<'a, T:'a> {\n    v: &'a mut [T],\n    chunk_size: usize\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for RChunksMut<'a, T> {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let sz = cmp::min(self.v.len(), self.chunk_size);\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let tmp_len = tmp.len();\n            let (head, tail) = tmp.split_at_mut(tmp_len - sz);\n            self.v = head;\n            Some(tail)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.v.is_empty() {\n            (0, Some(0))\n        } else {\n            let n = self.v.len() / self.chunk_size;\n            let rem = self.v.len() % self.chunk_size;\n            let n = if rem > 0 { n + 1 } else { n };\n            (n, Some(n))\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {\n        let (end, overflow) = n.overflowing_mul(self.chunk_size);\n        if end >= self.v.len() || overflow {\n            self.v = &mut [];\n            None\n        } else {\n            // Can't underflow because of the check above\n            let end = self.v.len() - end;\n            let start = match end.checked_sub(self.chunk_size) {\n                Some(sum) => sum,\n                None => 0,\n            };\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(start);\n            let (nth, _) = tail.split_at_mut(end - start);\n            self.v = head;\n            Some(nth)\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<Self::Item> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let rem = self.v.len() % self.chunk_size;\n            let end = if rem == 0 { self.chunk_size } else { rem };\n            Some(&mut self.v[0..end])\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for RChunksMut<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        if self.v.is_empty() {\n            None\n        } else {\n            let remainder = self.v.len() % self.chunk_size;\n            let sz = if remainder != 0 { remainder } else { self.chunk_size };\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(sz);\n            self.v = tail;\n            Some(head)\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> ExactSizeIterator for RChunksMut<'a, T> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<'a, T> TrustedLen for RChunksMut<'a, T> {}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> FusedIterator for RChunksMut<'a, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for RChunksMut<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {\n        let end = self.v.len() - i * self.chunk_size;\n        let start = match end.checked_sub(self.chunk_size) {\n            None => 0,\n            Some(start) => start,\n        };\n        from_raw_parts_mut(self.v.as_mut_ptr().add(start), end - start)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a\n/// time), starting at the end of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last\n/// up to `chunk_size-1` elements will be omitted but can be retrieved from\n/// the [`remainder`] function from the iterator.\n///\n/// This struct is created by the [`rchunks_exact`] method on [slices].\n///\n/// [`rchunks_exact`]: ../../std/primitive.slice.html#method.rchunks_exact\n/// [`remainder`]: ../../std/slice/struct.ChunksExact.html#method.remainder\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\npub struct RChunksExact<'a, T:'a> {\n    v: &'a [T],\n    rem: &'a [T],\n    chunk_size: usize\n}\n\nimpl<'a, T> RChunksExact<'a, T> {\n    /// Return the remainder of the original slice that is not going to be\n    /// returned by the iterator. The returned slice has at most `chunk_size-1`\n    /// elements.\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    pub fn remainder(&self) -> &'a [T] {\n        self.rem\n    }\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Clone for RChunksExact<'a, T> {\n    fn clone(&self) -> RChunksExact<'a, T> {\n        RChunksExact {\n            v: self.v,\n            rem: self.rem,\n            chunk_size: self.chunk_size,\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for RChunksExact<'a, T> {\n    type Item = &'a [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let (fst, snd) = self.v.split_at(self.v.len() - self.chunk_size);\n            self.v = fst;\n            Some(snd)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.v.len() / self.chunk_size;\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let (end, overflow) = n.overflowing_mul(self.chunk_size);\n        if end >= self.v.len() || overflow {\n            self.v = &[];\n            None\n        } else {\n            let (fst, _) = self.v.split_at(self.v.len() - end);\n            self.v = fst;\n            self.next()\n        }\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<Self::Item> {\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for RChunksExact<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let (fst, snd) = self.v.split_at(self.chunk_size);\n            self.v = snd;\n            Some(fst)\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> ExactSizeIterator for RChunksExact<'a, T> {\n    fn is_empty(&self) -> bool {\n        self.v.is_empty()\n    }\n}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<'a, T> TrustedLen for RChunksExact<'a, T> {}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> FusedIterator for RChunksExact<'a, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for RChunksExact<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a [T] {\n        let end = self.v.len() - i * self.chunk_size;\n        let start = end - self.chunk_size;\n        from_raw_parts(self.v.as_ptr().add(start), self.chunk_size)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n/// An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size`\n/// elements at a time), starting at the end of the slice.\n///\n/// When the slice len is not evenly divided by the chunk size, the last up to\n/// `chunk_size-1` elements will be omitted but can be retrieved from the\n/// [`into_remainder`] function from the iterator.\n///\n/// This struct is created by the [`rchunks_exact_mut`] method on [slices].\n///\n/// [`rchunks_exact_mut`]: ../../std/primitive.slice.html#method.rchunks_exact_mut\n/// [`into_remainder`]: ../../std/slice/struct.ChunksExactMut.html#method.into_remainder\n/// [slices]: ../../std/primitive.slice.html\n#[derive(Debug)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\npub struct RChunksExactMut<'a, T:'a> {\n    v: &'a mut [T],\n    rem: &'a mut [T],\n    chunk_size: usize\n}\n\nimpl<'a, T> RChunksExactMut<'a, T> {\n    /// Return the remainder of the original slice that is not going to be\n    /// returned by the iterator. The returned slice has at most `chunk_size-1`\n    /// elements.\n    #[stable(feature = \"rchunks\", since = \"1.31.0\")]\n    pub fn into_remainder(self) -> &'a mut [T] {\n        self.rem\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> Iterator for RChunksExactMut<'a, T> {\n    type Item = &'a mut [T];\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let tmp_len = tmp.len();\n            let (head, tail) = tmp.split_at_mut(tmp_len - self.chunk_size);\n            self.v = head;\n            Some(tail)\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.v.len() / self.chunk_size;\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<&'a mut [T]> {\n        let (end, overflow) = n.overflowing_mul(self.chunk_size);\n        if end >= self.v.len() || overflow {\n            self.v = &mut [];\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let tmp_len = tmp.len();\n            let (fst, _) = tmp.split_at_mut(tmp_len - end);\n            self.v = fst;\n            self.next()\n        }\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<Self::Item> {\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> DoubleEndedIterator for RChunksExactMut<'a, T> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut [T]> {\n        if self.v.len() < self.chunk_size {\n            None\n        } else {\n            let tmp = mem::replace(&mut self.v, &mut []);\n            let (head, tail) = tmp.split_at_mut(self.chunk_size);\n            self.v = tail;\n            Some(head)\n        }\n    }\n}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> ExactSizeIterator for RChunksExactMut<'a, T> {\n    fn is_empty(&self) -> bool {\n        self.v.is_empty()\n    }\n}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<'a, T> TrustedLen for RChunksExactMut<'a, T> {}\n\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nimpl<'a, T> FusedIterator for RChunksExactMut<'a, T> {}\n\n#[doc(hidden)]\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\nunsafe impl<'a, T> TrustedRandomAccess for RChunksExactMut<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut [T] {\n        let end = self.v.len() - i * self.chunk_size;\n        let start = end - self.chunk_size;\n        from_raw_parts_mut(self.v.as_mut_ptr().add(start), self.chunk_size)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n//\n// Free functions\n//\n\n/// Forms a slice from a pointer and a length.\n///\n/// The `len` argument is the number of **elements**, not the number of bytes.\n///\n/// # Safety\n///\n/// This function is unsafe as there is no guarantee that the given pointer is\n/// valid for `len` elements, nor whether the lifetime inferred is a suitable\n/// lifetime for the returned slice.\n///\n/// `data` must be non-null and aligned, even for zero-length slices. One\n/// reason for this is that enum layout optimizations may rely on references\n/// (including slices of any length) being aligned and non-null to distinguish\n/// them from other data. You can obtain a pointer that is usable as `data`\n/// for zero-length slices using [`NonNull::dangling()`].\n///\n/// The total size of the slice must be no larger than `isize::MAX` **bytes**\n/// in memory. See the safety documentation of [`pointer::offset`].\n///\n/// # Caveat\n///\n/// The lifetime for the returned slice is inferred from its usage. To\n/// prevent accidental misuse, it's suggested to tie the lifetime to whichever\n/// source lifetime is safe in the context, such as by providing a helper\n/// function taking the lifetime of a host value for the slice, or by explicit\n/// annotation.\n///\n/// # Examples\n///\n/// ```\n/// use std::slice;\n///\n/// // manifest a slice for a single element\n/// let x = 42;\n/// let ptr = &x as *const _;\n/// let slice = unsafe { slice::from_raw_parts(ptr, 1) };\n/// assert_eq!(slice[0], 42);\n/// ```\n///\n/// [`NonNull::dangling()`]: ../../std/ptr/struct.NonNull.html#method.dangling\n/// [`pointer::offset`]: ../../std/primitive.pointer.html#method.offset\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T] {\n    debug_assert!(data as usize % mem::align_of::<T>() == 0, \"attempt to create unaligned slice\");\n    debug_assert!(mem::size_of::<T>().saturating_mul(len) <= isize::MAX as usize,\n                  \"attempt to create slice covering half the address space\");\n    Repr { raw: FatPtr { data, len } }.rust\n}\n\n/// Performs the same functionality as [`from_raw_parts`], except that a\n/// mutable slice is returned.\n///\n/// This function is unsafe for the same reasons as [`from_raw_parts`], as well\n/// as not being able to provide a non-aliasing guarantee of the returned\n/// mutable slice. `data` must be non-null and aligned even for zero-length\n/// slices as with [`from_raw_parts`]. The total size of the slice must be no\n/// larger than `isize::MAX` **bytes** in memory.\n///\n/// See the documentation of [`from_raw_parts`] for more details.\n///\n/// [`from_raw_parts`]: ../../std/slice/fn.from_raw_parts.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T] {\n    debug_assert!(data as usize % mem::align_of::<T>() == 0, \"attempt to create unaligned slice\");\n    debug_assert!(mem::size_of::<T>().saturating_mul(len) <= isize::MAX as usize,\n                  \"attempt to create slice covering half the address space\");\n    Repr { raw: FatPtr { data, len } }.rust_mut\n}\n\n/// Converts a reference to T into a slice of length 1 (without copying).\n#[stable(feature = \"from_ref\", since = \"1.28.0\")]\npub fn from_ref<T>(s: &T) -> &[T] {\n    unsafe {\n        from_raw_parts(s, 1)\n    }\n}\n\n/// Converts a reference to T into a slice of length 1 (without copying).\n#[stable(feature = \"from_ref\", since = \"1.28.0\")]\npub fn from_mut<T>(s: &mut T) -> &mut [T] {\n    unsafe {\n        from_raw_parts_mut(s, 1)\n    }\n}\n\n// This function is public only because there is no other way to unit test heapsort.\n#[unstable(feature = \"sort_internals\", reason = \"internal to sort module\", issue = \"0\")]\n#[doc(hidden)]\npub fn heapsort<T, F>(v: &mut [T], mut is_less: F)\n    where F: FnMut(&T, &T) -> bool\n{\n    sort::heapsort(v, &mut is_less);\n}\n\n//\n// Comparison traits\n//\n\nextern {\n    /// Calls implementation provided memcmp.\n    ///\n    /// Interprets the data as u8.\n    ///\n    /// Returns 0 for equal, < 0 for less than and > 0 for greater\n    /// than.\n    // FIXME(#32610): Return type should be c_int\n    fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32;\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> PartialEq<[B]> for [A] where A: PartialEq<B> {\n    fn eq(&self, other: &[B]) -> bool {\n        SlicePartialEq::equal(self, other)\n    }\n\n    fn ne(&self, other: &[B]) -> bool {\n        SlicePartialEq::not_equal(self, other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Eq> Eq for [T] {}\n\n/// Implements comparison of vectors lexicographically.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Ord> Ord for [T] {\n    fn cmp(&self, other: &[T]) -> Ordering {\n        SliceOrd::compare(self, other)\n    }\n}\n\n/// Implements comparison of vectors lexicographically.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: PartialOrd> PartialOrd for [T] {\n    fn partial_cmp(&self, other: &[T]) -> Option<Ordering> {\n        SlicePartialOrd::partial_compare(self, other)\n    }\n}\n\n#[doc(hidden)]\n// intermediate trait for specialization of slice's PartialEq\ntrait SlicePartialEq<B> {\n    fn equal(&self, other: &[B]) -> bool;\n\n    fn not_equal(&self, other: &[B]) -> bool { !self.equal(other) }\n}\n\n// Generic slice equality\nimpl<A, B> SlicePartialEq<B> for [A]\n    where A: PartialEq<B>\n{\n    default fn equal(&self, other: &[B]) -> bool {\n        if self.len() != other.len() {\n            return false;\n        }\n\n        for i in 0..self.len() {\n            if !self[i].eq(&other[i]) {\n                return false;\n            }\n        }\n\n        true\n    }\n}\n\n// Use memcmp for bytewise equality when the types allow\nimpl<A> SlicePartialEq<A> for [A]\n    where A: PartialEq<A> + BytewiseEquality\n{\n    fn equal(&self, other: &[A]) -> bool {\n        if self.len() != other.len() {\n            return false;\n        }\n        if self.as_ptr() == other.as_ptr() {\n            return true;\n        }\n        unsafe {\n            let size = mem::size_of_val(self);\n            memcmp(self.as_ptr() as *const u8,\n                   other.as_ptr() as *const u8, size) == 0\n        }\n    }\n}\n\n#[doc(hidden)]\n// intermediate trait for specialization of slice's PartialOrd\ntrait SlicePartialOrd<B> {\n    fn partial_compare(&self, other: &[B]) -> Option<Ordering>;\n}\n\nimpl<A> SlicePartialOrd<A> for [A]\n    where A: PartialOrd\n{\n    default fn partial_compare(&self, other: &[A]) -> Option<Ordering> {\n        let l = cmp::min(self.len(), other.len());\n\n        // Slice to the loop iteration range to enable bound check\n        // elimination in the compiler\n        let lhs = &self[..l];\n        let rhs = &other[..l];\n\n        for i in 0..l {\n            match lhs[i].partial_cmp(&rhs[i]) {\n                Some(Ordering::Equal) => (),\n                non_eq => return non_eq,\n            }\n        }\n\n        self.len().partial_cmp(&other.len())\n    }\n}\n\nimpl<A> SlicePartialOrd<A> for [A]\n    where A: Ord\n{\n    default fn partial_compare(&self, other: &[A]) -> Option<Ordering> {\n        Some(SliceOrd::compare(self, other))\n    }\n}\n\n#[doc(hidden)]\n// intermediate trait for specialization of slice's Ord\ntrait SliceOrd<B> {\n    fn compare(&self, other: &[B]) -> Ordering;\n}\n\nimpl<A> SliceOrd<A> for [A]\n    where A: Ord\n{\n    default fn compare(&self, other: &[A]) -> Ordering {\n        let l = cmp::min(self.len(), other.len());\n\n        // Slice to the loop iteration range to enable bound check\n        // elimination in the compiler\n        let lhs = &self[..l];\n        let rhs = &other[..l];\n\n        for i in 0..l {\n            match lhs[i].cmp(&rhs[i]) {\n                Ordering::Equal => (),\n                non_eq => return non_eq,\n            }\n        }\n\n        self.len().cmp(&other.len())\n    }\n}\n\n// memcmp compares a sequence of unsigned bytes lexicographically.\n// this matches the order we want for [u8], but no others (not even [i8]).\nimpl SliceOrd<u8> for [u8] {\n    #[inline]\n    fn compare(&self, other: &[u8]) -> Ordering {\n        let order = unsafe {\n            memcmp(self.as_ptr(), other.as_ptr(),\n                   cmp::min(self.len(), other.len()))\n        };\n        if order == 0 {\n            self.len().cmp(&other.len())\n        } else if order < 0 {\n            Less\n        } else {\n            Greater\n        }\n    }\n}\n\n#[doc(hidden)]\n/// Trait implemented for types that can be compared for equality using\n/// their bytewise representation\ntrait BytewiseEquality { }\n\nmacro_rules! impl_marker_for {\n    ($traitname:ident, $($ty:ty)*) => {\n        $(\n            impl $traitname for $ty { }\n        )*\n    }\n}\n\nimpl_marker_for!(BytewiseEquality,\n                 u8 i8 u16 i16 u32 i32 u64 i64 usize isize char bool);\n\n#[doc(hidden)]\nunsafe impl<'a, T> TrustedRandomAccess for Iter<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a T {\n        &*self.ptr.add(i)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\n#[doc(hidden)]\nunsafe impl<'a, T> TrustedRandomAccess for IterMut<'a, T> {\n    unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut T {\n        &mut *self.ptr.add(i)\n    }\n    fn may_have_side_effect() -> bool { false }\n}\n\ntrait SliceContains: Sized {\n    fn slice_contains(&self, x: &[Self]) -> bool;\n}\n\nimpl<T> SliceContains for T where T: PartialEq {\n    default fn slice_contains(&self, x: &[Self]) -> bool {\n        x.iter().any(|y| *y == *self)\n    }\n}\n\nimpl SliceContains for u8 {\n    fn slice_contains(&self, x: &[Self]) -> bool {\n        memchr::memchr(*self, x).is_some()\n    }\n}\n\nimpl SliceContains for i8 {\n    fn slice_contains(&self, x: &[Self]) -> bool {\n        let byte = *self as u8;\n        let bytes: &[u8] = unsafe { from_raw_parts(x.as_ptr() as *const u8, x.len()) };\n        memchr::memchr(byte, bytes).is_some()\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Basic functions for dealing with memory.\n//!\n//! This module contains functions for querying the size and alignment of\n//! types, initializing and manipulating memory.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse clone;\nuse cmp;\nuse fmt;\nuse hash;\nuse intrinsics;\nuse marker::{Copy, PhantomData, Sized};\nuse ptr;\nuse ops::{Deref, DerefMut};\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use intrinsics::transmute;\n\n/// Takes ownership and \"forgets\" about the value **without running its destructor**.\n///\n/// Any resources the value manages, such as heap memory or a file handle, will linger\n/// forever in an unreachable state. However, it does not guarantee that pointers\n/// to this memory will remain valid.\n///\n/// * If you want to leak memory, see [`Box::leak`][leak].\n/// * If you want to obtain a raw pointer to the memory, see [`Box::into_raw`][into_raw].\n/// * If you want to dispose of a value properly, running its destructor, see\n/// [`mem::drop`][drop].\n///\n/// # Safety\n///\n/// `forget` is not marked as `unsafe`, because Rust's safety guarantees\n/// do not include a guarantee that destructors will always run. For example,\n/// a program can create a reference cycle using [`Rc`][rc], or call\n/// [`process::exit`][exit] to exit without running destructors. Thus, allowing\n/// `mem::forget` from safe code does not fundamentally change Rust's safety\n/// guarantees.\n///\n/// That said, leaking resources such as memory or I/O objects is usually undesirable,\n/// so `forget` is only recommended for specialized use cases like those shown below.\n///\n/// Because forgetting a value is allowed, any `unsafe` code you write must\n/// allow for this possibility. You cannot return a value and expect that the\n/// caller will necessarily run the value's destructor.\n///\n/// [rc]: ../../std/rc/struct.Rc.html\n/// [exit]: ../../std/process/fn.exit.html\n///\n/// # Examples\n///\n/// Leak an I/O object, never closing the file:\n///\n/// ```no_run\n/// use std::mem;\n/// use std::fs::File;\n///\n/// let file = File::open(\"foo.txt\").unwrap();\n/// mem::forget(file);\n/// ```\n///\n/// The practical use cases for `forget` are rather specialized and mainly come\n/// up in unsafe or FFI code.\n///\n/// ## Use case 1\n///\n/// You have created an uninitialized value using [`mem::uninitialized`][uninit].\n/// You must either initialize or `forget` it on every computation path before\n/// Rust drops it automatically, like at the end of a scope or after a panic.\n/// Running the destructor on an uninitialized value would be [undefined behavior][ub].\n///\n/// ```\n/// use std::mem;\n/// use std::ptr;\n///\n/// # let some_condition = false;\n/// unsafe {\n///     let mut uninit_vec: Vec<u32> = mem::uninitialized();\n///\n///     if some_condition {\n///         // Initialize the variable.\n///         ptr::write(&mut uninit_vec, Vec::new());\n///     } else {\n///         // Forget the uninitialized value so its destructor doesn't run.\n///         mem::forget(uninit_vec);\n///     }\n/// }\n/// ```\n///\n/// ## Use case 2\n///\n/// You have duplicated the bytes making up a value, without doing a proper\n/// [`Clone`][clone]. You need the value's destructor to run only once,\n/// because a double `free` is undefined behavior.\n///\n/// An example is a possible implementation of [`mem::swap`][swap]:\n///\n/// ```\n/// use std::mem;\n/// use std::ptr;\n///\n/// # #[allow(dead_code)]\n/// fn swap<T>(x: &mut T, y: &mut T) {\n///     unsafe {\n///         // Give ourselves some scratch space to work with\n///         let mut t: T = mem::uninitialized();\n///\n///         // Perform the swap, `&mut` pointers never alias\n///         ptr::copy_nonoverlapping(&*x, &mut t, 1);\n///         ptr::copy_nonoverlapping(&*y, x, 1);\n///         ptr::copy_nonoverlapping(&t, y, 1);\n///\n///         // y and t now point to the same thing, but we need to completely\n///         // forget `t` because we do not want to run the destructor for `T`\n///         // on its value, which is still owned somewhere outside this function.\n///         mem::forget(t);\n///     }\n/// }\n/// ```\n///\n/// [drop]: fn.drop.html\n/// [uninit]: fn.uninitialized.html\n/// [clone]: ../clone/trait.Clone.html\n/// [swap]: fn.swap.html\n/// [FFI]: ../../book/first-edition/ffi.html\n/// [box]: ../../std/boxed/struct.Box.html\n/// [leak]: ../../std/boxed/struct.Box.html#method.leak\n/// [into_raw]: ../../std/boxed/struct.Box.html#method.into_raw\n/// [ub]: ../../reference/behavior-considered-undefined.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn forget<T>(t: T) {\n    ManuallyDrop::new(t);\n}\n\n/// Returns the size of a type in bytes.\n///\n/// More specifically, this is the offset in bytes between successive elements\n/// in an array with that item type including alignment padding. Thus, for any\n/// type `T` and length `n`, `[T; n]` has a size of `n * size_of::<T>()`.\n///\n/// In general, the size of a type is not stable across compilations, but\n/// specific types such as primitives are.\n///\n/// The following table gives the size for primitives.\n///\n/// Type | size_of::\\<Type>()\n/// ---- | ---------------\n/// () | 0\n/// bool | 1\n/// u8 | 1\n/// u16 | 2\n/// u32 | 4\n/// u64 | 8\n/// u128 | 16\n/// i8 | 1\n/// i16 | 2\n/// i32 | 4\n/// i64 | 8\n/// i128 | 16\n/// f32 | 4\n/// f64 | 8\n/// char | 4\n///\n/// Furthermore, `usize` and `isize` have the same size.\n///\n/// The types `*const T`, `&T`, `Box<T>`, `Option<&T>`, and `Option<Box<T>>` all have\n/// the same size. If `T` is Sized, all of those types have the same size as `usize`.\n///\n/// The mutability of a pointer does not change its size. As such, `&T` and `&mut T`\n/// have the same size. Likewise for `*const T` and `*mut T`.\n///\n/// # Size of `#[repr(C)]` items\n///\n/// The `C` representation for items has a defined layout. With this layout,\n/// the size of items is also stable as long as all fields have a stable size.\n///\n/// ## Size of Structs\n///\n/// For `structs`, the size is determined by the following algorithm.\n///\n/// For each field in the struct ordered by declaration order:\n///\n/// 1. Add the size of the field.\n/// 2. Round up the current size to the nearest multiple of the next field's [alignment].\n///\n/// Finally, round the size of the struct to the nearest multiple of its [alignment].\n/// The alignment of the struct is usually the largest alignment of all its\n/// fields; this can be changed with the use of `repr(align(N))`.\n///\n/// Unlike `C`, zero sized structs are not rounded up to one byte in size.\n///\n/// ## Size of Enums\n///\n/// Enums that carry no data other than the descriminant have the same size as C enums\n/// on the platform they are compiled for.\n///\n/// ## Size of Unions\n///\n/// The size of a union is the size of its largest field.\n///\n/// Unlike `C`, zero sized unions are not rounded up to one byte in size.\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// // Some primitives\n/// assert_eq!(4, mem::size_of::<i32>());\n/// assert_eq!(8, mem::size_of::<f64>());\n/// assert_eq!(0, mem::size_of::<()>());\n///\n/// // Some arrays\n/// assert_eq!(8, mem::size_of::<[i32; 2]>());\n/// assert_eq!(12, mem::size_of::<[i32; 3]>());\n/// assert_eq!(0, mem::size_of::<[i32; 0]>());\n///\n///\n/// // Pointer size equality\n/// assert_eq!(mem::size_of::<&i32>(), mem::size_of::<*const i32>());\n/// assert_eq!(mem::size_of::<&i32>(), mem::size_of::<Box<i32>>());\n/// assert_eq!(mem::size_of::<&i32>(), mem::size_of::<Option<&i32>>());\n/// assert_eq!(mem::size_of::<Box<i32>>(), mem::size_of::<Option<Box<i32>>>());\n/// ```\n///\n/// Using `#[repr(C)]`.\n///\n/// ```\n/// use std::mem;\n///\n/// #[repr(C)]\n/// struct FieldStruct {\n///     first: u8,\n///     second: u16,\n///     third: u8\n/// }\n///\n/// // The size of the first field is 1, so add 1 to the size. Size is 1.\n/// // The alignment of the second field is 2, so add 1 to the size for padding. Size is 2.\n/// // The size of the second field is 2, so add 2 to the size. Size is 4.\n/// // The alignment of the third field is 1, so add 0 to the size for padding. Size is 4.\n/// // The size of the third field is 1, so add 1 to the size. Size is 5.\n/// // Finally, the alignment of the struct is 2 (because the largest alignment amongst its\n/// // fields is 2), so add 1 to the size for padding. Size is 6.\n/// assert_eq!(6, mem::size_of::<FieldStruct>());\n///\n/// #[repr(C)]\n/// struct TupleStruct(u8, u16, u8);\n///\n/// // Tuple structs follow the same rules.\n/// assert_eq!(6, mem::size_of::<TupleStruct>());\n///\n/// // Note that reordering the fields can lower the size. We can remove both padding bytes\n/// // by putting `third` before `second`.\n/// #[repr(C)]\n/// struct FieldStructOptimized {\n///     first: u8,\n///     third: u8,\n///     second: u16\n/// }\n///\n/// assert_eq!(4, mem::size_of::<FieldStructOptimized>());\n///\n/// // Union size is the size of the largest field.\n/// #[repr(C)]\n/// union ExampleUnion {\n///     smaller: u8,\n///     larger: u16\n/// }\n///\n/// assert_eq!(2, mem::size_of::<ExampleUnion>());\n/// ```\n///\n/// [alignment]: ./fn.align_of.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_promotable]\npub const fn size_of<T>() -> usize {\n    intrinsics::size_of::<T>()\n}\n\n/// Returns the size of the pointed-to value in bytes.\n///\n/// This is usually the same as `size_of::<T>()`. However, when `T` *has* no\n/// statically known size, e.g. a slice [`[T]`][slice] or a [trait object],\n/// then `size_of_val` can be used to get the dynamically-known size.\n///\n/// [slice]: ../../std/primitive.slice.html\n/// [trait object]: ../../book/first-edition/trait-objects.html\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// assert_eq!(4, mem::size_of_val(&5i32));\n///\n/// let x: [u8; 13] = [0; 13];\n/// let y: &[u8] = &x;\n/// assert_eq!(13, mem::size_of_val(y));\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn size_of_val<T: ?Sized>(val: &T) -> usize {\n    unsafe { intrinsics::size_of_val(val) }\n}\n\n/// Returns the [ABI]-required minimum alignment of a type.\n///\n/// Every reference to a value of the type `T` must be a multiple of this number.\n///\n/// This is the alignment used for struct fields. It may be smaller than the preferred alignment.\n///\n/// [ABI]: https://en.wikipedia.org/wiki/Application_binary_interface\n///\n/// # Examples\n///\n/// ```\n/// # #![allow(deprecated)]\n/// use std::mem;\n///\n/// assert_eq!(4, mem::min_align_of::<i32>());\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(reason = \"use `align_of` instead\", since = \"1.2.0\")]\npub fn min_align_of<T>() -> usize {\n    intrinsics::min_align_of::<T>()\n}\n\n/// Returns the [ABI]-required minimum alignment of the type of the value that `val` points to.\n///\n/// Every reference to a value of the type `T` must be a multiple of this number.\n///\n/// [ABI]: https://en.wikipedia.org/wiki/Application_binary_interface\n///\n/// # Examples\n///\n/// ```\n/// # #![allow(deprecated)]\n/// use std::mem;\n///\n/// assert_eq!(4, mem::min_align_of_val(&5i32));\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(reason = \"use `align_of_val` instead\", since = \"1.2.0\")]\npub fn min_align_of_val<T: ?Sized>(val: &T) -> usize {\n    unsafe { intrinsics::min_align_of_val(val) }\n}\n\n/// Returns the [ABI]-required minimum alignment of a type.\n///\n/// Every reference to a value of the type `T` must be a multiple of this number.\n///\n/// This is the alignment used for struct fields. It may be smaller than the preferred alignment.\n///\n/// [ABI]: https://en.wikipedia.org/wiki/Application_binary_interface\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// assert_eq!(4, mem::align_of::<i32>());\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_promotable]\npub const fn align_of<T>() -> usize {\n    intrinsics::min_align_of::<T>()\n}\n\n/// Returns the [ABI]-required minimum alignment of the type of the value that `val` points to.\n///\n/// Every reference to a value of the type `T` must be a multiple of this number.\n///\n/// [ABI]: https://en.wikipedia.org/wiki/Application_binary_interface\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// assert_eq!(4, mem::align_of_val(&5i32));\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn align_of_val<T: ?Sized>(val: &T) -> usize {\n    unsafe { intrinsics::min_align_of_val(val) }\n}\n\n/// Returns whether dropping values of type `T` matters.\n///\n/// This is purely an optimization hint, and may be implemented conservatively:\n/// it may return `true` for types that don't actually need to be dropped.\n/// As such always returning `true` would be a valid implementation of\n/// this function. However if this function actually returns `false`, then you\n/// can be certain dropping `T` has no side effect.\n///\n/// Low level implementations of things like collections, which need to manually\n/// drop their data, should use this function to avoid unnecessarily\n/// trying to drop all their contents when they are destroyed. This might not\n/// make a difference in release builds (where a loop that has no side-effects\n/// is easily detected and eliminated), but is often a big win for debug builds.\n///\n/// Note that `ptr::drop_in_place` already performs this check, so if your workload\n/// can be reduced to some small number of drop_in_place calls, using this is\n/// unnecessary. In particular note that you can drop_in_place a slice, and that\n/// will do a single needs_drop check for all the values.\n///\n/// Types like Vec therefore just `drop_in_place(&mut self[..])` without using\n/// needs_drop explicitly. Types like HashMap, on the other hand, have to drop\n/// values one at a time and should use this API.\n///\n///\n/// # Examples\n///\n/// Here's an example of how a collection might make use of needs_drop:\n///\n/// ```\n/// use std::{mem, ptr};\n///\n/// pub struct MyCollection<T> {\n/// #   data: [T; 1],\n///     /* ... */\n/// }\n/// # impl<T> MyCollection<T> {\n/// #   fn iter_mut(&mut self) -> &mut [T] { &mut self.data }\n/// #   fn free_buffer(&mut self) {}\n/// # }\n///\n/// impl<T> Drop for MyCollection<T> {\n///     fn drop(&mut self) {\n///         unsafe {\n///             // drop the data\n///             if mem::needs_drop::<T>() {\n///                 for x in self.iter_mut() {\n///                     ptr::drop_in_place(x);\n///                 }\n///             }\n///             self.free_buffer();\n///         }\n///     }\n/// }\n/// ```\n#[inline]\n#[stable(feature = \"needs_drop\", since = \"1.21.0\")]\n#[rustc_const_unstable(feature = \"const_needs_drop\")]\npub const fn needs_drop<T>() -> bool {\n    intrinsics::needs_drop::<T>()\n}\n\n/// Creates a value whose bytes are all zero.\n///\n/// This has the same effect as allocating space with\n/// [`mem::uninitialized`][uninit] and then zeroing it out. It is useful for\n/// [FFI] sometimes, but should generally be avoided.\n///\n/// There is no guarantee that an all-zero byte-pattern represents a valid value of\n/// some type `T`. If `T` has a destructor and the value is destroyed (due to\n/// a panic or the end of a scope) before being initialized, then the destructor\n/// will run on zeroed data, likely leading to [undefined behavior][ub].\n///\n/// See also the documentation for [`mem::uninitialized`][uninit], which has\n/// many of the same caveats.\n///\n/// [uninit]: fn.uninitialized.html\n/// [FFI]: ../../book/first-edition/ffi.html\n/// [ub]: ../../reference/behavior-considered-undefined.html\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// let x: i32 = unsafe { mem::zeroed() };\n/// assert_eq!(0, x);\n/// ```\n#[inline]\n#[rustc_deprecated(since = \"2.0.0\", reason = \"use `mem::MaybeUninit::zeroed` instead\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn zeroed<T>() -> T {\n    intrinsics::init()\n}\n\n/// Bypasses Rust's normal memory-initialization checks by pretending to\n/// produce a value of type `T`, while doing nothing at all.\n///\n/// **This is incredibly dangerous and should not be done lightly. Deeply\n/// consider initializing your memory with a default value instead.**\n///\n/// This is useful for [FFI] functions and initializing arrays sometimes,\n/// but should generally be avoided.\n///\n/// [FFI]: ../../book/first-edition/ffi.html\n///\n/// # Undefined behavior\n///\n/// It is [undefined behavior][ub] to read uninitialized memory, even just an\n/// uninitialized boolean. For instance, if you branch on the value of such\n/// a boolean, your program may take one, both, or neither of the branches.\n///\n/// Writing to the uninitialized value is similarly dangerous. Rust believes the\n/// value is initialized, and will therefore try to [`Drop`] the uninitialized\n/// value and its fields if you try to overwrite it in a normal manner. The only way\n/// to safely initialize an uninitialized value is with [`ptr::write`][write],\n/// [`ptr::copy`][copy], or [`ptr::copy_nonoverlapping`][copy_no].\n///\n/// If the value does implement [`Drop`], it must be initialized before\n/// it goes out of scope (and therefore would be dropped). Note that this\n/// includes a `panic` occurring and unwinding the stack suddenly.\n///\n/// # Examples\n///\n/// Here's how to safely initialize an array of [`Vec`]s.\n///\n/// ```\n/// use std::mem;\n/// use std::ptr;\n///\n/// // Only declare the array. This safely leaves it\n/// // uninitialized in a way that Rust will track for us.\n/// // However we can't initialize it element-by-element\n/// // safely, and we can't use the `[value; 1000]`\n/// // constructor because it only works with `Copy` data.\n/// let mut data: [Vec<u32>; 1000];\n///\n/// unsafe {\n///     // So we need to do this to initialize it.\n///     data = mem::uninitialized();\n///\n///     // DANGER ZONE: if anything panics or otherwise\n///     // incorrectly reads the array here, we will have\n///     // Undefined Behavior.\n///\n///     // It's ok to mutably iterate the data, since this\n///     // doesn't involve reading it at all.\n///     // (ptr and len are statically known for arrays)\n///     for elem in &mut data[..] {\n///         // *elem = Vec::new() would try to drop the\n///         // uninitialized memory at `elem` -- bad!\n///         //\n///         // Vec::new doesn't allocate or do really\n///         // anything. It's only safe to call here\n///         // because we know it won't panic.\n///         ptr::write(elem, Vec::new());\n///     }\n///\n///     // SAFE ZONE: everything is initialized.\n/// }\n///\n/// println!(\"{:?}\", &data[0]);\n/// ```\n///\n/// This example emphasizes exactly how delicate and dangerous using `mem::uninitialized`\n/// can be. Note that the [`vec!`] macro *does* let you initialize every element with a\n/// value that is only [`Clone`], so the following is semantically equivalent and\n/// vastly less dangerous, as long as you can live with an extra heap\n/// allocation:\n///\n/// ```\n/// let data: Vec<Vec<u32>> = vec![Vec::new(); 1000];\n/// println!(\"{:?}\", &data[0]);\n/// ```\n///\n/// [`Vec`]: ../../std/vec/struct.Vec.html\n/// [`vec!`]: ../../std/macro.vec.html\n/// [`Clone`]: ../../std/clone/trait.Clone.html\n/// [ub]: ../../reference/behavior-considered-undefined.html\n/// [write]: ../ptr/fn.write.html\n/// [copy]: ../intrinsics/fn.copy.html\n/// [copy_no]: ../intrinsics/fn.copy_nonoverlapping.html\n/// [`Drop`]: ../ops/trait.Drop.html\n#[inline]\n#[rustc_deprecated(since = \"2.0.0\", reason = \"use `mem::MaybeUninit::uninitialized` instead\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn uninitialized<T>() -> T {\n    intrinsics::uninit()\n}\n\n/// Swaps the values at two mutable locations, without deinitializing either one.\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// let mut x = 5;\n/// let mut y = 42;\n///\n/// mem::swap(&mut x, &mut y);\n///\n/// assert_eq!(42, x);\n/// assert_eq!(5, y);\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn swap<T>(x: &mut T, y: &mut T) {\n    unsafe {\n        ptr::swap_nonoverlapping_one(x, y);\n    }\n}\n\n/// Moves `src` into the referenced `dest`, returning the previous `dest` value.\n///\n/// Neither value is dropped.\n///\n/// # Examples\n///\n/// A simple example:\n///\n/// ```\n/// use std::mem;\n///\n/// let mut v: Vec<i32> = vec![1, 2];\n///\n/// let old_v = mem::replace(&mut v, vec![3, 4, 5]);\n/// assert_eq!(2, old_v.len());\n/// assert_eq!(3, v.len());\n/// ```\n///\n/// `replace` allows consumption of a struct field by replacing it with another value.\n/// Without `replace` you can run into issues like these:\n///\n/// ```compile_fail,E0507\n/// struct Buffer<T> { buf: Vec<T> }\n///\n/// impl<T> Buffer<T> {\n///     fn get_and_reset(&mut self) -> Vec<T> {\n///         // error: cannot move out of dereference of `&mut`-pointer\n///         let buf = self.buf;\n///         self.buf = Vec::new();\n///         buf\n///     }\n/// }\n/// ```\n///\n/// Note that `T` does not necessarily implement [`Clone`], so it can't even clone and reset\n/// `self.buf`. But `replace` can be used to disassociate the original value of `self.buf` from\n/// `self`, allowing it to be returned:\n///\n/// ```\n/// # #![allow(dead_code)]\n/// use std::mem;\n///\n/// # struct Buffer<T> { buf: Vec<T> }\n/// impl<T> Buffer<T> {\n///     fn get_and_reset(&mut self) -> Vec<T> {\n///         mem::replace(&mut self.buf, Vec::new())\n///     }\n/// }\n/// ```\n///\n/// [`Clone`]: ../../std/clone/trait.Clone.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn replace<T>(dest: &mut T, mut src: T) -> T {\n    swap(dest, &mut src);\n    src\n}\n\n/// Disposes of a value.\n///\n/// While this does call the argument's implementation of [`Drop`][drop],\n/// it will not release any borrows, as borrows are based on lexical scope.\n///\n/// This effectively does nothing for\n/// [types which implement `Copy`](../../book/first-edition/ownership.html#copy-types),\n/// e.g. integers. Such values are copied and _then_ moved into the function,\n/// so the value persists after this function call.\n///\n/// This function is not magic; it is literally defined as\n///\n/// ```\n/// pub fn drop<T>(_x: T) { }\n/// ```\n///\n/// Because `_x` is moved into the function, it is automatically dropped before\n/// the function returns.\n///\n/// [drop]: ../ops/trait.Drop.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let v = vec![1, 2, 3];\n///\n/// drop(v); // explicitly drop the vector\n/// ```\n///\n/// Borrows are based on lexical scope, so this produces an error:\n///\n/// ```compile_fail,E0502\n/// let mut v = vec![1, 2, 3];\n/// let x = &v[0];\n///\n/// drop(x); // explicitly drop the reference, but the borrow still exists\n///\n/// v.push(4); // error: cannot borrow `v` as mutable because it is also\n///            // borrowed as immutable\n/// ```\n///\n/// An inner scope is needed to fix this:\n///\n/// ```\n/// let mut v = vec![1, 2, 3];\n///\n/// {\n///     let x = &v[0];\n///\n///     drop(x); // this is now redundant, as `x` is going out of scope anyway\n/// }\n///\n/// v.push(4); // no problems\n/// ```\n///\n/// Since [`RefCell`] enforces the borrow rules at runtime, `drop` can\n/// release a [`RefCell`] borrow:\n///\n/// ```\n/// use std::cell::RefCell;\n///\n/// let x = RefCell::new(1);\n///\n/// let mut mutable_borrow = x.borrow_mut();\n/// *mutable_borrow = 1;\n///\n/// drop(mutable_borrow); // relinquish the mutable borrow on this slot\n///\n/// let borrow = x.borrow();\n/// println!(\"{}\", *borrow);\n/// ```\n///\n/// Integers and other types implementing [`Copy`] are unaffected by `drop`.\n///\n/// ```\n/// #[derive(Copy, Clone)]\n/// struct Foo(u8);\n///\n/// let x = 1;\n/// let y = Foo(2);\n/// drop(x); // a copy of `x` is moved and dropped\n/// drop(y); // a copy of `y` is moved and dropped\n///\n/// println!(\"x: {}, y: {}\", x, y.0); // still available\n/// ```\n///\n/// [`RefCell`]: ../../std/cell/struct.RefCell.html\n/// [`Copy`]: ../../std/marker/trait.Copy.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn drop<T>(_x: T) { }\n\n/// Interprets `src` as having type `&U`, and then reads `src` without moving\n/// the contained value.\n///\n/// This function will unsafely assume the pointer `src` is valid for\n/// [`size_of::<U>`][size_of] bytes by transmuting `&T` to `&U` and then reading\n/// the `&U`. It will also unsafely create a copy of the contained value instead of\n/// moving out of `src`.\n///\n/// It is not a compile-time error if `T` and `U` have different sizes, but it\n/// is highly encouraged to only invoke this function where `T` and `U` have the\n/// same size. This function triggers [undefined behavior][ub] if `U` is larger than\n/// `T`.\n///\n/// [ub]: ../../reference/behavior-considered-undefined.html\n/// [size_of]: fn.size_of.html\n///\n/// # Examples\n///\n/// ```\n/// use std::mem;\n///\n/// #[repr(packed)]\n/// struct Foo {\n///     bar: u8,\n/// }\n///\n/// let foo_slice = [10u8];\n///\n/// unsafe {\n///     // Copy the data from 'foo_slice' and treat it as a 'Foo'\n///     let mut foo_struct: Foo = mem::transmute_copy(&foo_slice);\n///     assert_eq!(foo_struct.bar, 10);\n///\n///     // Modify the copied data\n///     foo_struct.bar = 20;\n///     assert_eq!(foo_struct.bar, 20);\n/// }\n///\n/// // The contents of 'foo_slice' should not have changed\n/// assert_eq!(foo_slice, [10]);\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub unsafe fn transmute_copy<T, U>(src: &T) -> U {\n    ptr::read(src as *const T as *const U)\n}\n\n/// Opaque type representing the discriminant of an enum.\n///\n/// See the [`discriminant`] function in this module for more information.\n///\n/// [`discriminant`]: fn.discriminant.html\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\npub struct Discriminant<T>(u64, PhantomData<fn() -> T>);\n\n// N.B. These trait implementations cannot be derived because we don't want any bounds on T.\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> Copy for Discriminant<T> {}\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> clone::Clone for Discriminant<T> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> cmp::PartialEq for Discriminant<T> {\n    fn eq(&self, rhs: &Self) -> bool {\n        self.0 == rhs.0\n    }\n}\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> cmp::Eq for Discriminant<T> {}\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> hash::Hash for Discriminant<T> {\n    fn hash<H: hash::Hasher>(&self, state: &mut H) {\n        self.0.hash(state);\n    }\n}\n\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\nimpl<T> fmt::Debug for Discriminant<T> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt.debug_tuple(\"Discriminant\")\n           .field(&self.0)\n           .finish()\n    }\n}\n\n/// Returns a value uniquely identifying the enum variant in `v`.\n///\n/// If `T` is not an enum, calling this function will not result in undefined behavior, but the\n/// return value is unspecified.\n///\n/// # Stability\n///\n/// The discriminant of an enum variant may change if the enum definition changes. A discriminant\n/// of some variant will not change between compilations with the same compiler.\n///\n/// # Examples\n///\n/// This can be used to compare enums that carry data, while disregarding\n/// the actual data:\n///\n/// ```\n/// use std::mem;\n///\n/// enum Foo { A(&'static str), B(i32), C(i32) }\n///\n/// assert!(mem::discriminant(&Foo::A(\"bar\")) == mem::discriminant(&Foo::A(\"baz\")));\n/// assert!(mem::discriminant(&Foo::B(1))     == mem::discriminant(&Foo::B(2)));\n/// assert!(mem::discriminant(&Foo::B(3))     != mem::discriminant(&Foo::C(3)));\n/// ```\n#[stable(feature = \"discriminant_value\", since = \"1.21.0\")]\npub fn discriminant<T>(v: &T) -> Discriminant<T> {\n    unsafe {\n        Discriminant(intrinsics::discriminant_value(v), PhantomData)\n    }\n}\n\n/// A wrapper to inhibit compiler from automatically calling `T`\u2019s destructor.\n///\n/// This wrapper is 0-cost.\n///\n/// # Examples\n///\n/// This wrapper helps with explicitly documenting the drop order dependencies between fields of\n/// the type:\n///\n/// ```rust\n/// use std::mem::ManuallyDrop;\n/// struct Peach;\n/// struct Banana;\n/// struct Melon;\n/// struct FruitBox {\n///     // Immediately clear there\u2019s something non-trivial going on with these fields.\n///     peach: ManuallyDrop<Peach>,\n///     melon: Melon, // Field that\u2019s independent of the other two.\n///     banana: ManuallyDrop<Banana>,\n/// }\n///\n/// impl Drop for FruitBox {\n///     fn drop(&mut self) {\n///         unsafe {\n///             // Explicit ordering in which field destructors are run specified in the intuitive\n///             // location \u2013 the destructor of the structure containing the fields.\n///             // Moreover, one can now reorder fields within the struct however much they want.\n///             ManuallyDrop::drop(&mut self.peach);\n///             ManuallyDrop::drop(&mut self.banana);\n///         }\n///         // After destructor for `FruitBox` runs (this function), the destructor for Melon gets\n///         // invoked in the usual manner, as it is not wrapped in `ManuallyDrop`.\n///     }\n/// }\n/// ```\n#[stable(feature = \"manually_drop\", since = \"1.20.0\")]\n#[lang = \"manually_drop\"]\n#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]\n#[repr(transparent)]\npub struct ManuallyDrop<T: ?Sized> {\n    value: T,\n}\n\nimpl<T> ManuallyDrop<T> {\n    /// Wrap a value to be manually dropped.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::mem::ManuallyDrop;\n    /// ManuallyDrop::new(Box::new(()));\n    /// ```\n    #[stable(feature = \"manually_drop\", since = \"1.20.0\")]\n    #[rustc_const_unstable(feature = \"const_manually_drop_new\")]\n    #[inline]\n    pub const fn new(value: T) -> ManuallyDrop<T> {\n        ManuallyDrop { value }\n    }\n\n    /// Extract the value from the `ManuallyDrop` container.\n    ///\n    /// This allows the value to be dropped again.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::mem::ManuallyDrop;\n    /// let x = ManuallyDrop::new(Box::new(()));\n    /// let _: Box<()> = ManuallyDrop::into_inner(x); // This drops the `Box`.\n    /// ```\n    #[stable(feature = \"manually_drop\", since = \"1.20.0\")]\n    #[inline]\n    pub fn into_inner(slot: ManuallyDrop<T>) -> T {\n        slot.value\n    }\n\n    /// Takes the contained value out.\n    ///\n    /// This method is primarily intended for moving out values in drop.\n    /// Instead of using [`ManuallyDrop::drop`] to manually drop the value,\n    /// you can use this method to take the value and use it however desired.\n    /// `Drop` will be invoked on the returned value following normal end-of-scope rules.\n    ///\n    /// If you have ownership of the container, you can use [`ManuallyDrop::into_inner`] instead.\n    ///\n    /// # Safety\n    ///\n    /// This function semantically moves out the contained value without preventing further usage.\n    /// It is up to the user of this method to ensure that this container is not used again.\n    #[must_use = \"if you don't need the value, you can use `ManuallyDrop::drop` instead\"]\n    #[unstable(feature = \"manually_drop_take\", issue = \"55422\")]\n    #[inline]\n    pub unsafe fn take(slot: &mut ManuallyDrop<T>) -> T {\n        ManuallyDrop::into_inner(ptr::read(slot))\n    }\n}\n\nimpl<T: ?Sized> ManuallyDrop<T> {\n    /// Manually drops the contained value.\n    ///\n    /// If you have ownership of the value, you can use [`ManuallyDrop::into_inner`] instead.\n    ///\n    /// # Safety\n    ///\n    /// This function runs the destructor of the contained value and thus the wrapped value\n    /// now represents uninitialized data. It is up to the user of this method to ensure the\n    /// uninitialized data is not actually used.\n    ///\n    /// [`ManuallyDrop::into_inner`]: #method.into_inner\n    #[stable(feature = \"manually_drop\", since = \"1.20.0\")]\n    #[inline]\n    pub unsafe fn drop(slot: &mut ManuallyDrop<T>) {\n        ptr::drop_in_place(&mut slot.value)\n    }\n}\n\n#[stable(feature = \"manually_drop\", since = \"1.20.0\")]\nimpl<T: ?Sized> Deref for ManuallyDrop<T> {\n    type Target = T;\n    #[inline]\n    fn deref(&self) -> &Self::Target {\n        &self.value\n    }\n}\n\n#[stable(feature = \"manually_drop\", since = \"1.20.0\")]\nimpl<T: ?Sized> DerefMut for ManuallyDrop<T> {\n    #[inline]\n    fn deref_mut(&mut self) -> &mut Self::Target {\n        &mut self.value\n    }\n}\n\n/// A newtype to construct uninitialized instances of `T`\n#[allow(missing_debug_implementations)]\n#[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n// NOTE after stabilizing `MaybeUninit` proceed to deprecate `mem::{uninitialized,zeroed}`\npub union MaybeUninit<T> {\n    uninit: (),\n    value: ManuallyDrop<T>,\n}\n\nimpl<T> MaybeUninit<T> {\n    /// Create a new `MaybeUninit` initialized with the given value.\n    ///\n    /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.\n    /// It is your responsibility to make sure `T` gets dropped if it got initialized.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub const fn new(val: T) -> MaybeUninit<T> {\n        MaybeUninit { value: ManuallyDrop::new(val) }\n    }\n\n    /// Create a new `MaybeUninit` in an uninitialized state.\n    ///\n    /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.\n    /// It is your responsibility to make sure `T` gets dropped if it got initialized.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub const fn uninitialized() -> MaybeUninit<T> {\n        MaybeUninit { uninit: () }\n    }\n\n    /// Create a new `MaybeUninit` in an uninitialized state, with the memory being\n    /// filled with `0` bytes.  It depends on `T` whether that already makes for\n    /// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,\n    /// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not\n    /// be null.\n    ///\n    /// Note that dropping a `MaybeUninit` will never call `T`'s drop code.\n    /// It is your responsibility to make sure `T` gets dropped if it got initialized.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub fn zeroed() -> MaybeUninit<T> {\n        let mut u = MaybeUninit::<T>::uninitialized();\n        unsafe {\n            u.as_mut_ptr().write_bytes(0u8, 1);\n        }\n        u\n    }\n\n    /// Set the value of the `MaybeUninit`. This overwrites any previous value without dropping it.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub fn set(&mut self, val: T) {\n        unsafe {\n            self.value = ManuallyDrop::new(val);\n        }\n    }\n\n    /// Extract the value from the `MaybeUninit` container.  This is a great way\n    /// to ensure that the data will get dropped, because the resulting `T` is\n    /// subject to the usual drop handling.\n    ///\n    /// # Unsafety\n    ///\n    /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized\n    /// state, otherwise this will immediately cause undefined behavior.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub unsafe fn into_inner(self) -> T {\n        ManuallyDrop::into_inner(self.value)\n    }\n\n    /// Get a reference to the contained value.\n    ///\n    /// # Unsafety\n    ///\n    /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized\n    /// state, otherwise this will immediately cause undefined behavior.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub unsafe fn get_ref(&self) -> &T {\n        &*self.value\n    }\n\n    /// Get a mutable reference to the contained value.\n    ///\n    /// # Unsafety\n    ///\n    /// It is up to the caller to guarantee that the the `MaybeUninit` really is in an initialized\n    /// state, otherwise this will immediately cause undefined behavior.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub unsafe fn get_mut(&mut self) -> &mut T {\n        &mut *self.value\n    }\n\n    /// Get a pointer to the contained value. Reading from this pointer will be undefined\n    /// behavior unless the `MaybeUninit` is initialized.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub fn as_ptr(&self) -> *const T {\n        unsafe { &*self.value as *const T }\n    }\n\n    /// Get a mutable pointer to the contained value. Reading from this pointer will be undefined\n    /// behavior unless the `MaybeUninit` is initialized.\n    #[unstable(feature = \"maybe_uninit\", issue = \"53491\")]\n    pub fn as_mut_ptr(&mut self) -> *mut T {\n        unsafe { &mut *self.value as *mut T }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A UTF-8 encoded, growable string.\n//!\n//! This module contains the [`String`] type, a trait for converting\n//! [`ToString`]s, and several error types that may result from working with\n//! [`String`]s.\n//!\n//! [`ToString`]: trait.ToString.html\n//!\n//! # Examples\n//!\n//! There are multiple ways to create a new [`String`] from a string literal:\n//!\n//! ```\n//! let s = \"Hello\".to_string();\n//!\n//! let s = String::from(\"world\");\n//! let s: String = \"also this\".into();\n//! ```\n//!\n//! You can create a new [`String`] from an existing one by concatenating with\n//! `+`:\n//!\n//! [`String`]: struct.String.html\n//!\n//! ```\n//! let s = \"Hello\".to_string();\n//!\n//! let message = s + \" world!\";\n//! ```\n//!\n//! If you have a vector of valid UTF-8 bytes, you can make a [`String`] out of\n//! it. You can do the reverse too.\n//!\n//! ```\n//! let sparkle_heart = vec![240, 159, 146, 150];\n//!\n//! // We know these bytes are valid, so we'll use `unwrap()`.\n//! let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();\n//!\n//! assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n//!\n//! let bytes = sparkle_heart.into_bytes();\n//!\n//! assert_eq!(bytes, [240, 159, 146, 150]);\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse core::char::{decode_utf16, REPLACEMENT_CHARACTER};\nuse core::fmt;\nuse core::hash;\nuse core::iter::{FromIterator, FusedIterator};\nuse core::ops::Bound::{Excluded, Included, Unbounded};\nuse core::ops::{self, Add, AddAssign, Index, IndexMut, RangeBounds};\nuse core::ptr;\nuse core::str::pattern::Pattern;\nuse core::str::lossy;\n\nuse collections::CollectionAllocErr;\nuse borrow::{Cow, ToOwned};\nuse boxed::Box;\nuse str::{self, from_boxed_utf8_unchecked, FromStr, Utf8Error, Chars};\nuse vec::Vec;\n\n/// A UTF-8 encoded, growable string.\n///\n/// The `String` type is the most common string type that has ownership over the\n/// contents of the string. It has a close relationship with its borrowed\n/// counterpart, the primitive [`str`].\n///\n/// [`str`]: ../../std/primitive.str.html\n///\n/// # Examples\n///\n/// You can create a `String` from a literal string with [`String::from`]:\n///\n/// ```\n/// let hello = String::from(\"Hello, world!\");\n/// ```\n///\n/// You can append a [`char`] to a `String` with the [`push`] method, and\n/// append a [`&str`] with the [`push_str`] method:\n///\n/// ```\n/// let mut hello = String::from(\"Hello, \");\n///\n/// hello.push('w');\n/// hello.push_str(\"orld!\");\n/// ```\n///\n/// [`String::from`]: #method.from\n/// [`char`]: ../../std/primitive.char.html\n/// [`push`]: #method.push\n/// [`push_str`]: #method.push_str\n///\n/// If you have a vector of UTF-8 bytes, you can create a `String` from it with\n/// the [`from_utf8`] method:\n///\n/// ```\n/// // some bytes, in a vector\n/// let sparkle_heart = vec![240, 159, 146, 150];\n///\n/// // We know these bytes are valid, so we'll use `unwrap()`.\n/// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();\n///\n/// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n/// ```\n///\n/// [`from_utf8`]: #method.from_utf8\n///\n/// # UTF-8\n///\n/// `String`s are always valid UTF-8. This has a few implications, the first of\n/// which is that if you need a non-UTF-8 string, consider [`OsString`]. It is\n/// similar, but without the UTF-8 constraint. The second implication is that\n/// you cannot index into a `String`:\n///\n/// ```compile_fail,E0277\n/// let s = \"hello\";\n///\n/// println!(\"The first letter of s is {}\", s[0]); // ERROR!!!\n/// ```\n///\n/// [`OsString`]: ../../std/ffi/struct.OsString.html\n///\n/// Indexing is intended to be a constant-time operation, but UTF-8 encoding\n/// does not allow us to do this. Furthermore, it's not clear what sort of\n/// thing the index should return: a byte, a codepoint, or a grapheme cluster.\n/// The [`bytes`] and [`chars`] methods return iterators over the first\n/// two, respectively.\n///\n/// [`bytes`]: #method.bytes\n/// [`chars`]: #method.chars\n///\n/// # Deref\n///\n/// `String`s implement [`Deref`]`<Target=str>`, and so inherit all of [`str`]'s\n/// methods. In addition, this means that you can pass a `String` to a\n/// function which takes a [`&str`] by using an ampersand (`&`):\n///\n/// ```\n/// fn takes_str(s: &str) { }\n///\n/// let s = String::from(\"Hello\");\n///\n/// takes_str(&s);\n/// ```\n///\n/// This will create a [`&str`] from the `String` and pass it in. This\n/// conversion is very inexpensive, and so generally, functions will accept\n/// [`&str`]s as arguments unless they need a `String` for some specific\n/// reason.\n///\n/// In certain cases Rust doesn't have enough information to make this\n/// conversion, known as [`Deref`] coercion. In the following example a string\n/// slice [`&'a str`][`&str`] implements the trait `TraitExample`, and the function\n/// `example_func` takes anything that implements the trait. In this case Rust\n/// would need to make two implicit conversions, which Rust doesn't have the\n/// means to do. For that reason, the following example will not compile.\n///\n/// ```compile_fail,E0277\n/// trait TraitExample {}\n///\n/// impl<'a> TraitExample for &'a str {}\n///\n/// fn example_func<A: TraitExample>(example_arg: A) {}\n///\n/// fn main() {\n///     let example_string = String::from(\"example_string\");\n///     example_func(&example_string);\n/// }\n/// ```\n///\n/// There are two options that would work instead. The first would be to\n/// change the line `example_func(&example_string);` to\n/// `example_func(example_string.as_str());`, using the method [`as_str()`]\n/// to explicitly extract the string slice containing the string. The second\n/// way changes `example_func(&example_string);` to\n/// `example_func(&*example_string);`. In this case we are dereferencing a\n/// `String` to a [`str`][`&str`], then referencing the [`str`][`&str`] back to\n/// [`&str`]. The second way is more idiomatic, however both work to do the\n/// conversion explicitly rather than relying on the implicit conversion.\n///\n/// # Representation\n///\n/// A `String` is made up of three components: a pointer to some bytes, a\n/// length, and a capacity. The pointer points to an internal buffer `String`\n/// uses to store its data. The length is the number of bytes currently stored\n/// in the buffer, and the capacity is the size of the buffer in bytes. As such,\n/// the length will always be less than or equal to the capacity.\n///\n/// This buffer is always stored on the heap.\n///\n/// You can look at these with the [`as_ptr`], [`len`], and [`capacity`]\n/// methods:\n///\n/// ```\n/// use std::mem;\n///\n/// let story = String::from(\"Once upon a time...\");\n///\n/// let ptr = story.as_ptr();\n/// let len = story.len();\n/// let capacity = story.capacity();\n///\n/// // story has nineteen bytes\n/// assert_eq!(19, len);\n///\n/// // Now that we have our parts, we throw the story away.\n/// mem::forget(story);\n///\n/// // We can re-build a String out of ptr, len, and capacity. This is all\n/// // unsafe because we are responsible for making sure the components are\n/// // valid:\n/// let s = unsafe { String::from_raw_parts(ptr as *mut _, len, capacity) } ;\n///\n/// assert_eq!(String::from(\"Once upon a time...\"), s);\n/// ```\n///\n/// [`as_ptr`]: #method.as_ptr\n/// [`len`]: #method.len\n/// [`capacity`]: #method.capacity\n///\n/// If a `String` has enough capacity, adding elements to it will not\n/// re-allocate. For example, consider this program:\n///\n/// ```\n/// let mut s = String::new();\n///\n/// println!(\"{}\", s.capacity());\n///\n/// for _ in 0..5 {\n///     s.push_str(\"hello\");\n///     println!(\"{}\", s.capacity());\n/// }\n/// ```\n///\n/// This will output the following:\n///\n/// ```text\n/// 0\n/// 5\n/// 10\n/// 20\n/// 20\n/// 40\n/// ```\n///\n/// At first, we have no memory allocated at all, but as we append to the\n/// string, it increases its capacity appropriately. If we instead use the\n/// [`with_capacity`] method to allocate the correct capacity initially:\n///\n/// ```\n/// let mut s = String::with_capacity(25);\n///\n/// println!(\"{}\", s.capacity());\n///\n/// for _ in 0..5 {\n///     s.push_str(\"hello\");\n///     println!(\"{}\", s.capacity());\n/// }\n/// ```\n///\n/// [`with_capacity`]: #method.with_capacity\n///\n/// We end up with a different output:\n///\n/// ```text\n/// 25\n/// 25\n/// 25\n/// 25\n/// 25\n/// 25\n/// ```\n///\n/// Here, there's no need to allocate more memory inside the loop.\n///\n/// [`&str`]: ../../std/primitive.str.html\n/// [`Deref`]: ../../std/ops/trait.Deref.html\n/// [`as_str()`]: struct.String.html#method.as_str\n#[derive(PartialOrd, Eq, Ord)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct String {\n    vec: Vec<u8>,\n}\n\n/// A possible error value when converting a `String` from a UTF-8 byte vector.\n///\n/// This type is the error type for the [`from_utf8`] method on [`String`]. It\n/// is designed in such a way to carefully avoid reallocations: the\n/// [`into_bytes`] method will give back the byte vector that was used in the\n/// conversion attempt.\n///\n/// [`from_utf8`]: struct.String.html#method.from_utf8\n/// [`String`]: struct.String.html\n/// [`into_bytes`]: struct.FromUtf8Error.html#method.into_bytes\n///\n/// The [`Utf8Error`] type provided by [`std::str`] represents an error that may\n/// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's\n/// an analogue to `FromUtf8Error`, and you can get one from a `FromUtf8Error`\n/// through the [`utf8_error`] method.\n///\n/// [`Utf8Error`]: ../../std/str/struct.Utf8Error.html\n/// [`std::str`]: ../../std/str/index.html\n/// [`u8`]: ../../std/primitive.u8.html\n/// [`&str`]: ../../std/primitive.str.html\n/// [`utf8_error`]: #method.utf8_error\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // some invalid bytes, in a vector\n/// let bytes = vec![0, 159];\n///\n/// let value = String::from_utf8(bytes);\n///\n/// assert!(value.is_err());\n/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct FromUtf8Error {\n    bytes: Vec<u8>,\n    error: Utf8Error,\n}\n\n/// A possible error value when converting a `String` from a UTF-16 byte slice.\n///\n/// This type is the error type for the [`from_utf16`] method on [`String`].\n///\n/// [`from_utf16`]: struct.String.html#method.from_utf16\n/// [`String`]: struct.String.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // \ud834\udd1emu<invalid>ic\n/// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n///           0xD800, 0x0069, 0x0063];\n///\n/// assert!(String::from_utf16(v).is_err());\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct FromUtf16Error(());\n\nimpl String {\n    /// Creates a new empty `String`.\n    ///\n    /// Given that the `String` is empty, this will not allocate any initial\n    /// buffer. While that means that this initial operation is very\n    /// inexpensive, it may cause excessive allocation later when you add\n    /// data. If you have an idea of how much data the `String` will hold,\n    /// consider the [`with_capacity`] method to prevent excessive\n    /// re-allocation.\n    ///\n    /// [`with_capacity`]: #method.with_capacity\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::new();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature = \"const_string_new\")]\n    pub const fn new() -> String {\n        String { vec: Vec::new() }\n    }\n\n    /// Creates a new empty `String` with a particular capacity.\n    ///\n    /// `String`s have an internal buffer to hold their data. The capacity is\n    /// the length of that buffer, and can be queried with the [`capacity`]\n    /// method. This method creates an empty `String`, but one with an initial\n    /// buffer that can hold `capacity` bytes. This is useful when you may be\n    /// appending a bunch of data to the `String`, reducing the number of\n    /// reallocations it needs to do.\n    ///\n    /// [`capacity`]: #method.capacity\n    ///\n    /// If the given capacity is `0`, no allocation will occur, and this method\n    /// is identical to the [`new`] method.\n    ///\n    /// [`new`]: #method.new\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::with_capacity(10);\n    ///\n    /// // The String contains no chars, even though it has capacity for more\n    /// assert_eq!(s.len(), 0);\n    ///\n    /// // These are all done without reallocating...\n    /// let cap = s.capacity();\n    /// for _ in 0..10 {\n    ///     s.push('a');\n    /// }\n    ///\n    /// assert_eq!(s.capacity(), cap);\n    ///\n    /// // ...but this may make the vector reallocate\n    /// s.push('a');\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(capacity: usize) -> String {\n        String { vec: Vec::with_capacity(capacity) }\n    }\n\n    // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is\n    // required for this method definition, is not available. Since we don't\n    // require this method for testing purposes, I'll just stub it\n    // NB see the slice::hack module in slice.rs for more information\n    #[inline]\n    #[cfg(test)]\n    pub fn from_str(_: &str) -> String {\n        panic!(\"not available with cfg(test)\");\n    }\n\n    /// Converts a vector of bytes to a `String`.\n    ///\n    /// A string slice ([`&str`]) is made of bytes ([`u8`]), and a vector of bytes\n    /// ([`Vec<u8>`]) is made of bytes, so this function converts between the\n    /// two. Not all byte slices are valid `String`s, however: `String`\n    /// requires that it is valid UTF-8. `from_utf8()` checks to ensure that\n    /// the bytes are valid UTF-8, and then does the conversion.\n    ///\n    /// If you are sure that the byte slice is valid UTF-8, and you don't want\n    /// to incur the overhead of the validity check, there is an unsafe version\n    /// of this function, [`from_utf8_unchecked`], which has the same behavior\n    /// but skips the check.\n    ///\n    /// This method will take care to not copy the vector, for efficiency's\n    /// sake.\n    ///\n    /// If you need a [`&str`] instead of a `String`, consider\n    /// [`str::from_utf8`].\n    ///\n    /// The inverse of this method is [`as_bytes`].\n    ///\n    /// # Errors\n    ///\n    /// Returns [`Err`] if the slice is not UTF-8 with a description as to why the\n    /// provided bytes are not UTF-8. The vector you moved in is also included.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some bytes, in a vector\n    /// let sparkle_heart = vec![240, 159, 146, 150];\n    ///\n    /// // We know these bytes are valid, so we'll use `unwrap()`.\n    /// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();\n    ///\n    /// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n    /// ```\n    ///\n    /// Incorrect bytes:\n    ///\n    /// ```\n    /// // some invalid bytes, in a vector\n    /// let sparkle_heart = vec![0, 159, 146, 150];\n    ///\n    /// assert!(String::from_utf8(sparkle_heart).is_err());\n    /// ```\n    ///\n    /// See the docs for [`FromUtf8Error`] for more details on what you can do\n    /// with this error.\n    ///\n    /// [`from_utf8_unchecked`]: struct.String.html#method.from_utf8_unchecked\n    /// [`&str`]: ../../std/primitive.str.html\n    /// [`u8`]: ../../std/primitive.u8.html\n    /// [`Vec<u8>`]: ../../std/vec/struct.Vec.html\n    /// [`str::from_utf8`]: ../../std/str/fn.from_utf8.html\n    /// [`as_bytes`]: struct.String.html#method.as_bytes\n    /// [`FromUtf8Error`]: struct.FromUtf8Error.html\n    /// [`Err`]: ../../stdresult/enum.Result.html#variant.Err\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {\n        match str::from_utf8(&vec) {\n            Ok(..) => Ok(String { vec }),\n            Err(e) => {\n                Err(FromUtf8Error {\n                    bytes: vec,\n                    error: e,\n                })\n            }\n        }\n    }\n\n    /// Converts a slice of bytes to a string, including invalid characters.\n    ///\n    /// Strings are made of bytes ([`u8`]), and a slice of bytes\n    /// ([`&[u8]`][byteslice]) is made of bytes, so this function converts\n    /// between the two. Not all byte slices are valid strings, however: strings\n    /// are required to be valid UTF-8. During this conversion,\n    /// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with\n    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD], which looks like this: \ufffd\n    ///\n    /// [`u8`]: ../../std/primitive.u8.html\n    /// [byteslice]: ../../std/primitive.slice.html\n    /// [U+FFFD]: ../char/constant.REPLACEMENT_CHARACTER.html\n    ///\n    /// If you are sure that the byte slice is valid UTF-8, and you don't want\n    /// to incur the overhead of the conversion, there is an unsafe version\n    /// of this function, [`from_utf8_unchecked`], which has the same behavior\n    /// but skips the checks.\n    ///\n    /// [`from_utf8_unchecked`]: struct.String.html#method.from_utf8_unchecked\n    ///\n    /// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid\n    /// UTF-8, then we need to insert the replacement characters, which will\n    /// change the size of the string, and hence, require a `String`. But if\n    /// it's already valid UTF-8, we don't need a new allocation. This return\n    /// type allows us to handle both cases.\n    ///\n    /// [`Cow<'a, str>`]: ../../std/borrow/enum.Cow.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some bytes, in a vector\n    /// let sparkle_heart = vec![240, 159, 146, 150];\n    ///\n    /// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);\n    ///\n    /// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n    /// ```\n    ///\n    /// Incorrect bytes:\n    ///\n    /// ```\n    /// // some invalid bytes\n    /// let input = b\"Hello \\xF0\\x90\\x80World\";\n    /// let output = String::from_utf8_lossy(input);\n    ///\n    /// assert_eq!(\"Hello \ufffdWorld\", output);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> Cow<'a, str> {\n        let mut iter = lossy::Utf8Lossy::from_bytes(v).chunks();\n\n        let (first_valid, first_broken) = if let Some(chunk) = iter.next() {\n            let lossy::Utf8LossyChunk { valid, broken } = chunk;\n            if valid.len() == v.len() {\n                debug_assert!(broken.is_empty());\n                return Cow::Borrowed(valid);\n            }\n            (valid, broken)\n        } else {\n            return Cow::Borrowed(\"\");\n        };\n\n        const REPLACEMENT: &'static str = \"\\u{FFFD}\";\n\n        let mut res = String::with_capacity(v.len());\n        res.push_str(first_valid);\n        if !first_broken.is_empty() {\n            res.push_str(REPLACEMENT);\n        }\n\n        for lossy::Utf8LossyChunk { valid, broken } in iter {\n            res.push_str(valid);\n            if !broken.is_empty() {\n                res.push_str(REPLACEMENT);\n            }\n        }\n\n        Cow::Owned(res)\n    }\n\n    /// Decode a UTF-16 encoded vector `v` into a `String`, returning [`Err`]\n    /// if `v` contains any invalid data.\n    ///\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // \ud834\udd1emusic\n    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n    ///           0x0073, 0x0069, 0x0063];\n    /// assert_eq!(String::from(\"\ud834\udd1emusic\"),\n    ///            String::from_utf16(v).unwrap());\n    ///\n    /// // \ud834\udd1emu<invalid>ic\n    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n    ///           0xD800, 0x0069, 0x0063];\n    /// assert!(String::from_utf16(v).is_err());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {\n        decode_utf16(v.iter().cloned()).collect::<Result<_, _>>().map_err(|_| FromUtf16Error(()))\n    }\n\n    /// Decode a UTF-16 encoded slice `v` into a `String`, replacing\n    /// invalid data with [the replacement character (`U+FFFD`)][U+FFFD].\n    ///\n    /// Unlike [`from_utf8_lossy`] which returns a [`Cow<'a, str>`],\n    /// `from_utf16_lossy` returns a `String` since the UTF-16 to UTF-8\n    /// conversion requires a memory allocation.\n    ///\n    /// [`from_utf8_lossy`]: #method.from_utf8_lossy\n    /// [`Cow<'a, str>`]: ../borrow/enum.Cow.html\n    /// [U+FFFD]: ../char/constant.REPLACEMENT_CHARACTER.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // \ud834\udd1emus<invalid>ic<invalid>\n    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,\n    ///           0x0073, 0xDD1E, 0x0069, 0x0063,\n    ///           0xD834];\n    ///\n    /// assert_eq!(String::from(\"\ud834\udd1emus\\u{FFFD}ic\\u{FFFD}\"),\n    ///            String::from_utf16_lossy(v));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn from_utf16_lossy(v: &[u16]) -> String {\n        decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect()\n    }\n\n    /// Creates a new `String` from a length, capacity, and pointer.\n    ///\n    /// # Safety\n    ///\n    /// This is highly unsafe, due to the number of invariants that aren't\n    /// checked:\n    ///\n    /// * The memory at `ptr` needs to have been previously allocated by the\n    ///   same allocator the standard library uses.\n    /// * `length` needs to be less than or equal to `capacity`.\n    /// * `capacity` needs to be the correct value.\n    ///\n    /// Violating these may cause problems like corrupting the allocator's\n    /// internal data structures.\n    ///\n    /// The ownership of `ptr` is effectively transferred to the\n    /// `String` which may then deallocate, reallocate or change the\n    /// contents of memory pointed to by the pointer at will. Ensure\n    /// that nothing else uses the pointer after calling this\n    /// function.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::mem;\n    ///\n    /// unsafe {\n    ///     let s = String::from(\"hello\");\n    ///     let ptr = s.as_ptr();\n    ///     let len = s.len();\n    ///     let capacity = s.capacity();\n    ///\n    ///     mem::forget(s);\n    ///\n    ///     let s = String::from_raw_parts(ptr as *mut _, len, capacity);\n    ///\n    ///     assert_eq!(String::from(\"hello\"), s);\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {\n        String { vec: Vec::from_raw_parts(buf, length, capacity) }\n    }\n\n    /// Converts a vector of bytes to a `String` without checking that the\n    /// string contains valid UTF-8.\n    ///\n    /// See the safe version, [`from_utf8`], for more details.\n    ///\n    /// [`from_utf8`]: struct.String.html#method.from_utf8\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because it does not check that the bytes passed\n    /// to it are valid UTF-8. If this constraint is violated, it may cause\n    /// memory unsafety issues with future users of the `String`, as the rest of\n    /// the standard library assumes that `String`s are valid UTF-8.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some bytes, in a vector\n    /// let sparkle_heart = vec![240, 159, 146, 150];\n    ///\n    /// let sparkle_heart = unsafe {\n    ///     String::from_utf8_unchecked(sparkle_heart)\n    /// };\n    ///\n    /// assert_eq!(\"\ud83d\udc96\", sparkle_heart);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String {\n        String { vec: bytes }\n    }\n\n    /// Converts a `String` into a byte vector.\n    ///\n    /// This consumes the `String`, so we do not need to copy its contents.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::from(\"hello\");\n    /// let bytes = s.into_bytes();\n    ///\n    /// assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_bytes(self) -> Vec<u8> {\n        self.vec\n    }\n\n    /// Extracts a string slice containing the entire `String`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::from(\"foo\");\n    ///\n    /// assert_eq!(\"foo\", s.as_str());\n    /// ```\n    #[inline]\n    #[stable(feature = \"string_as_str\", since = \"1.7.0\")]\n    pub fn as_str(&self) -> &str {\n        self\n    }\n\n    /// Converts a `String` into a mutable string slice.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foobar\");\n    /// let s_mut_str = s.as_mut_str();\n    ///\n    /// s_mut_str.make_ascii_uppercase();\n    ///\n    /// assert_eq!(\"FOOBAR\", s_mut_str);\n    /// ```\n    #[inline]\n    #[stable(feature = \"string_as_str\", since = \"1.7.0\")]\n    pub fn as_mut_str(&mut self) -> &mut str {\n        self\n    }\n\n    /// Appends a given string slice onto the end of this `String`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// s.push_str(\"bar\");\n    ///\n    /// assert_eq!(\"foobar\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn push_str(&mut self, string: &str) {\n        self.vec.extend_from_slice(string.as_bytes())\n    }\n\n    /// Returns this `String`'s capacity, in bytes.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::with_capacity(10);\n    ///\n    /// assert!(s.capacity() >= 10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn capacity(&self) -> usize {\n        self.vec.capacity()\n    }\n\n    /// Ensures that this `String`'s capacity is at least `additional` bytes\n    /// larger than its length.\n    ///\n    /// The capacity may be increased by more than `additional` bytes if it\n    /// chooses, to prevent frequent reallocations.\n    ///\n    /// If you do not want this \"at least\" behavior, see the [`reserve_exact`]\n    /// method.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new capacity overflows [`usize`].\n    ///\n    /// [`reserve_exact`]: struct.String.html#method.reserve_exact\n    /// [`usize`]: ../../std/primitive.usize.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::new();\n    ///\n    /// s.reserve(10);\n    ///\n    /// assert!(s.capacity() >= 10);\n    /// ```\n    ///\n    /// This may not actually increase the capacity:\n    ///\n    /// ```\n    /// let mut s = String::with_capacity(10);\n    /// s.push('a');\n    /// s.push('b');\n    ///\n    /// // s now has a length of 2 and a capacity of 10\n    /// assert_eq!(2, s.len());\n    /// assert_eq!(10, s.capacity());\n    ///\n    /// // Since we already have an extra 8 capacity, calling this...\n    /// s.reserve(8);\n    ///\n    /// // ... doesn't actually increase.\n    /// assert_eq!(10, s.capacity());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reserve(&mut self, additional: usize) {\n        self.vec.reserve(additional)\n    }\n\n    /// Ensures that this `String`'s capacity is `additional` bytes\n    /// larger than its length.\n    ///\n    /// Consider using the [`reserve`] method unless you absolutely know\n    /// better than the allocator.\n    ///\n    /// [`reserve`]: #method.reserve\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new capacity overflows `usize`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::new();\n    ///\n    /// s.reserve_exact(10);\n    ///\n    /// assert!(s.capacity() >= 10);\n    /// ```\n    ///\n    /// This may not actually increase the capacity:\n    ///\n    /// ```\n    /// let mut s = String::with_capacity(10);\n    /// s.push('a');\n    /// s.push('b');\n    ///\n    /// // s now has a length of 2 and a capacity of 10\n    /// assert_eq!(2, s.len());\n    /// assert_eq!(10, s.capacity());\n    ///\n    /// // Since we already have an extra 8 capacity, calling this...\n    /// s.reserve_exact(8);\n    ///\n    /// // ... doesn't actually increase.\n    /// assert_eq!(10, s.capacity());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reserve_exact(&mut self, additional: usize) {\n        self.vec.reserve_exact(additional)\n    }\n\n    /// Tries to reserve capacity for at least `additional` more elements to be inserted\n    /// in the given `String`. The collection may reserve more space to avoid\n    /// frequent reallocations. After calling `reserve`, capacity will be\n    /// greater than or equal to `self.len() + additional`. Does nothing if\n    /// capacity is already sufficient.\n    ///\n    /// # Errors\n    ///\n    /// If the capacity overflows, or the allocator reports a failure, then an error\n    /// is returned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(try_reserve)]\n    /// use std::collections::CollectionAllocErr;\n    ///\n    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr> {\n    ///     let mut output = String::new();\n    ///\n    ///     // Pre-reserve the memory, exiting if we can't\n    ///     output.try_reserve(data.len())?;\n    ///\n    ///     // Now we know this can't OOM in the middle of our complex work\n    ///     output.push_str(data);\n    ///\n    ///     Ok(output)\n    /// }\n    /// # process_data(\"rust\").expect(\"why is the test harness OOMing on 4 bytes?\");\n    /// ```\n    #[unstable(feature = \"try_reserve\", reason = \"new API\", issue=\"48043\")]\n    pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {\n        self.vec.try_reserve(additional)\n    }\n\n    /// Tries to reserves the minimum capacity for exactly `additional` more elements to\n    /// be inserted in the given `String`. After calling `reserve_exact`,\n    /// capacity will be greater than or equal to `self.len() + additional`.\n    /// Does nothing if the capacity is already sufficient.\n    ///\n    /// Note that the allocator may give the collection more space than it\n    /// requests. Therefore capacity can not be relied upon to be precisely\n    /// minimal. Prefer `reserve` if future insertions are expected.\n    ///\n    /// # Errors\n    ///\n    /// If the capacity overflows, or the allocator reports a failure, then an error\n    /// is returned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(try_reserve)]\n    /// use std::collections::CollectionAllocErr;\n    ///\n    /// fn process_data(data: &str) -> Result<String, CollectionAllocErr> {\n    ///     let mut output = String::new();\n    ///\n    ///     // Pre-reserve the memory, exiting if we can't\n    ///     output.try_reserve(data.len())?;\n    ///\n    ///     // Now we know this can't OOM in the middle of our complex work\n    ///     output.push_str(data);\n    ///\n    ///     Ok(output)\n    /// }\n    /// # process_data(\"rust\").expect(\"why is the test harness OOMing on 4 bytes?\");\n    /// ```\n    #[unstable(feature = \"try_reserve\", reason = \"new API\", issue=\"48043\")]\n    pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), CollectionAllocErr>  {\n        self.vec.try_reserve_exact(additional)\n    }\n\n    /// Shrinks the capacity of this `String` to match its length.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// s.reserve(100);\n    /// assert!(s.capacity() >= 100);\n    ///\n    /// s.shrink_to_fit();\n    /// assert_eq!(3, s.capacity());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn shrink_to_fit(&mut self) {\n        self.vec.shrink_to_fit()\n    }\n\n    /// Shrinks the capacity of this `String` with a lower bound.\n    ///\n    /// The capacity will remain at least as large as both the length\n    /// and the supplied value.\n    ///\n    /// Panics if the current capacity is smaller than the supplied\n    /// minimum capacity.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(shrink_to)]\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// s.reserve(100);\n    /// assert!(s.capacity() >= 100);\n    ///\n    /// s.shrink_to(10);\n    /// assert!(s.capacity() >= 10);\n    /// s.shrink_to(0);\n    /// assert!(s.capacity() >= 3);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"shrink_to\", reason = \"new API\", issue=\"0\")]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        self.vec.shrink_to(min_capacity)\n    }\n\n    /// Appends the given [`char`] to the end of this `String`.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"abc\");\n    ///\n    /// s.push('1');\n    /// s.push('2');\n    /// s.push('3');\n    ///\n    /// assert_eq!(\"abc123\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn push(&mut self, ch: char) {\n        match ch.len_utf8() {\n            1 => self.vec.push(ch as u8),\n            _ => self.vec.extend_from_slice(ch.encode_utf8(&mut [0; 4]).as_bytes()),\n        }\n    }\n\n    /// Returns a byte slice of this `String`'s contents.\n    ///\n    /// The inverse of this method is [`from_utf8`].\n    ///\n    /// [`from_utf8`]: #method.from_utf8\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::from(\"hello\");\n    ///\n    /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_bytes(&self) -> &[u8] {\n        &self.vec\n    }\n\n    /// Shortens this `String` to the specified length.\n    ///\n    /// If `new_len` is greater than the string's current length, this has no\n    /// effect.\n    ///\n    /// Note that this method has no effect on the allocated capacity\n    /// of the string\n    ///\n    /// # Panics\n    ///\n    /// Panics if `new_len` does not lie on a [`char`] boundary.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"hello\");\n    ///\n    /// s.truncate(2);\n    ///\n    /// assert_eq!(\"he\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn truncate(&mut self, new_len: usize) {\n        if new_len <= self.len() {\n            assert!(self.is_char_boundary(new_len));\n            self.vec.truncate(new_len)\n        }\n    }\n\n    /// Removes the last character from the string buffer and returns it.\n    ///\n    /// Returns [`None`] if this `String` is empty.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// assert_eq!(s.pop(), Some('o'));\n    /// assert_eq!(s.pop(), Some('o'));\n    /// assert_eq!(s.pop(), Some('f'));\n    ///\n    /// assert_eq!(s.pop(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn pop(&mut self) -> Option<char> {\n        let ch = self.chars().rev().next()?;\n        let newlen = self.len() - ch.len_utf8();\n        unsafe {\n            self.vec.set_len(newlen);\n        }\n        Some(ch)\n    }\n\n    /// Removes a [`char`] from this `String` at a byte position and returns it.\n    ///\n    /// This is an `O(n)` operation, as it requires copying every element in the\n    /// buffer.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `idx` is larger than or equal to the `String`'s length,\n    /// or if it does not lie on a [`char`] boundary.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// assert_eq!(s.remove(0), 'f');\n    /// assert_eq!(s.remove(1), 'o');\n    /// assert_eq!(s.remove(0), 'o');\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove(&mut self, idx: usize) -> char {\n        let ch = match self[idx..].chars().next() {\n            Some(ch) => ch,\n            None => panic!(\"cannot remove a char from the end of a string\"),\n        };\n\n        let next = idx + ch.len_utf8();\n        let len = self.len();\n        unsafe {\n            ptr::copy(self.vec.as_ptr().add(next),\n                      self.vec.as_mut_ptr().add(idx),\n                      len - next);\n            self.vec.set_len(len - (next - idx));\n        }\n        ch\n    }\n\n    /// Retains only the characters specified by the predicate.\n    ///\n    /// In other words, remove all characters `c` such that `f(c)` returns `false`.\n    /// This method operates in place and preserves the order of the retained\n    /// characters.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut s = String::from(\"f_o_ob_ar\");\n    ///\n    /// s.retain(|c| c != '_');\n    ///\n    /// assert_eq!(s, \"foobar\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"string_retain\", since = \"1.26.0\")]\n    pub fn retain<F>(&mut self, mut f: F)\n        where F: FnMut(char) -> bool\n    {\n        let len = self.len();\n        let mut del_bytes = 0;\n        let mut idx = 0;\n\n        while idx < len {\n            let ch = unsafe {\n                self.get_unchecked(idx..len).chars().next().unwrap()\n            };\n            let ch_len = ch.len_utf8();\n\n            if !f(ch) {\n                del_bytes += ch_len;\n            } else if del_bytes > 0 {\n                unsafe {\n                    ptr::copy(self.vec.as_ptr().add(idx),\n                              self.vec.as_mut_ptr().add(idx - del_bytes),\n                              ch_len);\n                }\n            }\n\n            // Point idx to the next char\n            idx += ch_len;\n        }\n\n        if del_bytes > 0 {\n            unsafe { self.vec.set_len(len - del_bytes); }\n        }\n    }\n\n    /// Inserts a character into this `String` at a byte position.\n    ///\n    /// This is an `O(n)` operation as it requires copying every element in the\n    /// buffer.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `idx` is larger than the `String`'s length, or if it does not\n    /// lie on a [`char`] boundary.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::with_capacity(3);\n    ///\n    /// s.insert(0, 'f');\n    /// s.insert(1, 'o');\n    /// s.insert(2, 'o');\n    ///\n    /// assert_eq!(\"foo\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, idx: usize, ch: char) {\n        assert!(self.is_char_boundary(idx));\n        let mut bits = [0; 4];\n        let bits = ch.encode_utf8(&mut bits).as_bytes();\n\n        unsafe {\n            self.insert_bytes(idx, bits);\n        }\n    }\n\n    unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) {\n        let len = self.len();\n        let amt = bytes.len();\n        self.vec.reserve(amt);\n\n        ptr::copy(self.vec.as_ptr().add(idx),\n                  self.vec.as_mut_ptr().add(idx + amt),\n                  len - idx);\n        ptr::copy(bytes.as_ptr(),\n                  self.vec.as_mut_ptr().add(idx),\n                  amt);\n        self.vec.set_len(len + amt);\n    }\n\n    /// Inserts a string slice into this `String` at a byte position.\n    ///\n    /// This is an `O(n)` operation as it requires copying every element in the\n    /// buffer.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `idx` is larger than the `String`'s length, or if it does not\n    /// lie on a [`char`] boundary.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"bar\");\n    ///\n    /// s.insert_str(0, \"foo\");\n    ///\n    /// assert_eq!(\"foobar\", s);\n    /// ```\n    #[inline]\n    #[stable(feature = \"insert_str\", since = \"1.16.0\")]\n    pub fn insert_str(&mut self, idx: usize, string: &str) {\n        assert!(self.is_char_boundary(idx));\n\n        unsafe {\n            self.insert_bytes(idx, string.as_bytes());\n        }\n    }\n\n    /// Returns a mutable reference to the contents of this `String`.\n    ///\n    /// # Safety\n    ///\n    /// This function is unsafe because it does not check that the bytes passed\n    /// to it are valid UTF-8. If this constraint is violated, it may cause\n    /// memory unsafety issues with future users of the `String`, as the rest of\n    /// the standard library assumes that `String`s are valid UTF-8.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"hello\");\n    ///\n    /// unsafe {\n    ///     let vec = s.as_mut_vec();\n    ///     assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);\n    ///\n    ///     vec.reverse();\n    /// }\n    /// assert_eq!(s, \"olleh\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {\n        &mut self.vec\n    }\n\n    /// Returns the length of this `String`, in bytes.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = String::from(\"foo\");\n    ///\n    /// assert_eq!(a.len(), 3);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn len(&self) -> usize {\n        self.vec.len()\n    }\n\n    /// Returns `true` if this `String` has a length of zero.\n    ///\n    /// Returns `false` otherwise.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut v = String::new();\n    /// assert!(v.is_empty());\n    ///\n    /// v.push('a');\n    /// assert!(!v.is_empty());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n\n    /// Splits the string into two at the given index.\n    ///\n    /// Returns a newly allocated `String`. `self` contains bytes `[0, at)`, and\n    /// the returned `String` contains bytes `[at, len)`. `at` must be on the\n    /// boundary of a UTF-8 code point.\n    ///\n    /// Note that the capacity of `self` does not change.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last\n    /// code point of the string.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # fn main() {\n    /// let mut hello = String::from(\"Hello, World!\");\n    /// let world = hello.split_off(7);\n    /// assert_eq!(hello, \"Hello, \");\n    /// assert_eq!(world, \"World!\");\n    /// # }\n    /// ```\n    #[inline]\n    #[stable(feature = \"string_split_off\", since = \"1.16.0\")]\n    pub fn split_off(&mut self, at: usize) -> String {\n        assert!(self.is_char_boundary(at));\n        let other = self.vec.split_off(at);\n        unsafe { String::from_utf8_unchecked(other) }\n    }\n\n    /// Truncates this `String`, removing all contents.\n    ///\n    /// While this means the `String` will have a length of zero, it does not\n    /// touch its capacity.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"foo\");\n    ///\n    /// s.clear();\n    ///\n    /// assert!(s.is_empty());\n    /// assert_eq!(0, s.len());\n    /// assert_eq!(3, s.capacity());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn clear(&mut self) {\n        self.vec.clear()\n    }\n\n    /// Creates a draining iterator that removes the specified range in the `String`\n    /// and yields the removed `chars`.\n    ///\n    /// Note: The element range is removed even if the iterator is not\n    /// consumed until the end.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the starting point or end point do not lie on a [`char`]\n    /// boundary, or if they're out of bounds.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"\u03b1 is alpha, \u03b2 is beta\");\n    /// let beta_offset = s.find('\u03b2').unwrap_or(s.len());\n    ///\n    /// // Remove the range up until the \u03b2 from the string\n    /// let t: String = s.drain(..beta_offset).collect();\n    /// assert_eq!(t, \"\u03b1 is alpha, \");\n    /// assert_eq!(s, \"\u03b2 is beta\");\n    ///\n    /// // A full range clears the string\n    /// s.drain(..);\n    /// assert_eq!(s, \"\");\n    /// ```\n    #[stable(feature = \"drain\", since = \"1.6.0\")]\n    pub fn drain<R>(&mut self, range: R) -> Drain\n        where R: RangeBounds<usize>\n    {\n        // Memory safety\n        //\n        // The String version of Drain does not have the memory safety issues\n        // of the vector version. The data is just plain bytes.\n        // Because the range removal happens in Drop, if the Drain iterator is leaked,\n        // the removal will not happen.\n        let len = self.len();\n        let start = match range.start_bound() {\n            Included(&n) => n,\n            Excluded(&n) => n + 1,\n            Unbounded => 0,\n        };\n        let end = match range.end_bound() {\n            Included(&n) => n + 1,\n            Excluded(&n) => n,\n            Unbounded => len,\n        };\n\n        // Take out two simultaneous borrows. The &mut String won't be accessed\n        // until iteration is over, in Drop.\n        let self_ptr = self as *mut _;\n        // slicing does the appropriate bounds checks\n        let chars_iter = self[start..end].chars();\n\n        Drain {\n            start,\n            end,\n            iter: chars_iter,\n            string: self_ptr,\n        }\n    }\n\n    /// Removes the specified range in the string,\n    /// and replaces it with the given string.\n    /// The given string doesn't need to be the same length as the range.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the starting point or end point do not lie on a [`char`]\n    /// boundary, or if they're out of bounds.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    /// [`Vec::splice`]: ../../std/vec/struct.Vec.html#method.splice\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let mut s = String::from(\"\u03b1 is alpha, \u03b2 is beta\");\n    /// let beta_offset = s.find('\u03b2').unwrap_or(s.len());\n    ///\n    /// // Replace the range up until the \u03b2 from the string\n    /// s.replace_range(..beta_offset, \"\u0391 is capital alpha; \");\n    /// assert_eq!(s, \"\u0391 is capital alpha; \u03b2 is beta\");\n    /// ```\n    #[stable(feature = \"splice\", since = \"1.27.0\")]\n    pub fn replace_range<R>(&mut self, range: R, replace_with: &str)\n        where R: RangeBounds<usize>\n    {\n        // Memory safety\n        //\n        // Replace_range does not have the memory safety issues of a vector Splice.\n        // of the vector version. The data is just plain bytes.\n\n        match range.start_bound() {\n             Included(&n) => assert!(self.is_char_boundary(n)),\n             Excluded(&n) => assert!(self.is_char_boundary(n + 1)),\n             Unbounded => {},\n        };\n        match range.end_bound() {\n             Included(&n) => assert!(self.is_char_boundary(n + 1)),\n             Excluded(&n) => assert!(self.is_char_boundary(n)),\n             Unbounded => {},\n        };\n\n        unsafe {\n            self.as_mut_vec()\n        }.splice(range, replace_with.bytes());\n    }\n\n    /// Converts this `String` into a [`Box`]`<`[`str`]`>`.\n    ///\n    /// This will drop any excess capacity.\n    ///\n    /// [`Box`]: ../../std/boxed/struct.Box.html\n    /// [`str`]: ../../std/primitive.str.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = String::from(\"hello\");\n    ///\n    /// let b = s.into_boxed_str();\n    /// ```\n    #[stable(feature = \"box_str\", since = \"1.4.0\")]\n    #[inline]\n    pub fn into_boxed_str(self) -> Box<str> {\n        let slice = self.vec.into_boxed_slice();\n        unsafe { from_boxed_utf8_unchecked(slice) }\n    }\n}\n\nimpl FromUtf8Error {\n    /// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some invalid bytes, in a vector\n    /// let bytes = vec![0, 159];\n    ///\n    /// let value = String::from_utf8(bytes);\n    ///\n    /// assert_eq!(&[0, 159], value.unwrap_err().as_bytes());\n    /// ```\n    #[stable(feature = \"from_utf8_error_as_bytes\", since = \"1.26.0\")]\n    pub fn as_bytes(&self) -> &[u8] {\n        &self.bytes[..]\n    }\n\n    /// Returns the bytes that were attempted to convert to a `String`.\n    ///\n    /// This method is carefully constructed to avoid allocation. It will\n    /// consume the error, moving out the bytes, so that a copy of the bytes\n    /// does not need to be made.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some invalid bytes, in a vector\n    /// let bytes = vec![0, 159];\n    ///\n    /// let value = String::from_utf8(bytes);\n    ///\n    /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_bytes(self) -> Vec<u8> {\n        self.bytes\n    }\n\n    /// Fetch a `Utf8Error` to get more details about the conversion failure.\n    ///\n    /// The [`Utf8Error`] type provided by [`std::str`] represents an error that may\n    /// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's\n    /// an analogue to `FromUtf8Error`. See its documentation for more details\n    /// on using it.\n    ///\n    /// [`Utf8Error`]: ../../std/str/struct.Utf8Error.html\n    /// [`std::str`]: ../../std/str/index.html\n    /// [`u8`]: ../../std/primitive.u8.html\n    /// [`&str`]: ../../std/primitive.str.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // some invalid bytes, in a vector\n    /// let bytes = vec![0, 159];\n    ///\n    /// let error = String::from_utf8(bytes).unwrap_err().utf8_error();\n    ///\n    /// // the first byte is invalid here\n    /// assert_eq!(1, error.valid_up_to());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn utf8_error(&self) -> Utf8Error {\n        self.error\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for FromUtf8Error {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&self.error, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for FromUtf16Error {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(\"invalid utf-16: lone surrogate found\", f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Clone for String {\n    fn clone(&self) -> Self {\n        String { vec: self.vec.clone() }\n    }\n\n    fn clone_from(&mut self, source: &Self) {\n        self.vec.clone_from(&source.vec);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromIterator<char> for String {\n    fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String {\n        let mut buf = String::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"string_from_iter_by_ref\", since = \"1.17.0\")]\nimpl<'a> FromIterator<&'a char> for String {\n    fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String {\n        let mut buf = String::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> FromIterator<&'a str> for String {\n    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String {\n        let mut buf = String::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"extend_string\", since = \"1.4.0\")]\nimpl FromIterator<String> for String {\n    fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String {\n        let mut buf = String::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"herd_cows\", since = \"1.19.0\")]\nimpl<'a> FromIterator<Cow<'a, str>> for String {\n    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {\n        let mut buf = String::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Extend<char> for String {\n    fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {\n        let iterator = iter.into_iter();\n        let (lower_bound, _) = iterator.size_hint();\n        self.reserve(lower_bound);\n        for ch in iterator {\n            self.push(ch)\n        }\n    }\n}\n\n#[stable(feature = \"extend_ref\", since = \"1.2.0\")]\nimpl<'a> Extend<&'a char> for String {\n    fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {\n        self.extend(iter.into_iter().cloned());\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Extend<&'a str> for String {\n    fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {\n        for s in iter {\n            self.push_str(s)\n        }\n    }\n}\n\n#[stable(feature = \"extend_string\", since = \"1.4.0\")]\nimpl Extend<String> for String {\n    fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {\n        for s in iter {\n            self.push_str(&s)\n        }\n    }\n}\n\n#[stable(feature = \"herd_cows\", since = \"1.19.0\")]\nimpl<'a> Extend<Cow<'a, str>> for String {\n    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {\n        for s in iter {\n            self.push_str(&s)\n        }\n    }\n}\n\n/// A convenience impl that delegates to the impl for `&str`\n#[unstable(feature = \"pattern\",\n           reason = \"API not fully fleshed out and ready to be stabilized\",\n           issue = \"27721\")]\nimpl<'a, 'b> Pattern<'a> for &'b String {\n    type Searcher = <&'b str as Pattern<'a>>::Searcher;\n\n    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {\n        self[..].into_searcher(haystack)\n    }\n\n    #[inline]\n    fn is_contained_in(self, haystack: &'a str) -> bool {\n        self[..].is_contained_in(haystack)\n    }\n\n    #[inline]\n    fn is_prefix_of(self, haystack: &'a str) -> bool {\n        self[..].is_prefix_of(haystack)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for String {\n    #[inline]\n    fn eq(&self, other: &String) -> bool {\n        PartialEq::eq(&self[..], &other[..])\n    }\n    #[inline]\n    fn ne(&self, other: &String) -> bool {\n        PartialEq::ne(&self[..], &other[..])\n    }\n}\n\nmacro_rules! impl_eq {\n    ($lhs:ty, $rhs: ty) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, 'b> PartialEq<$rhs> for $lhs {\n            #[inline]\n            fn eq(&self, other: &$rhs) -> bool { PartialEq::eq(&self[..], &other[..]) }\n            #[inline]\n            fn ne(&self, other: &$rhs) -> bool { PartialEq::ne(&self[..], &other[..]) }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, 'b> PartialEq<$lhs> for $rhs {\n            #[inline]\n            fn eq(&self, other: &$lhs) -> bool { PartialEq::eq(&self[..], &other[..]) }\n            #[inline]\n            fn ne(&self, other: &$lhs) -> bool { PartialEq::ne(&self[..], &other[..]) }\n        }\n\n    }\n}\n\nimpl_eq! { String, str }\nimpl_eq! { String, &'a str }\nimpl_eq! { Cow<'a, str>, str }\nimpl_eq! { Cow<'a, str>, &'b str }\nimpl_eq! { Cow<'a, str>, String }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Default for String {\n    /// Creates an empty `String`.\n    #[inline]\n    fn default() -> String {\n        String::new()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for String {\n    #[inline]\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for String {\n    #[inline]\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl hash::Hash for String {\n    #[inline]\n    fn hash<H: hash::Hasher>(&self, hasher: &mut H) {\n        (**self).hash(hasher)\n    }\n}\n\n/// Implements the `+` operator for concatenating two strings.\n///\n/// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if\n/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on\n/// every operation, which would lead to `O(n^2)` running time when building an `n`-byte string by\n/// repeated concatenation.\n///\n/// The string on the right-hand side is only borrowed; its contents are copied into the returned\n/// `String`.\n///\n/// # Examples\n///\n/// Concatenating two `String`s takes the first by value and borrows the second:\n///\n/// ```\n/// let a = String::from(\"hello\");\n/// let b = String::from(\" world\");\n/// let c = a + &b;\n/// // `a` is moved and can no longer be used here.\n/// ```\n///\n/// If you want to keep using the first `String`, you can clone it and append to the clone instead:\n///\n/// ```\n/// let a = String::from(\"hello\");\n/// let b = String::from(\" world\");\n/// let c = a.clone() + &b;\n/// // `a` is still valid here.\n/// ```\n///\n/// Concatenating `&str` slices can be done by converting the first to a `String`:\n///\n/// ```\n/// let a = \"hello\";\n/// let b = \" world\";\n/// let c = a.to_string() + b;\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Add<&'a str> for String {\n    type Output = String;\n\n    #[inline]\n    fn add(mut self, other: &str) -> String {\n        self.push_str(other);\n        self\n    }\n}\n\n/// Implements the `+=` operator for appending to a `String`.\n///\n/// This has the same behavior as the [`push_str`][String::push_str] method.\n#[stable(feature = \"stringaddassign\", since = \"1.12.0\")]\nimpl<'a> AddAssign<&'a str> for String {\n    #[inline]\n    fn add_assign(&mut self, other: &str) {\n        self.push_str(other);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Index<ops::Range<usize>> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, index: ops::Range<usize>) -> &str {\n        &self[..][index]\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Index<ops::RangeTo<usize>> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, index: ops::RangeTo<usize>) -> &str {\n        &self[..][index]\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Index<ops::RangeFrom<usize>> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, index: ops::RangeFrom<usize>) -> &str {\n        &self[..][index]\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Index<ops::RangeFull> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, _index: ops::RangeFull) -> &str {\n        unsafe { str::from_utf8_unchecked(&self.vec) }\n    }\n}\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl ops::Index<ops::RangeInclusive<usize>> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, index: ops::RangeInclusive<usize>) -> &str {\n        Index::index(&**self, index)\n    }\n}\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl ops::Index<ops::RangeToInclusive<usize>> for String {\n    type Output = str;\n\n    #[inline]\n    fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {\n        Index::index(&**self, index)\n    }\n}\n\n#[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\nimpl ops::IndexMut<ops::Range<usize>> for String {\n    #[inline]\n    fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {\n        &mut self[..][index]\n    }\n}\n#[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\nimpl ops::IndexMut<ops::RangeTo<usize>> for String {\n    #[inline]\n    fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {\n        &mut self[..][index]\n    }\n}\n#[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\nimpl ops::IndexMut<ops::RangeFrom<usize>> for String {\n    #[inline]\n    fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {\n        &mut self[..][index]\n    }\n}\n#[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\nimpl ops::IndexMut<ops::RangeFull> for String {\n    #[inline]\n    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {\n        unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }\n    }\n}\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl ops::IndexMut<ops::RangeInclusive<usize>> for String {\n    #[inline]\n    fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {\n        IndexMut::index_mut(&mut **self, index)\n    }\n}\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl ops::IndexMut<ops::RangeToInclusive<usize>> for String {\n    #[inline]\n    fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {\n        IndexMut::index_mut(&mut **self, index)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Deref for String {\n    type Target = str;\n\n    #[inline]\n    fn deref(&self) -> &str {\n        unsafe { str::from_utf8_unchecked(&self.vec) }\n    }\n}\n\n#[stable(feature = \"derefmut_for_string\", since = \"1.3.0\")]\nimpl ops::DerefMut for String {\n    #[inline]\n    fn deref_mut(&mut self) -> &mut str {\n        unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }\n    }\n}\n\n/// An error when parsing a `String`.\n///\n/// This `enum` is slightly awkward: it will never actually exist. This error is\n/// part of the type signature of the implementation of [`FromStr`] on\n/// [`String`]. The return type of [`from_str`], requires that an error be\n/// defined, but, given that a [`String`] can always be made into a new\n/// [`String`] without error, this type will never actually be returned. As\n/// such, it is only here to satisfy said signature, and is useless otherwise.\n///\n/// [`FromStr`]: ../../std/str/trait.FromStr.html\n/// [`String`]: struct.String.html\n/// [`from_str`]: ../../std/str/trait.FromStr.html#tymethod.from_str\n#[stable(feature = \"str_parse_error\", since = \"1.5.0\")]\n#[derive(Copy)]\npub enum ParseError {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromStr for String {\n    type Err = ParseError;\n    #[inline]\n    fn from_str(s: &str) -> Result<String, ParseError> {\n        Ok(String::from(s))\n    }\n}\n\n#[stable(feature = \"str_parse_error\", since = \"1.5.0\")]\nimpl Clone for ParseError {\n    fn clone(&self) -> ParseError {\n        match *self {}\n    }\n}\n\n#[stable(feature = \"str_parse_error\", since = \"1.5.0\")]\nimpl fmt::Debug for ParseError {\n    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {\n        match *self {}\n    }\n}\n\n#[stable(feature = \"str_parse_error2\", since = \"1.8.0\")]\nimpl fmt::Display for ParseError {\n    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {\n        match *self {}\n    }\n}\n\n#[stable(feature = \"str_parse_error\", since = \"1.5.0\")]\nimpl PartialEq for ParseError {\n    fn eq(&self, _: &ParseError) -> bool {\n        match *self {}\n    }\n}\n\n#[stable(feature = \"str_parse_error\", since = \"1.5.0\")]\nimpl Eq for ParseError {}\n\n/// A trait for converting a value to a `String`.\n///\n/// This trait is automatically implemented for any type which implements the\n/// [`Display`] trait. As such, `ToString` shouldn't be implemented directly:\n/// [`Display`] should be implemented instead, and you get the `ToString`\n/// implementation for free.\n///\n/// [`Display`]: ../../std/fmt/trait.Display.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait ToString {\n    /// Converts the given value to a `String`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let i = 5;\n    /// let five = String::from(\"5\");\n    ///\n    /// assert_eq!(five, i.to_string());\n    /// ```\n    #[rustc_conversion_suggestion]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn to_string(&self) -> String;\n}\n\n/// # Panics\n///\n/// In this implementation, the `to_string` method panics\n/// if the `Display` implementation returns an error.\n/// This indicates an incorrect `Display` implementation\n/// since `fmt::Write for String` never returns an error itself.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: fmt::Display + ?Sized> ToString for T {\n    #[inline]\n    default fn to_string(&self) -> String {\n        use core::fmt::Write;\n        let mut buf = String::new();\n        buf.write_fmt(format_args!(\"{}\", self))\n           .expect(\"a Display implementation return an error unexpectedly\");\n        buf.shrink_to_fit();\n        buf\n    }\n}\n\n#[stable(feature = \"str_to_string_specialization\", since = \"1.9.0\")]\nimpl ToString for str {\n    #[inline]\n    fn to_string(&self) -> String {\n        String::from(self)\n    }\n}\n\n#[stable(feature = \"cow_str_to_string_specialization\", since = \"1.17.0\")]\nimpl<'a> ToString for Cow<'a, str> {\n    #[inline]\n    fn to_string(&self) -> String {\n        self[..].to_owned()\n    }\n}\n\n#[stable(feature = \"string_to_string_specialization\", since = \"1.17.0\")]\nimpl ToString for String {\n    #[inline]\n    fn to_string(&self) -> String {\n        self.to_owned()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<str> for String {\n    #[inline]\n    fn as_ref(&self) -> &str {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<[u8]> for String {\n    #[inline]\n    fn as_ref(&self) -> &[u8] {\n        self.as_bytes()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> From<&'a str> for String {\n    #[inline]\n    fn from(s: &'a str) -> String {\n        s.to_owned()\n    }\n}\n\n// note: test pulls in libstd, which causes errors here\n#[cfg(not(test))]\n#[stable(feature = \"string_from_box\", since = \"1.18.0\")]\nimpl From<Box<str>> for String {\n    fn from(s: Box<str>) -> String {\n        s.into_string()\n    }\n}\n\n#[stable(feature = \"box_from_str\", since = \"1.20.0\")]\nimpl From<String> for Box<str> {\n    fn from(s: String) -> Box<str> {\n        s.into_boxed_str()\n    }\n}\n\n#[stable(feature = \"string_from_cow_str\", since = \"1.14.0\")]\nimpl<'a> From<Cow<'a, str>> for String {\n    fn from(s: Cow<'a, str>) -> String {\n        s.into_owned()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> From<&'a str> for Cow<'a, str> {\n    #[inline]\n    fn from(s: &'a str) -> Cow<'a, str> {\n        Cow::Borrowed(s)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> From<String> for Cow<'a, str> {\n    #[inline]\n    fn from(s: String) -> Cow<'a, str> {\n        Cow::Owned(s)\n    }\n}\n\n#[stable(feature = \"cow_from_string_ref\", since = \"1.28.0\")]\nimpl<'a> From<&'a String> for Cow<'a, str> {\n    #[inline]\n    fn from(s: &'a String) -> Cow<'a, str> {\n        Cow::Borrowed(s.as_str())\n    }\n}\n\n#[stable(feature = \"cow_str_from_iter\", since = \"1.12.0\")]\nimpl<'a> FromIterator<char> for Cow<'a, str> {\n    fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str> {\n        Cow::Owned(FromIterator::from_iter(it))\n    }\n}\n\n#[stable(feature = \"cow_str_from_iter\", since = \"1.12.0\")]\nimpl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {\n    fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str> {\n        Cow::Owned(FromIterator::from_iter(it))\n    }\n}\n\n#[stable(feature = \"cow_str_from_iter\", since = \"1.12.0\")]\nimpl<'a> FromIterator<String> for Cow<'a, str> {\n    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str> {\n        Cow::Owned(FromIterator::from_iter(it))\n    }\n}\n\n#[stable(feature = \"from_string_for_vec_u8\", since = \"1.14.0\")]\nimpl From<String> for Vec<u8> {\n    fn from(string: String) -> Vec<u8> {\n        string.into_bytes()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Write for String {\n    #[inline]\n    fn write_str(&mut self, s: &str) -> fmt::Result {\n        self.push_str(s);\n        Ok(())\n    }\n\n    #[inline]\n    fn write_char(&mut self, c: char) -> fmt::Result {\n        self.push(c);\n        Ok(())\n    }\n}\n\n/// A draining iterator for `String`.\n///\n/// This struct is created by the [`drain`] method on [`String`]. See its\n/// documentation for more.\n///\n/// [`drain`]: struct.String.html#method.drain\n/// [`String`]: struct.String.html\n#[stable(feature = \"drain\", since = \"1.6.0\")]\npub struct Drain<'a> {\n    /// Will be used as &'a mut String in the destructor\n    string: *mut String,\n    /// Start of part to remove\n    start: usize,\n    /// End of part to remove\n    end: usize,\n    /// Current remaining range to remove\n    iter: Chars<'a>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a> fmt::Debug for Drain<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Drain { .. }\")\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nunsafe impl<'a> Sync for Drain<'a> {}\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nunsafe impl<'a> Send for Drain<'a> {}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a> Drop for Drain<'a> {\n    fn drop(&mut self) {\n        unsafe {\n            // Use Vec::drain. \"Reaffirm\" the bounds checks to avoid\n            // panic code being inserted again.\n            let self_vec = (*self.string).as_mut_vec();\n            if self.start <= self.end && self.end <= self_vec.len() {\n                self_vec.drain(self.start..self.end);\n            }\n        }\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a> Iterator for Drain<'a> {\n    type Item = char;\n\n    #[inline]\n    fn next(&mut self) -> Option<char> {\n        self.iter.next()\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a> DoubleEndedIterator for Drain<'a> {\n    #[inline]\n    fn next_back(&mut self) -> Option<char> {\n        self.iter.next_back()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a> FusedIterator for Drain<'a> {}\n","// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Memory allocation APIs\n\n#![stable(feature = \"alloc_module\", since = \"1.28.0\")]\n\nuse core::intrinsics::{min_align_of_val, size_of_val};\nuse core::ptr::{NonNull, Unique};\nuse core::usize;\n\n#[stable(feature = \"alloc_module\", since = \"1.28.0\")]\n#[doc(inline)]\npub use core::alloc::*;\n\nextern \"Rust\" {\n    #[allocator]\n    #[rustc_allocator_nounwind]\n    fn __rust_alloc(size: usize, align: usize) -> *mut u8;\n    #[rustc_allocator_nounwind]\n    fn __rust_dealloc(ptr: *mut u8, size: usize, align: usize);\n    #[rustc_allocator_nounwind]\n    fn __rust_realloc(ptr: *mut u8,\n                      old_size: usize,\n                      align: usize,\n                      new_size: usize) -> *mut u8;\n    #[rustc_allocator_nounwind]\n    fn __rust_alloc_zeroed(size: usize, align: usize) -> *mut u8;\n}\n\n/// The global memory allocator.\n///\n/// This type implements the [`Alloc`] trait by forwarding calls\n/// to the allocator registered with the `#[global_allocator]` attribute\n/// if there is one, or the `std` crate\u2019s default.\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\n#[derive(Copy, Clone, Default, Debug)]\npub struct Global;\n\n/// Allocate memory with the global allocator.\n///\n/// This function forwards calls to the [`GlobalAlloc::alloc`] method\n/// of the allocator registered with the `#[global_allocator]` attribute\n/// if there is one, or the `std` crate\u2019s default.\n///\n/// This function is expected to be deprecated in favor of the `alloc` method\n/// of the [`Global`] type when it and the [`Alloc`] trait become stable.\n///\n/// # Safety\n///\n/// See [`GlobalAlloc::alloc`].\n///\n/// # Examples\n///\n/// ```\n/// use std::alloc::{alloc, dealloc, Layout};\n///\n/// unsafe {\n///     let layout = Layout::new::<u16>();\n///     let ptr = alloc(layout);\n///\n///     *(ptr as *mut u16) = 42;\n///     assert_eq!(*(ptr as *mut u16), 42);\n///\n///     dealloc(ptr, layout);\n/// }\n/// ```\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n#[inline]\npub unsafe fn alloc(layout: Layout) -> *mut u8 {\n    __rust_alloc(layout.size(), layout.align())\n}\n\n/// Deallocate memory with the global allocator.\n///\n/// This function forwards calls to the [`GlobalAlloc::dealloc`] method\n/// of the allocator registered with the `#[global_allocator]` attribute\n/// if there is one, or the `std` crate\u2019s default.\n///\n/// This function is expected to be deprecated in favor of the `dealloc` method\n/// of the [`Global`] type when it and the [`Alloc`] trait become stable.\n///\n/// # Safety\n///\n/// See [`GlobalAlloc::dealloc`].\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n#[inline]\npub unsafe fn dealloc(ptr: *mut u8, layout: Layout) {\n    __rust_dealloc(ptr, layout.size(), layout.align())\n}\n\n/// Reallocate memory with the global allocator.\n///\n/// This function forwards calls to the [`GlobalAlloc::realloc`] method\n/// of the allocator registered with the `#[global_allocator]` attribute\n/// if there is one, or the `std` crate\u2019s default.\n///\n/// This function is expected to be deprecated in favor of the `realloc` method\n/// of the [`Global`] type when it and the [`Alloc`] trait become stable.\n///\n/// # Safety\n///\n/// See [`GlobalAlloc::realloc`].\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n#[inline]\npub unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {\n    __rust_realloc(ptr, layout.size(), layout.align(), new_size)\n}\n\n/// Allocate zero-initialized memory with the global allocator.\n///\n/// This function forwards calls to the [`GlobalAlloc::alloc_zeroed`] method\n/// of the allocator registered with the `#[global_allocator]` attribute\n/// if there is one, or the `std` crate\u2019s default.\n///\n/// This function is expected to be deprecated in favor of the `alloc_zeroed` method\n/// of the [`Global`] type when it and the [`Alloc`] trait become stable.\n///\n/// # Safety\n///\n/// See [`GlobalAlloc::alloc_zeroed`].\n///\n/// # Examples\n///\n/// ```\n/// use std::alloc::{alloc_zeroed, dealloc, Layout};\n///\n/// unsafe {\n///     let layout = Layout::new::<u16>();\n///     let ptr = alloc_zeroed(layout);\n///\n///     assert_eq!(*(ptr as *mut u16), 0);\n///\n///     dealloc(ptr, layout);\n/// }\n/// ```\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n#[inline]\npub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {\n    __rust_alloc_zeroed(layout.size(), layout.align())\n}\n\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\nunsafe impl Alloc for Global {\n    #[inline]\n    unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n        NonNull::new(alloc(layout)).ok_or(AllocErr)\n    }\n\n    #[inline]\n    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {\n        dealloc(ptr.as_ptr(), layout)\n    }\n\n    #[inline]\n    unsafe fn realloc(&mut self,\n                      ptr: NonNull<u8>,\n                      layout: Layout,\n                      new_size: usize)\n                      -> Result<NonNull<u8>, AllocErr>\n    {\n        NonNull::new(realloc(ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)\n    }\n\n    #[inline]\n    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n        NonNull::new(alloc_zeroed(layout)).ok_or(AllocErr)\n    }\n}\n\n/// The allocator for unique pointers.\n// This function must not unwind. If it does, MIR codegen will fail.\n#[cfg(not(test))]\n#[lang = \"exchange_malloc\"]\n#[inline]\nunsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {\n    if size == 0 {\n        align as *mut u8\n    } else {\n        let layout = Layout::from_size_align_unchecked(size, align);\n        let ptr = alloc(layout);\n        if !ptr.is_null() {\n            ptr\n        } else {\n            handle_alloc_error(layout)\n        }\n    }\n}\n\n#[cfg_attr(not(test), lang = \"box_free\")]\n#[inline]\npub(crate) unsafe fn box_free<T: ?Sized>(ptr: Unique<T>) {\n    let ptr = ptr.as_ptr();\n    let size = size_of_val(&*ptr);\n    let align = min_align_of_val(&*ptr);\n    // We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.\n    if size != 0 {\n        let layout = Layout::from_size_align_unchecked(size, align);\n        dealloc(ptr as *mut u8, layout);\n    }\n}\n\n/// Abort on memory allocation error or failure.\n///\n/// Callers of memory allocation APIs wishing to abort computation\n/// in response to an allocation error are encouraged to call this function,\n/// rather than directly invoking `panic!` or similar.\n///\n/// The default behavior of this function is to print a message to standard error\n/// and abort the process.\n/// It can be replaced with [`set_alloc_error_hook`] and [`take_alloc_error_hook`].\n///\n/// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html\n/// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html\n#[stable(feature = \"global_alloc\", since = \"1.28.0\")]\n#[rustc_allocator_nounwind]\npub fn handle_alloc_error(layout: Layout) -> ! {\n    #[allow(improper_ctypes)]\n    extern \"Rust\" {\n        #[lang = \"oom\"]\n        fn oom_impl(layout: Layout) -> !;\n    }\n    unsafe { oom_impl(layout) }\n}\n\n#[cfg(test)]\nmod tests {\n    extern crate test;\n    use self::test::Bencher;\n    use boxed::Box;\n    use alloc::{Global, Alloc, Layout, handle_alloc_error};\n\n    #[test]\n    fn allocate_zeroed() {\n        unsafe {\n            let layout = Layout::from_size_align(1024, 1).unwrap();\n            let ptr = Global.alloc_zeroed(layout.clone())\n                .unwrap_or_else(|_| handle_alloc_error(layout));\n\n            let mut i = ptr.cast::<u8>().as_ptr();\n            let end = i.add(layout.size());\n            while i < end {\n                assert_eq!(*i, 0);\n                i = i.offset(1);\n            }\n            Global.dealloc(ptr, layout);\n        }\n    }\n\n    #[bench]\n    fn alloc_owned_small(b: &mut Bencher) {\n        b.iter(|| {\n            let _: Box<_> = box 10;\n        })\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![unstable(feature = \"raw_vec_internals\", reason = \"implementation detail\", issue = \"0\")]\n#![doc(hidden)]\n\nuse core::cmp;\nuse core::mem;\nuse core::ops::Drop;\nuse core::ptr::{self, NonNull, Unique};\nuse core::slice;\n\nuse alloc::{Alloc, Layout, Global, handle_alloc_error};\nuse collections::CollectionAllocErr;\nuse collections::CollectionAllocErr::*;\nuse boxed::Box;\n\n/// A low-level utility for more ergonomically allocating, reallocating, and deallocating\n/// a buffer of memory on the heap without having to worry about all the corner cases\n/// involved. This type is excellent for building your own data structures like Vec and VecDeque.\n/// In particular:\n///\n/// * Produces Unique::empty() on zero-sized types\n/// * Produces Unique::empty() on zero-length allocations\n/// * Catches all overflows in capacity computations (promotes them to \"capacity overflow\" panics)\n/// * Guards against 32-bit systems allocating more than isize::MAX bytes\n/// * Guards against overflowing your length\n/// * Aborts on OOM\n/// * Avoids freeing Unique::empty()\n/// * Contains a ptr::Unique and thus endows the user with all related benefits\n///\n/// This type does not in anyway inspect the memory that it manages. When dropped it *will*\n/// free its memory, but it *won't* try to Drop its contents. It is up to the user of RawVec\n/// to handle the actual things *stored* inside of a RawVec.\n///\n/// Note that a RawVec always forces its capacity to be usize::MAX for zero-sized types.\n/// This enables you to use capacity growing logic catch the overflows in your length\n/// that might occur with zero-sized types.\n///\n/// However this means that you need to be careful when roundtripping this type\n/// with a `Box<[T]>`: `cap()` won't yield the len. However `with_capacity`,\n/// `shrink_to_fit`, and `from_box` will actually set RawVec's private capacity\n/// field. This allows zero-sized types to not be special-cased by consumers of\n/// this type.\n#[allow(missing_debug_implementations)]\npub struct RawVec<T, A: Alloc = Global> {\n    ptr: Unique<T>,\n    cap: usize,\n    a: A,\n}\n\nimpl<T, A: Alloc> RawVec<T, A> {\n    /// Like `new` but parameterized over the choice of allocator for\n    /// the returned RawVec.\n    pub const fn new_in(a: A) -> Self {\n        // !0 is usize::MAX. This branch should be stripped at compile time.\n        // FIXME(mark-i-m): use this line when `if`s are allowed in `const`\n        //let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 };\n\n        // Unique::empty() doubles as \"unallocated\" and \"zero-sized allocation\"\n        RawVec {\n            ptr: Unique::empty(),\n            // FIXME(mark-i-m): use `cap` when ifs are allowed in const\n            cap: [0, !0][(mem::size_of::<T>() == 0) as usize],\n            a,\n        }\n    }\n\n    /// Like `with_capacity` but parameterized over the choice of\n    /// allocator for the returned RawVec.\n    #[inline]\n    pub fn with_capacity_in(cap: usize, a: A) -> Self {\n        RawVec::allocate_in(cap, false, a)\n    }\n\n    /// Like `with_capacity_zeroed` but parameterized over the choice\n    /// of allocator for the returned RawVec.\n    #[inline]\n    pub fn with_capacity_zeroed_in(cap: usize, a: A) -> Self {\n        RawVec::allocate_in(cap, true, a)\n    }\n\n    fn allocate_in(cap: usize, zeroed: bool, mut a: A) -> Self {\n        unsafe {\n            let elem_size = mem::size_of::<T>();\n\n            let alloc_size = cap.checked_mul(elem_size).unwrap_or_else(|| capacity_overflow());\n            alloc_guard(alloc_size).unwrap_or_else(|_| capacity_overflow());\n\n            // handles ZSTs and `cap = 0` alike\n            let ptr = if alloc_size == 0 {\n                NonNull::<T>::dangling()\n            } else {\n                let align = mem::align_of::<T>();\n                let layout = Layout::from_size_align(alloc_size, align).unwrap();\n                let result = if zeroed {\n                    a.alloc_zeroed(layout)\n                } else {\n                    a.alloc(layout)\n                };\n                match result {\n                    Ok(ptr) => ptr.cast(),\n                    Err(_) => handle_alloc_error(layout),\n                }\n            };\n\n            RawVec {\n                ptr: ptr.into(),\n                cap,\n                a,\n            }\n        }\n    }\n}\n\nimpl<T> RawVec<T, Global> {\n    /// Creates the biggest possible RawVec (on the system heap)\n    /// without allocating. If T has positive size, then this makes a\n    /// RawVec with capacity 0. If T has 0 size, then it makes a\n    /// RawVec with capacity `usize::MAX`. Useful for implementing\n    /// delayed allocation.\n    pub const fn new() -> Self {\n        Self::new_in(Global)\n    }\n\n    /// Creates a RawVec (on the system heap) with exactly the\n    /// capacity and alignment requirements for a `[T; cap]`. This is\n    /// equivalent to calling RawVec::new when `cap` is 0 or T is\n    /// zero-sized. Note that if `T` is zero-sized this means you will\n    /// *not* get a RawVec with the requested capacity!\n    ///\n    /// # Panics\n    ///\n    /// * Panics if the requested capacity exceeds `usize::MAX` bytes.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    ///\n    /// # Aborts\n    ///\n    /// Aborts on OOM\n    #[inline]\n    pub fn with_capacity(cap: usize) -> Self {\n        RawVec::allocate_in(cap, false, Global)\n    }\n\n    /// Like `with_capacity` but guarantees the buffer is zeroed.\n    #[inline]\n    pub fn with_capacity_zeroed(cap: usize) -> Self {\n        RawVec::allocate_in(cap, true, Global)\n    }\n}\n\nimpl<T, A: Alloc> RawVec<T, A> {\n    /// Reconstitutes a RawVec from a pointer, capacity, and allocator.\n    ///\n    /// # Undefined Behavior\n    ///\n    /// The ptr must be allocated (via the given allocator `a`), and with the given capacity. The\n    /// capacity cannot exceed `isize::MAX` (only a concern on 32-bit systems).\n    /// If the ptr and capacity come from a RawVec created via `a`, then this is guaranteed.\n    pub unsafe fn from_raw_parts_in(ptr: *mut T, cap: usize, a: A) -> Self {\n        RawVec {\n            ptr: Unique::new_unchecked(ptr),\n            cap,\n            a,\n        }\n    }\n}\n\nimpl<T> RawVec<T, Global> {\n    /// Reconstitutes a RawVec from a pointer, capacity.\n    ///\n    /// # Undefined Behavior\n    ///\n    /// The ptr must be allocated (on the system heap), and with the given capacity. The\n    /// capacity cannot exceed `isize::MAX` (only a concern on 32-bit systems).\n    /// If the ptr and capacity come from a RawVec, then this is guaranteed.\n    pub unsafe fn from_raw_parts(ptr: *mut T, cap: usize) -> Self {\n        RawVec {\n            ptr: Unique::new_unchecked(ptr),\n            cap,\n            a: Global,\n        }\n    }\n\n    /// Converts a `Box<[T]>` into a `RawVec<T>`.\n    pub fn from_box(mut slice: Box<[T]>) -> Self {\n        unsafe {\n            let result = RawVec::from_raw_parts(slice.as_mut_ptr(), slice.len());\n            mem::forget(slice);\n            result\n        }\n    }\n}\n\nimpl<T, A: Alloc> RawVec<T, A> {\n    /// Gets a raw pointer to the start of the allocation. Note that this is\n    /// Unique::empty() if `cap = 0` or T is zero-sized. In the former case, you must\n    /// be careful.\n    pub fn ptr(&self) -> *mut T {\n        self.ptr.as_ptr()\n    }\n\n    /// Gets the capacity of the allocation.\n    ///\n    /// This will always be `usize::MAX` if `T` is zero-sized.\n    #[inline(always)]\n    pub fn cap(&self) -> usize {\n        if mem::size_of::<T>() == 0 {\n            !0\n        } else {\n            self.cap\n        }\n    }\n\n    /// Returns a shared reference to the allocator backing this RawVec.\n    pub fn alloc(&self) -> &A {\n        &self.a\n    }\n\n    /// Returns a mutable reference to the allocator backing this RawVec.\n    pub fn alloc_mut(&mut self) -> &mut A {\n        &mut self.a\n    }\n\n    fn current_layout(&self) -> Option<Layout> {\n        if self.cap == 0 {\n            None\n        } else {\n            // We have an allocated chunk of memory, so we can bypass runtime\n            // checks to get our current layout.\n            unsafe {\n                let align = mem::align_of::<T>();\n                let size = mem::size_of::<T>() * self.cap;\n                Some(Layout::from_size_align_unchecked(size, align))\n            }\n        }\n    }\n\n    /// Doubles the size of the type's backing allocation. This is common enough\n    /// to want to do that it's easiest to just have a dedicated method. Slightly\n    /// more efficient logic can be provided for this than the general case.\n    ///\n    /// This function is ideal for when pushing elements one-at-a-time because\n    /// you don't need to incur the costs of the more general computations\n    /// reserve needs to do to guard against overflow. You do however need to\n    /// manually check if your `len == cap`.\n    ///\n    /// # Panics\n    ///\n    /// * Panics if T is zero-sized on the assumption that you managed to exhaust\n    ///   all `usize::MAX` slots in your imaginary buffer.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    ///\n    /// # Aborts\n    ///\n    /// Aborts on OOM\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(alloc, raw_vec_internals)]\n    /// # extern crate alloc;\n    /// # use std::ptr;\n    /// # use alloc::raw_vec::RawVec;\n    /// struct MyVec<T> {\n    ///     buf: RawVec<T>,\n    ///     len: usize,\n    /// }\n    ///\n    /// impl<T> MyVec<T> {\n    ///     pub fn push(&mut self, elem: T) {\n    ///         if self.len == self.buf.cap() { self.buf.double(); }\n    ///         // double would have aborted or panicked if the len exceeded\n    ///         // `isize::MAX` so this is safe to do unchecked now.\n    ///         unsafe {\n    ///             ptr::write(self.buf.ptr().add(self.len), elem);\n    ///         }\n    ///         self.len += 1;\n    ///     }\n    /// }\n    /// # fn main() {\n    /// #   let mut vec = MyVec { buf: RawVec::new(), len: 0 };\n    /// #   vec.push(1);\n    /// # }\n    /// ```\n    #[inline(never)]\n    #[cold]\n    pub fn double(&mut self) {\n        unsafe {\n            let elem_size = mem::size_of::<T>();\n\n            // since we set the capacity to usize::MAX when elem_size is\n            // 0, getting to here necessarily means the RawVec is overfull.\n            assert!(elem_size != 0, \"capacity overflow\");\n\n            let (new_cap, uniq) = match self.current_layout() {\n                Some(cur) => {\n                    // Since we guarantee that we never allocate more than\n                    // isize::MAX bytes, `elem_size * self.cap <= isize::MAX` as\n                    // a precondition, so this can't overflow. Additionally the\n                    // alignment will never be too large as to \"not be\n                    // satisfiable\", so `Layout::from_size_align` will always\n                    // return `Some`.\n                    //\n                    // tl;dr; we bypass runtime checks due to dynamic assertions\n                    // in this module, allowing us to use\n                    // `from_size_align_unchecked`.\n                    let new_cap = 2 * self.cap;\n                    let new_size = new_cap * elem_size;\n                    alloc_guard(new_size).unwrap_or_else(|_| capacity_overflow());\n                    let ptr_res = self.a.realloc(NonNull::from(self.ptr).cast(),\n                                                 cur,\n                                                 new_size);\n                    match ptr_res {\n                        Ok(ptr) => (new_cap, ptr.cast().into()),\n                        Err(_) => handle_alloc_error(\n                            Layout::from_size_align_unchecked(new_size, cur.align())\n                        ),\n                    }\n                }\n                None => {\n                    // skip to 4 because tiny Vec's are dumb; but not if that\n                    // would cause overflow\n                    let new_cap = if elem_size > (!0) / 8 { 1 } else { 4 };\n                    match self.a.alloc_array::<T>(new_cap) {\n                        Ok(ptr) => (new_cap, ptr.into()),\n                        Err(_) => handle_alloc_error(Layout::array::<T>(new_cap).unwrap()),\n                    }\n                }\n            };\n            self.ptr = uniq;\n            self.cap = new_cap;\n        }\n    }\n\n    /// Attempts to double the size of the type's backing allocation in place. This is common\n    /// enough to want to do that it's easiest to just have a dedicated method. Slightly\n    /// more efficient logic can be provided for this than the general case.\n    ///\n    /// Returns true if the reallocation attempt has succeeded, or false otherwise.\n    ///\n    /// # Panics\n    ///\n    /// * Panics if T is zero-sized on the assumption that you managed to exhaust\n    ///   all `usize::MAX` slots in your imaginary buffer.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    #[inline(never)]\n    #[cold]\n    pub fn double_in_place(&mut self) -> bool {\n        unsafe {\n            let elem_size = mem::size_of::<T>();\n            let old_layout = match self.current_layout() {\n                Some(layout) => layout,\n                None => return false, // nothing to double\n            };\n\n            // since we set the capacity to usize::MAX when elem_size is\n            // 0, getting to here necessarily means the RawVec is overfull.\n            assert!(elem_size != 0, \"capacity overflow\");\n\n            // Since we guarantee that we never allocate more than isize::MAX\n            // bytes, `elem_size * self.cap <= isize::MAX` as a precondition, so\n            // this can't overflow.\n            //\n            // Similarly like with `double` above we can go straight to\n            // `Layout::from_size_align_unchecked` as we know this won't\n            // overflow and the alignment is sufficiently small.\n            let new_cap = 2 * self.cap;\n            let new_size = new_cap * elem_size;\n            alloc_guard(new_size).unwrap_or_else(|_| capacity_overflow());\n            match self.a.grow_in_place(NonNull::from(self.ptr).cast(), old_layout, new_size) {\n                Ok(_) => {\n                    // We can't directly divide `size`.\n                    self.cap = new_cap;\n                    true\n                }\n                Err(_) => {\n                    false\n                }\n            }\n        }\n    }\n\n    /// The same as `reserve_exact`, but returns on errors instead of panicking or aborting.\n    pub fn try_reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize)\n           -> Result<(), CollectionAllocErr> {\n\n        self.reserve_internal(used_cap, needed_extra_cap, Fallible, Exact)\n    }\n\n    /// Ensures that the buffer contains at least enough space to hold\n    /// `used_cap + needed_extra_cap` elements. If it doesn't already,\n    /// will reallocate the minimum possible amount of memory necessary.\n    /// Generally this will be exactly the amount of memory necessary,\n    /// but in principle the allocator is free to give back more than\n    /// we asked for.\n    ///\n    /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate\n    /// the requested space. This is not really unsafe, but the unsafe\n    /// code *you* write that relies on the behavior of this function may break.\n    ///\n    /// # Panics\n    ///\n    /// * Panics if the requested capacity exceeds `usize::MAX` bytes.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    ///\n    /// # Aborts\n    ///\n    /// Aborts on OOM\n    pub fn reserve_exact(&mut self, used_cap: usize, needed_extra_cap: usize) {\n        match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Exact) {\n            Err(CapacityOverflow) => capacity_overflow(),\n            Err(AllocErr) => unreachable!(),\n            Ok(()) => { /* yay */ }\n         }\n     }\n\n    /// Calculates the buffer's new size given that it'll hold `used_cap +\n    /// needed_extra_cap` elements. This logic is used in amortized reserve methods.\n    /// Returns `(new_capacity, new_alloc_size)`.\n    fn amortized_new_size(&self, used_cap: usize, needed_extra_cap: usize)\n        -> Result<usize, CollectionAllocErr> {\n\n        // Nothing we can really do about these checks :(\n        let required_cap = used_cap.checked_add(needed_extra_cap).ok_or(CapacityOverflow)?;\n        // Cannot overflow, because `cap <= isize::MAX`, and type of `cap` is `usize`.\n        let double_cap = self.cap * 2;\n        // `double_cap` guarantees exponential growth.\n        Ok(cmp::max(double_cap, required_cap))\n    }\n\n    /// The same as `reserve`, but returns on errors instead of panicking or aborting.\n    pub fn try_reserve(&mut self, used_cap: usize, needed_extra_cap: usize)\n        -> Result<(), CollectionAllocErr> {\n        self.reserve_internal(used_cap, needed_extra_cap, Fallible, Amortized)\n    }\n\n    /// Ensures that the buffer contains at least enough space to hold\n    /// `used_cap + needed_extra_cap` elements. If it doesn't already have\n    /// enough capacity, will reallocate enough space plus comfortable slack\n    /// space to get amortized `O(1)` behavior. Will limit this behavior\n    /// if it would needlessly cause itself to panic.\n    ///\n    /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate\n    /// the requested space. This is not really unsafe, but the unsafe\n    /// code *you* write that relies on the behavior of this function may break.\n    ///\n    /// This is ideal for implementing a bulk-push operation like `extend`.\n    ///\n    /// # Panics\n    ///\n    /// * Panics if the requested capacity exceeds `usize::MAX` bytes.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    ///\n    /// # Aborts\n    ///\n    /// Aborts on OOM\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(alloc, raw_vec_internals)]\n    /// # extern crate alloc;\n    /// # use std::ptr;\n    /// # use alloc::raw_vec::RawVec;\n    /// struct MyVec<T> {\n    ///     buf: RawVec<T>,\n    ///     len: usize,\n    /// }\n    ///\n    /// impl<T: Clone> MyVec<T> {\n    ///     pub fn push_all(&mut self, elems: &[T]) {\n    ///         self.buf.reserve(self.len, elems.len());\n    ///         // reserve would have aborted or panicked if the len exceeded\n    ///         // `isize::MAX` so this is safe to do unchecked now.\n    ///         for x in elems {\n    ///             unsafe {\n    ///                 ptr::write(self.buf.ptr().add(self.len), x.clone());\n    ///             }\n    ///             self.len += 1;\n    ///         }\n    ///     }\n    /// }\n    /// # fn main() {\n    /// #   let mut vector = MyVec { buf: RawVec::new(), len: 0 };\n    /// #   vector.push_all(&[1, 3, 5, 7, 9]);\n    /// # }\n    /// ```\n    pub fn reserve(&mut self, used_cap: usize, needed_extra_cap: usize) {\n        match self.reserve_internal(used_cap, needed_extra_cap, Infallible, Amortized) {\n            Err(CapacityOverflow) => capacity_overflow(),\n            Err(AllocErr) => unreachable!(),\n            Ok(()) => { /* yay */ }\n        }\n    }\n    /// Attempts to ensure that the buffer contains at least enough space to hold\n    /// `used_cap + needed_extra_cap` elements. If it doesn't already have\n    /// enough capacity, will reallocate in place enough space plus comfortable slack\n    /// space to get amortized `O(1)` behavior. Will limit this behaviour\n    /// if it would needlessly cause itself to panic.\n    ///\n    /// If `used_cap` exceeds `self.cap()`, this may fail to actually allocate\n    /// the requested space. This is not really unsafe, but the unsafe\n    /// code *you* write that relies on the behavior of this function may break.\n    ///\n    /// Returns true if the reallocation attempt has succeeded, or false otherwise.\n    ///\n    /// # Panics\n    ///\n    /// * Panics if the requested capacity exceeds `usize::MAX` bytes.\n    /// * Panics on 32-bit platforms if the requested capacity exceeds\n    ///   `isize::MAX` bytes.\n    pub fn reserve_in_place(&mut self, used_cap: usize, needed_extra_cap: usize) -> bool {\n        unsafe {\n            // NOTE: we don't early branch on ZSTs here because we want this\n            // to actually catch \"asking for more than usize::MAX\" in that case.\n            // If we make it past the first branch then we are guaranteed to\n            // panic.\n\n            // Don't actually need any more capacity. If the current `cap` is 0, we can't\n            // reallocate in place.\n            // Wrapping in case they give a bad `used_cap`\n            let old_layout = match self.current_layout() {\n                Some(layout) => layout,\n                None => return false,\n            };\n            if self.cap().wrapping_sub(used_cap) >= needed_extra_cap {\n                return false;\n            }\n\n            let new_cap = self.amortized_new_size(used_cap, needed_extra_cap)\n                .unwrap_or_else(|_| capacity_overflow());\n\n            // Here, `cap < used_cap + needed_extra_cap <= new_cap`\n            // (regardless of whether `self.cap - used_cap` wrapped).\n            // Therefore we can safely call grow_in_place.\n\n            let new_layout = Layout::new::<T>().repeat(new_cap).unwrap().0;\n            // FIXME: may crash and burn on over-reserve\n            alloc_guard(new_layout.size()).unwrap_or_else(|_| capacity_overflow());\n            match self.a.grow_in_place(\n                NonNull::from(self.ptr).cast(), old_layout, new_layout.size(),\n            ) {\n                Ok(_) => {\n                    self.cap = new_cap;\n                    true\n                }\n                Err(_) => {\n                    false\n                }\n            }\n        }\n    }\n\n    /// Shrinks the allocation down to the specified amount. If the given amount\n    /// is 0, actually completely deallocates.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the given amount is *larger* than the current capacity.\n    ///\n    /// # Aborts\n    ///\n    /// Aborts on OOM.\n    pub fn shrink_to_fit(&mut self, amount: usize) {\n        let elem_size = mem::size_of::<T>();\n\n        // Set the `cap` because they might be about to promote to a `Box<[T]>`\n        if elem_size == 0 {\n            self.cap = amount;\n            return;\n        }\n\n        // This check is my waterloo; it's the only thing Vec wouldn't have to do.\n        assert!(self.cap >= amount, \"Tried to shrink to a larger capacity\");\n\n        if amount == 0 {\n            // We want to create a new zero-length vector within the\n            // same allocator.  We use ptr::write to avoid an\n            // erroneous attempt to drop the contents, and we use\n            // ptr::read to sidestep condition against destructuring\n            // types that implement Drop.\n\n            unsafe {\n                let a = ptr::read(&self.a as *const A);\n                self.dealloc_buffer();\n                ptr::write(self, RawVec::new_in(a));\n            }\n        } else if self.cap != amount {\n            unsafe {\n                // We know here that our `amount` is greater than zero. This\n                // implies, via the assert above, that capacity is also greater\n                // than zero, which means that we've got a current layout that\n                // \"fits\"\n                //\n                // We also know that `self.cap` is greater than `amount`, and\n                // consequently we don't need runtime checks for creating either\n                // layout\n                let old_size = elem_size * self.cap;\n                let new_size = elem_size * amount;\n                let align = mem::align_of::<T>();\n                let old_layout = Layout::from_size_align_unchecked(old_size, align);\n                match self.a.realloc(NonNull::from(self.ptr).cast(),\n                                     old_layout,\n                                     new_size) {\n                    Ok(p) => self.ptr = p.cast().into(),\n                    Err(_) => handle_alloc_error(\n                        Layout::from_size_align_unchecked(new_size, align)\n                    ),\n                }\n            }\n            self.cap = amount;\n        }\n    }\n}\n\nenum Fallibility {\n    Fallible,\n    Infallible,\n}\n\nuse self::Fallibility::*;\n\nenum ReserveStrategy {\n    Exact,\n    Amortized,\n}\n\nuse self::ReserveStrategy::*;\n\nimpl<T, A: Alloc> RawVec<T, A> {\n    fn reserve_internal(\n        &mut self,\n        used_cap: usize,\n        needed_extra_cap: usize,\n        fallibility: Fallibility,\n        strategy: ReserveStrategy,\n    ) -> Result<(), CollectionAllocErr> {\n        unsafe {\n            use alloc::AllocErr;\n\n            // NOTE: we don't early branch on ZSTs here because we want this\n            // to actually catch \"asking for more than usize::MAX\" in that case.\n            // If we make it past the first branch then we are guaranteed to\n            // panic.\n\n            // Don't actually need any more capacity.\n            // Wrapping in case they gave a bad `used_cap`.\n            if self.cap().wrapping_sub(used_cap) >= needed_extra_cap {\n                return Ok(());\n            }\n\n            // Nothing we can really do about these checks :(\n            let new_cap = match strategy {\n                Exact => used_cap.checked_add(needed_extra_cap).ok_or(CapacityOverflow)?,\n                Amortized => self.amortized_new_size(used_cap, needed_extra_cap)?,\n            };\n            let new_layout = Layout::array::<T>(new_cap).map_err(|_| CapacityOverflow)?;\n\n            alloc_guard(new_layout.size())?;\n\n            let res = match self.current_layout() {\n                Some(layout) => {\n                    debug_assert!(new_layout.align() == layout.align());\n                    self.a.realloc(NonNull::from(self.ptr).cast(), layout, new_layout.size())\n                }\n                None => self.a.alloc(new_layout),\n            };\n\n            match (&res, fallibility) {\n                (Err(AllocErr), Infallible) => handle_alloc_error(new_layout),\n                _ => {}\n            }\n\n            self.ptr = res?.cast().into();\n            self.cap = new_cap;\n\n            Ok(())\n        }\n    }\n\n}\n\nimpl<T> RawVec<T, Global> {\n    /// Converts the entire buffer into `Box<[T]>`.\n    ///\n    /// While it is not *strictly* Undefined Behavior to call\n    /// this procedure while some of the RawVec is uninitialized,\n    /// it certainly makes it trivial to trigger it.\n    ///\n    /// Note that this will correctly reconstitute any `cap` changes\n    /// that may have been performed. (see description of type for details)\n    pub unsafe fn into_box(self) -> Box<[T]> {\n        // NOTE: not calling `cap()` here, actually using the real `cap` field!\n        let slice = slice::from_raw_parts_mut(self.ptr(), self.cap);\n        let output: Box<[T]> = Box::from_raw(slice);\n        mem::forget(self);\n        output\n    }\n}\n\nimpl<T, A: Alloc> RawVec<T, A> {\n    /// Frees the memory owned by the RawVec *without* trying to Drop its contents.\n    pub unsafe fn dealloc_buffer(&mut self) {\n        let elem_size = mem::size_of::<T>();\n        if elem_size != 0 {\n            if let Some(layout) = self.current_layout() {\n                self.a.dealloc(NonNull::from(self.ptr).cast(), layout);\n            }\n        }\n    }\n}\n\nunsafe impl<#[may_dangle] T, A: Alloc> Drop for RawVec<T, A> {\n    /// Frees the memory owned by the RawVec *without* trying to Drop its contents.\n    fn drop(&mut self) {\n        unsafe { self.dealloc_buffer(); }\n    }\n}\n\n\n\n// We need to guarantee the following:\n// * We don't ever allocate `> isize::MAX` byte-size objects\n// * We don't overflow `usize::MAX` and actually allocate too little\n//\n// On 64-bit we just need to check for overflow since trying to allocate\n// `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add\n// an extra guard for this in case we're running on a platform which can use\n// all 4GB in user-space. e.g. PAE or x32\n\n#[inline]\nfn alloc_guard(alloc_size: usize) -> Result<(), CollectionAllocErr> {\n    if mem::size_of::<usize>() < 8 && alloc_size > ::core::isize::MAX as usize {\n        Err(CapacityOverflow)\n    } else {\n        Ok(())\n    }\n}\n\n// One central function responsible for reporting capacity overflows. This'll\n// ensure that the code generation related to these panics is minimal as there's\n// only one location which panics rather than a bunch throughout the module.\nfn capacity_overflow() -> ! {\n    panic!(\"capacity overflow\")\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    #[test]\n    fn allocator_param() {\n        use alloc::AllocErr;\n\n        // Writing a test of integration between third-party\n        // allocators and RawVec is a little tricky because the RawVec\n        // API does not expose fallible allocation methods, so we\n        // cannot check what happens when allocator is exhausted\n        // (beyond detecting a panic).\n        //\n        // Instead, this just checks that the RawVec methods do at\n        // least go through the Allocator API when it reserves\n        // storage.\n\n        // A dumb allocator that consumes a fixed amount of fuel\n        // before allocation attempts start failing.\n        struct BoundedAlloc { fuel: usize }\n        unsafe impl Alloc for BoundedAlloc {\n            unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n                let size = layout.size();\n                if size > self.fuel {\n                    return Err(AllocErr);\n                }\n                match Global.alloc(layout) {\n                    ok @ Ok(_) => { self.fuel -= size; ok }\n                    err @ Err(_) => err,\n                }\n            }\n            unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {\n                Global.dealloc(ptr, layout)\n            }\n        }\n\n        let a = BoundedAlloc { fuel: 500 };\n        let mut v: RawVec<u8, _> = RawVec::with_capacity_in(50, a);\n        assert_eq!(v.a.fuel, 450);\n        v.reserve(50, 150); // (causes a realloc, thus using 50 + 150 = 200 units of fuel)\n        assert_eq!(v.a.fuel, 250);\n    }\n\n    #[test]\n    fn reserve_does_not_overallocate() {\n        {\n            let mut v: RawVec<u32> = RawVec::new();\n            // First `reserve` allocates like `reserve_exact`\n            v.reserve(0, 9);\n            assert_eq!(9, v.cap());\n        }\n\n        {\n            let mut v: RawVec<u32> = RawVec::new();\n            v.reserve(0, 7);\n            assert_eq!(7, v.cap());\n            // 97 if more than double of 7, so `reserve` should work\n            // like `reserve_exact`.\n            v.reserve(7, 90);\n            assert_eq!(97, v.cap());\n        }\n\n        {\n            let mut v: RawVec<u32> = RawVec::new();\n            v.reserve(0, 12);\n            assert_eq!(12, v.cap());\n            v.reserve(12, 3);\n            // 3 is less than half of 12, so `reserve` must grow\n            // exponentially. At the time of writing this test grow\n            // factor is 2, so new capacity is 24, however, grow factor\n            // of 1.5 is OK too. Hence `>= 18` in assert.\n            assert!(v.cap() >= 12 + 12 / 2);\n        }\n    }\n\n\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Optional values.\n//!\n//! Type [`Option`] represents an optional value: every [`Option`]\n//! is either [`Some`] and contains a value, or [`None`], and\n//! does not. [`Option`] types are very common in Rust code, as\n//! they have a number of uses:\n//!\n//! * Initial values\n//! * Return values for functions that are not defined\n//!   over their entire input range (partial functions)\n//! * Return value for otherwise reporting simple errors, where `None` is\n//!   returned on error\n//! * Optional struct fields\n//! * Struct fields that can be loaned or \"taken\"\n//! * Optional function arguments\n//! * Nullable pointers\n//! * Swapping things out of difficult situations\n//!\n//! [`Option`]s are commonly paired with pattern matching to query the presence\n//! of a value and take action, always accounting for the [`None`] case.\n//!\n//! ```\n//! fn divide(numerator: f64, denominator: f64) -> Option<f64> {\n//!     if denominator == 0.0 {\n//!         None\n//!     } else {\n//!         Some(numerator / denominator)\n//!     }\n//! }\n//!\n//! // The return value of the function is an option\n//! let result = divide(2.0, 3.0);\n//!\n//! // Pattern match to retrieve the value\n//! match result {\n//!     // The division was valid\n//!     Some(x) => println!(\"Result: {}\", x),\n//!     // The division was invalid\n//!     None    => println!(\"Cannot divide by 0\"),\n//! }\n//! ```\n//!\n//\n// FIXME: Show how `Option` is used in practice, with lots of methods\n//\n//! # Options and pointers (\"nullable\" pointers)\n//!\n//! Rust's pointer types must always point to a valid location; there are\n//! no \"null\" pointers. Instead, Rust has *optional* pointers, like\n//! the optional owned box, [`Option`]`<`[`Box<T>`]`>`.\n//!\n//! The following example uses [`Option`] to create an optional box of\n//! [`i32`]. Notice that in order to use the inner [`i32`] value first, the\n//! `check_optional` function needs to use pattern matching to\n//! determine whether the box has a value (i.e. it is [`Some(...)`][`Some`]) or\n//! not ([`None`]).\n//!\n//! ```\n//! let optional = None;\n//! check_optional(optional);\n//!\n//! let optional = Some(Box::new(9000));\n//! check_optional(optional);\n//!\n//! fn check_optional(optional: Option<Box<i32>>) {\n//!     match optional {\n//!         Some(ref p) => println!(\"has value {}\", p),\n//!         None => println!(\"has no value\"),\n//!     }\n//! }\n//! ```\n//!\n//! This usage of [`Option`] to create safe nullable pointers is so\n//! common that Rust does special optimizations to make the\n//! representation of [`Option`]`<`[`Box<T>`]`>` a single pointer. Optional pointers\n//! in Rust are stored as efficiently as any other pointer type.\n//!\n//! # Examples\n//!\n//! Basic pattern matching on [`Option`]:\n//!\n//! ```\n//! let msg = Some(\"howdy\");\n//!\n//! // Take a reference to the contained string\n//! if let Some(ref m) = msg {\n//!     println!(\"{}\", *m);\n//! }\n//!\n//! // Remove the contained string, destroying the Option\n//! let unwrapped_msg = msg.unwrap_or(\"default message\");\n//! ```\n//!\n//! Initialize a result to [`None`] before a loop:\n//!\n//! ```\n//! enum Kingdom { Plant(u32, &'static str), Animal(u32, &'static str) }\n//!\n//! // A list of data to search through.\n//! let all_the_big_things = [\n//!     Kingdom::Plant(250, \"redwood\"),\n//!     Kingdom::Plant(230, \"noble fir\"),\n//!     Kingdom::Plant(229, \"sugar pine\"),\n//!     Kingdom::Animal(25, \"blue whale\"),\n//!     Kingdom::Animal(19, \"fin whale\"),\n//!     Kingdom::Animal(15, \"north pacific right whale\"),\n//! ];\n//!\n//! // We're going to search for the name of the biggest animal,\n//! // but to start with we've just got `None`.\n//! let mut name_of_biggest_animal = None;\n//! let mut size_of_biggest_animal = 0;\n//! for big_thing in &all_the_big_things {\n//!     match *big_thing {\n//!         Kingdom::Animal(size, name) if size > size_of_biggest_animal => {\n//!             // Now we've found the name of some big animal\n//!             size_of_biggest_animal = size;\n//!             name_of_biggest_animal = Some(name);\n//!         }\n//!         Kingdom::Animal(..) | Kingdom::Plant(..) => ()\n//!     }\n//! }\n//!\n//! match name_of_biggest_animal {\n//!     Some(name) => println!(\"the biggest animal is {}\", name),\n//!     None => println!(\"there are no animals :(\"),\n//! }\n//! ```\n//!\n//! [`Option`]: enum.Option.html\n//! [`Some`]: enum.Option.html#variant.Some\n//! [`None`]: enum.Option.html#variant.None\n//! [`Box<T>`]: ../../std/boxed/struct.Box.html\n//! [`i32`]: ../../std/primitive.i32.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse iter::{FromIterator, FusedIterator, TrustedLen};\nuse {hint, mem, ops::{self, Deref}};\nuse pin::Pin;\n\n// Note that this is not a lang item per se, but it has a hidden dependency on\n// `Iterator`, which is one. The compiler assumes that the `next` method of\n// `Iterator` is an enumeration with one type parameter and two variants,\n// which basically means it must be `Option`.\n\n/// The `Option` type. See [the module level documentation](index.html) for more.\n#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Option<T> {\n    /// No value\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    None,\n    /// Some value `T`\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Some(#[stable(feature = \"rust1\", since = \"1.0.0\")] T),\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Type implementation\n/////////////////////////////////////////////////////////////////////////////\n\nimpl<T> Option<T> {\n    /////////////////////////////////////////////////////////////////////////\n    // Querying the contained values\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns `true` if the option is a [`Some`] value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x: Option<u32> = Some(2);\n    /// assert_eq!(x.is_some(), true);\n    ///\n    /// let x: Option<u32> = None;\n    /// assert_eq!(x.is_some(), false);\n    /// ```\n    ///\n    /// [`Some`]: #variant.Some\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_some(&self) -> bool {\n        match *self {\n            Some(_) => true,\n            None => false,\n        }\n    }\n\n    /// Returns `true` if the option is a [`None`] value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x: Option<u32> = Some(2);\n    /// assert_eq!(x.is_none(), false);\n    ///\n    /// let x: Option<u32> = None;\n    /// assert_eq!(x.is_none(), true);\n    /// ```\n    ///\n    /// [`None`]: #variant.None\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_none(&self) -> bool {\n        !self.is_some()\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Adapter for working with references\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Converts from `Option<T>` to `Option<&T>`.\n    ///\n    /// # Examples\n    ///\n    /// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, preserving the original.\n    /// The [`map`] method takes the `self` argument by value, consuming the original,\n    /// so this technique uses `as_ref` to first take an `Option` to a reference\n    /// to the value inside the original.\n    ///\n    /// [`map`]: enum.Option.html#method.map\n    /// [`String`]: ../../std/string/struct.String.html\n    /// [`usize`]: ../../std/primitive.usize.html\n    ///\n    /// ```\n    /// let text: Option<String> = Some(\"Hello, world!\".to_string());\n    /// // First, cast `Option<String>` to `Option<&String>` with `as_ref`,\n    /// // then consume *that* with `map`, leaving `text` on the stack.\n    /// let text_length: Option<usize> = text.as_ref().map(|s| s.len());\n    /// println!(\"still can print text: {:?}\", text);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_ref(&self) -> Option<&T> {\n        match *self {\n            Some(ref x) => Some(x),\n            None => None,\n        }\n    }\n\n    /// Converts from `Option<T>` to `Option<&mut T>`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = Some(2);\n    /// match x.as_mut() {\n    ///     Some(v) => *v = 42,\n    ///     None => {},\n    /// }\n    /// assert_eq!(x, Some(42));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_mut(&mut self) -> Option<&mut T> {\n        match *self {\n            Some(ref mut x) => Some(x),\n            None => None,\n        }\n    }\n\n\n    /// Converts from `Pin<&Option<T>>` to `Option<Pin<&T>>`\n    #[inline]\n    #[unstable(feature = \"pin\", issue = \"49150\")]\n    pub fn as_pin_ref<'a>(self: Pin<&'a Option<T>>) -> Option<Pin<&'a T>> {\n        unsafe {\n            Pin::get_ref(self).as_ref().map(|x| Pin::new_unchecked(x))\n        }\n    }\n\n    /// Converts from `Pin<&mut Option<T>>` to `Option<Pin<&mut T>>`\n    #[inline]\n    #[unstable(feature = \"pin\", issue = \"49150\")]\n    pub fn as_pin_mut<'a>(self: Pin<&'a mut Option<T>>) -> Option<Pin<&'a mut T>> {\n        unsafe {\n            Pin::get_mut_unchecked(self).as_mut().map(|x| Pin::new_unchecked(x))\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Getting to contained values\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Unwraps an option, yielding the content of a [`Some`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is a [`None`] with a custom panic message provided by\n    /// `msg`.\n    ///\n    /// [`Some`]: #variant.Some\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"value\");\n    /// assert_eq!(x.expect(\"the world is ending\"), \"value\");\n    /// ```\n    ///\n    /// ```{.should_panic}\n    /// let x: Option<&str> = None;\n    /// x.expect(\"the world is ending\"); // panics with `the world is ending`\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn expect(self, msg: &str) -> T {\n        match self {\n            Some(val) => val,\n            None => expect_failed(msg),\n        }\n    }\n\n    /// Moves the value `v` out of the `Option<T>` if it is [`Some(v)`].\n    ///\n    /// In general, because this function may panic, its use is discouraged.\n    /// Instead, prefer to use pattern matching and handle the [`None`]\n    /// case explicitly.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the self value equals [`None`].\n    ///\n    /// [`Some(v)`]: #variant.Some\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"air\");\n    /// assert_eq!(x.unwrap(), \"air\");\n    /// ```\n    ///\n    /// ```{.should_panic}\n    /// let x: Option<&str> = None;\n    /// assert_eq!(x.unwrap(), \"air\"); // fails\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap(self) -> T {\n        match self {\n            Some(val) => val,\n            None => panic!(\"called `Option::unwrap()` on a `None` value\"),\n        }\n    }\n\n    /// Returns the contained value or a default.\n    ///\n    /// Arguments passed to `unwrap_or` are eagerly evaluated; if you are passing\n    /// the result of a function call, it is recommended to use [`unwrap_or_else`],\n    /// which is lazily evaluated.\n    ///\n    /// [`unwrap_or_else`]: #method.unwrap_or_else\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!(Some(\"car\").unwrap_or(\"bike\"), \"car\");\n    /// assert_eq!(None.unwrap_or(\"bike\"), \"bike\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_or(self, def: T) -> T {\n        match self {\n            Some(x) => x,\n            None => def,\n        }\n    }\n\n    /// Returns the contained value or computes it from a closure.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let k = 10;\n    /// assert_eq!(Some(4).unwrap_or_else(|| 2 * k), 4);\n    /// assert_eq!(None.unwrap_or_else(|| 2 * k), 20);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T {\n        match self {\n            Some(x) => x,\n            None => f(),\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Transforming contained values\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Maps an `Option<T>` to `Option<U>` by applying a function to a contained value.\n    ///\n    /// # Examples\n    ///\n    /// Convert an `Option<`[`String`]`>` into an `Option<`[`usize`]`>`, consuming the original:\n    ///\n    /// [`String`]: ../../std/string/struct.String.html\n    /// [`usize`]: ../../std/primitive.usize.html\n    ///\n    /// ```\n    /// let maybe_some_string = Some(String::from(\"Hello, World!\"));\n    /// // `Option::map` takes self *by value*, consuming `maybe_some_string`\n    /// let maybe_some_len = maybe_some_string.map(|s| s.len());\n    ///\n    /// assert_eq!(maybe_some_len, Some(13));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Option<U> {\n        match self {\n            Some(x) => Some(f(x)),\n            None => None,\n        }\n    }\n\n    /// Applies a function to the contained value (if any),\n    /// or returns the provided default (if not).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"foo\");\n    /// assert_eq!(x.map_or(42, |v| v.len()), 3);\n    ///\n    /// let x: Option<&str> = None;\n    /// assert_eq!(x.map_or(42, |v| v.len()), 42);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn map_or<U, F: FnOnce(T) -> U>(self, default: U, f: F) -> U {\n        match self {\n            Some(t) => f(t),\n            None => default,\n        }\n    }\n\n    /// Applies a function to the contained value (if any),\n    /// or computes a default (if not).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let k = 21;\n    ///\n    /// let x = Some(\"foo\");\n    /// assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 3);\n    ///\n    /// let x: Option<&str> = None;\n    /// assert_eq!(x.map_or_else(|| 2 * k, |v| v.len()), 42);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn map_or_else<U, D: FnOnce() -> U, F: FnOnce(T) -> U>(self, default: D, f: F) -> U {\n        match self {\n            Some(t) => f(t),\n            None => default(),\n        }\n    }\n\n    /// Transforms the `Option<T>` into a [`Result<T, E>`], mapping [`Some(v)`] to\n    /// [`Ok(v)`] and [`None`] to [`Err(err)`].\n    ///\n    /// Arguments passed to `ok_or` are eagerly evaluated; if you are passing the\n    /// result of a function call, it is recommended to use [`ok_or_else`], which is\n    /// lazily evaluated.\n    ///\n    /// [`Result<T, E>`]: ../../std/result/enum.Result.html\n    /// [`Ok(v)`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Err(err)`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`None`]: #variant.None\n    /// [`Some(v)`]: #variant.Some\n    /// [`ok_or_else`]: #method.ok_or_else\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"foo\");\n    /// assert_eq!(x.ok_or(0), Ok(\"foo\"));\n    ///\n    /// let x: Option<&str> = None;\n    /// assert_eq!(x.ok_or(0), Err(0));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ok_or<E>(self, err: E) -> Result<T, E> {\n        match self {\n            Some(v) => Ok(v),\n            None => Err(err),\n        }\n    }\n\n    /// Transforms the `Option<T>` into a [`Result<T, E>`], mapping [`Some(v)`] to\n    /// [`Ok(v)`] and [`None`] to [`Err(err())`].\n    ///\n    /// [`Result<T, E>`]: ../../std/result/enum.Result.html\n    /// [`Ok(v)`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Err(err())`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`None`]: #variant.None\n    /// [`Some(v)`]: #variant.Some\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"foo\");\n    /// assert_eq!(x.ok_or_else(|| 0), Ok(\"foo\"));\n    ///\n    /// let x: Option<&str> = None;\n    /// assert_eq!(x.ok_or_else(|| 0), Err(0));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ok_or_else<E, F: FnOnce() -> E>(self, err: F) -> Result<T, E> {\n        match self {\n            Some(v) => Ok(v),\n            None => Err(err()),\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Iterator constructors\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns an iterator over the possibly contained value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(4);\n    /// assert_eq!(x.iter().next(), Some(&4));\n    ///\n    /// let x: Option<u32> = None;\n    /// assert_eq!(x.iter().next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter(&self) -> Iter<T> {\n        Iter { inner: Item { opt: self.as_ref() } }\n    }\n\n    /// Returns a mutable iterator over the possibly contained value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = Some(4);\n    /// match x.iter_mut().next() {\n    ///     Some(v) => *v = 42,\n    ///     None => {},\n    /// }\n    /// assert_eq!(x, Some(42));\n    ///\n    /// let mut x: Option<u32> = None;\n    /// assert_eq!(x.iter_mut().next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter_mut(&mut self) -> IterMut<T> {\n        IterMut { inner: Item { opt: self.as_mut() } }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Boolean operations on the values, eager and lazy\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Returns [`None`] if the option is [`None`], otherwise returns `optb`.\n    ///\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(2);\n    /// let y: Option<&str> = None;\n    /// assert_eq!(x.and(y), None);\n    ///\n    /// let x: Option<u32> = None;\n    /// let y = Some(\"foo\");\n    /// assert_eq!(x.and(y), None);\n    ///\n    /// let x = Some(2);\n    /// let y = Some(\"foo\");\n    /// assert_eq!(x.and(y), Some(\"foo\"));\n    ///\n    /// let x: Option<u32> = None;\n    /// let y: Option<&str> = None;\n    /// assert_eq!(x.and(y), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn and<U>(self, optb: Option<U>) -> Option<U> {\n        match self {\n            Some(_) => optb,\n            None => None,\n        }\n    }\n\n    /// Returns [`None`] if the option is [`None`], otherwise calls `f` with the\n    /// wrapped value and returns the result.\n    ///\n    /// Some languages call this operation flatmap.\n    ///\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// fn sq(x: u32) -> Option<u32> { Some(x * x) }\n    /// fn nope(_: u32) -> Option<u32> { None }\n    ///\n    /// assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));\n    /// assert_eq!(Some(2).and_then(sq).and_then(nope), None);\n    /// assert_eq!(Some(2).and_then(nope).and_then(sq), None);\n    /// assert_eq!(None.and_then(sq).and_then(sq), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn and_then<U, F: FnOnce(T) -> Option<U>>(self, f: F) -> Option<U> {\n        match self {\n            Some(x) => f(x),\n            None => None,\n        }\n    }\n\n    /// Returns `None` if the option is `None`, otherwise calls `predicate`\n    /// with the wrapped value and returns:\n    ///\n    /// - `Some(t)` if `predicate` returns `true` (where `t` is the wrapped\n    ///   value), and\n    /// - `None` if `predicate` returns `false`.\n    ///\n    /// This function works similar to `Iterator::filter()`. You can imagine\n    /// the `Option<T>` being an iterator over one or zero elements. `filter()`\n    /// lets you decide which elements to keep.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// fn is_even(n: &i32) -> bool {\n    ///     n % 2 == 0\n    /// }\n    ///\n    /// assert_eq!(None.filter(is_even), None);\n    /// assert_eq!(Some(3).filter(is_even), None);\n    /// assert_eq!(Some(4).filter(is_even), Some(4));\n    /// ```\n    #[inline]\n    #[stable(feature = \"option_filter\", since = \"1.27.0\")]\n    pub fn filter<P: FnOnce(&T) -> bool>(self, predicate: P) -> Self {\n        if let Some(x) = self {\n            if predicate(&x) {\n                return Some(x)\n            }\n        }\n        None\n    }\n\n    /// Returns the option if it contains a value, otherwise returns `optb`.\n    ///\n    /// Arguments passed to `or` are eagerly evaluated; if you are passing the\n    /// result of a function call, it is recommended to use [`or_else`], which is\n    /// lazily evaluated.\n    ///\n    /// [`or_else`]: #method.or_else\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(2);\n    /// let y = None;\n    /// assert_eq!(x.or(y), Some(2));\n    ///\n    /// let x = None;\n    /// let y = Some(100);\n    /// assert_eq!(x.or(y), Some(100));\n    ///\n    /// let x = Some(2);\n    /// let y = Some(100);\n    /// assert_eq!(x.or(y), Some(2));\n    ///\n    /// let x: Option<u32> = None;\n    /// let y = None;\n    /// assert_eq!(x.or(y), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or(self, optb: Option<T>) -> Option<T> {\n        match self {\n            Some(_) => self,\n            None => optb,\n        }\n    }\n\n    /// Returns the option if it contains a value, otherwise calls `f` and\n    /// returns the result.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// fn nobody() -> Option<&'static str> { None }\n    /// fn vikings() -> Option<&'static str> { Some(\"vikings\") }\n    ///\n    /// assert_eq!(Some(\"barbarians\").or_else(vikings), Some(\"barbarians\"));\n    /// assert_eq!(None.or_else(vikings), Some(\"vikings\"));\n    /// assert_eq!(None.or_else(nobody), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Option<T> {\n        match self {\n            Some(_) => self,\n            None => f(),\n        }\n    }\n\n    /// Returns [`Some`] if exactly one of `self`, `optb` is [`Some`], otherwise returns `None`.\n    ///\n    /// [`Some`]: #variant.Some\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(option_xor)]\n    ///\n    /// let x = Some(2);\n    /// let y: Option<u32> = None;\n    /// assert_eq!(x.xor(y), Some(2));\n    ///\n    /// let x: Option<u32> = None;\n    /// let y = Some(2);\n    /// assert_eq!(x.xor(y), Some(2));\n    ///\n    /// let x = Some(2);\n    /// let y = Some(2);\n    /// assert_eq!(x.xor(y), None);\n    ///\n    /// let x: Option<u32> = None;\n    /// let y: Option<u32> = None;\n    /// assert_eq!(x.xor(y), None);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"option_xor\", issue = \"50512\")]\n    pub fn xor(self, optb: Option<T>) -> Option<T> {\n        match (self, optb) {\n            (Some(a), None) => Some(a),\n            (None, Some(b)) => Some(b),\n            _ => None,\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Entry-like operations to insert if None and return a reference\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Inserts `v` into the option if it is [`None`], then\n    /// returns a mutable reference to the contained value.\n    ///\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = None;\n    ///\n    /// {\n    ///     let y: &mut u32 = x.get_or_insert(5);\n    ///     assert_eq!(y, &5);\n    ///\n    ///     *y = 7;\n    /// }\n    ///\n    /// assert_eq!(x, Some(7));\n    /// ```\n    #[inline]\n    #[stable(feature = \"option_entry\", since = \"1.20.0\")]\n    pub fn get_or_insert(&mut self, v: T) -> &mut T {\n        match *self {\n            None => *self = Some(v),\n            _ => (),\n        }\n\n        match *self {\n            Some(ref mut v) => v,\n            None => unsafe { hint::unreachable_unchecked() },\n        }\n    }\n\n    /// Inserts a value computed from `f` into the option if it is [`None`], then\n    /// returns a mutable reference to the contained value.\n    ///\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = None;\n    ///\n    /// {\n    ///     let y: &mut u32 = x.get_or_insert_with(|| 5);\n    ///     assert_eq!(y, &5);\n    ///\n    ///     *y = 7;\n    /// }\n    ///\n    /// assert_eq!(x, Some(7));\n    /// ```\n    #[inline]\n    #[stable(feature = \"option_entry\", since = \"1.20.0\")]\n    pub fn get_or_insert_with<F: FnOnce() -> T>(&mut self, f: F) -> &mut T {\n        match *self {\n            None => *self = Some(f()),\n            _ => (),\n        }\n\n        match *self {\n            Some(ref mut v) => v,\n            None => unsafe { hint::unreachable_unchecked() },\n        }\n    }\n\n    /////////////////////////////////////////////////////////////////////////\n    // Misc\n    /////////////////////////////////////////////////////////////////////////\n\n    /// Takes the value out of the option, leaving a [`None`] in its place.\n    ///\n    /// [`None`]: #variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = Some(2);\n    /// let y = x.take();\n    /// assert_eq!(x, None);\n    /// assert_eq!(y, Some(2));\n    ///\n    /// let mut x: Option<u32> = None;\n    /// let y = x.take();\n    /// assert_eq!(x, None);\n    /// assert_eq!(y, None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn take(&mut self) -> Option<T> {\n        mem::replace(self, None)\n    }\n\n    /// Replaces the actual value in the option by the value given in parameter,\n    /// returning the old value if present,\n    /// leaving a [`Some`] in its place without deinitializing either one.\n    ///\n    /// [`Some`]: #variant.Some\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = Some(2);\n    /// let old = x.replace(5);\n    /// assert_eq!(x, Some(5));\n    /// assert_eq!(old, Some(2));\n    ///\n    /// let mut x = None;\n    /// let old = x.replace(3);\n    /// assert_eq!(x, Some(3));\n    /// assert_eq!(old, None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"option_replace\", since = \"1.31.0\")]\n    pub fn replace(&mut self, value: T) -> Option<T> {\n        mem::replace(self, Some(value))\n    }\n}\n\nimpl<'a, T: Clone> Option<&'a T> {\n    /// Maps an `Option<&T>` to an `Option<T>` by cloning the contents of the\n    /// option.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = 12;\n    /// let opt_x = Some(&x);\n    /// assert_eq!(opt_x, Some(&12));\n    /// let cloned = opt_x.cloned();\n    /// assert_eq!(cloned, Some(12));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn cloned(self) -> Option<T> {\n        self.map(|t| t.clone())\n    }\n}\n\nimpl<'a, T: Clone> Option<&'a mut T> {\n    /// Maps an `Option<&mut T>` to an `Option<T>` by cloning the contents of the\n    /// option.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut x = 12;\n    /// let opt_x = Some(&mut x);\n    /// assert_eq!(opt_x, Some(&mut 12));\n    /// let cloned = opt_x.cloned();\n    /// assert_eq!(cloned, Some(12));\n    /// ```\n    #[stable(since = \"1.26.0\", feature = \"option_ref_mut_cloned\")]\n    pub fn cloned(self) -> Option<T> {\n        self.map(|t| t.clone())\n    }\n}\n\nimpl<T: Default> Option<T> {\n    /// Returns the contained value or a default\n    ///\n    /// Consumes the `self` argument then, if [`Some`], returns the contained\n    /// value, otherwise if [`None`], returns the [default value] for that\n    /// type.\n    ///\n    /// # Examples\n    ///\n    /// Convert a string to an integer, turning poorly-formed strings\n    /// into 0 (the default value for integers). [`parse`] converts\n    /// a string to any other type that implements [`FromStr`], returning\n    /// [`None`] on error.\n    ///\n    /// ```\n    /// let good_year_from_input = \"1909\";\n    /// let bad_year_from_input = \"190blarg\";\n    /// let good_year = good_year_from_input.parse().ok().unwrap_or_default();\n    /// let bad_year = bad_year_from_input.parse().ok().unwrap_or_default();\n    ///\n    /// assert_eq!(1909, good_year);\n    /// assert_eq!(0, bad_year);\n    /// ```\n    ///\n    /// [`Some`]: #variant.Some\n    /// [`None`]: #variant.None\n    /// [default value]: ../default/trait.Default.html#tymethod.default\n    /// [`parse`]: ../../std/primitive.str.html#method.parse\n    /// [`FromStr`]: ../../std/str/trait.FromStr.html\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unwrap_or_default(self) -> T {\n        match self {\n            Some(x) => x,\n            None => Default::default(),\n        }\n    }\n}\n\n#[unstable(feature = \"inner_deref\", reason = \"newly added\", issue = \"50264\")]\nimpl<T: Deref> Option<T> {\n    /// Converts from `&Option<T>` to `Option<&T::Target>`.\n    ///\n    /// Leaves the original Option in-place, creating a new one with a reference\n    /// to the original one, additionally coercing the contents via `Deref`.\n    pub fn deref(&self) -> Option<&T::Target> {\n        self.as_ref().map(|t| t.deref())\n    }\n}\n\nimpl<T, E> Option<Result<T, E>> {\n    /// Transposes an `Option` of a `Result` into a `Result` of an `Option`.\n    ///\n    /// `None` will be mapped to `Ok(None)`.\n    /// `Some(Ok(_))` and `Some(Err(_))` will be mapped to `Ok(Some(_))` and `Err(_)`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(transpose_result)]\n    ///\n    /// #[derive(Debug, Eq, PartialEq)]\n    /// struct SomeErr;\n    ///\n    /// let x: Result<Option<i32>, SomeErr> = Ok(Some(5));\n    /// let y: Option<Result<i32, SomeErr>> = Some(Ok(5));\n    /// assert_eq!(x, y.transpose());\n    /// ```\n    #[inline]\n    #[unstable(feature = \"transpose_result\", issue = \"47338\")]\n    pub fn transpose(self) -> Result<Option<T>, E> {\n        match self {\n            Some(Ok(x)) => Ok(Some(x)),\n            Some(Err(e)) => Err(e),\n            None => Ok(None),\n        }\n    }\n}\n\n// This is a separate function to reduce the code size of .expect() itself.\n#[inline(never)]\n#[cold]\nfn expect_failed(msg: &str) -> ! {\n    panic!(\"{}\", msg)\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Trait implementations\n/////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Default for Option<T> {\n    /// Returns [`None`][Option::None].\n    #[inline]\n    fn default() -> Option<T> { None }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> IntoIterator for Option<T> {\n    type Item = T;\n    type IntoIter = IntoIter<T>;\n\n    /// Returns a consuming iterator over the possibly contained value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Some(\"string\");\n    /// let v: Vec<&str> = x.into_iter().collect();\n    /// assert_eq!(v, [\"string\"]);\n    ///\n    /// let x = None;\n    /// let v: Vec<&str> = x.into_iter().collect();\n    /// assert!(v.is_empty());\n    /// ```\n    #[inline]\n    fn into_iter(self) -> IntoIter<T> {\n        IntoIter { inner: Item { opt: self } }\n    }\n}\n\n#[stable(since = \"1.4.0\", feature = \"option_iter\")]\nimpl<'a, T> IntoIterator for &'a Option<T> {\n    type Item = &'a T;\n    type IntoIter = Iter<'a, T>;\n\n    fn into_iter(self) -> Iter<'a, T> {\n        self.iter()\n    }\n}\n\n#[stable(since = \"1.4.0\", feature = \"option_iter\")]\nimpl<'a, T> IntoIterator for &'a mut Option<T> {\n    type Item = &'a mut T;\n    type IntoIter = IterMut<'a, T>;\n\n    fn into_iter(self) -> IterMut<'a, T> {\n        self.iter_mut()\n    }\n}\n\n#[stable(since = \"1.12.0\", feature = \"option_from\")]\nimpl<T> From<T> for Option<T> {\n    fn from(val: T) -> Option<T> {\n        Some(val)\n    }\n}\n\n#[stable(feature = \"option_ref_from_ref_option\", since = \"1.30.0\")]\nimpl<'a, T> From<&'a Option<T>> for Option<&'a T> {\n    fn from(o: &'a Option<T>) -> Option<&'a T> {\n        o.as_ref()\n    }\n}\n\n#[stable(feature = \"option_ref_from_ref_option\", since = \"1.30.0\")]\nimpl<'a, T> From<&'a mut Option<T>> for Option<&'a mut T> {\n    fn from(o: &'a mut Option<T>) -> Option<&'a mut T> {\n        o.as_mut()\n    }\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// The Option Iterators\n/////////////////////////////////////////////////////////////////////////////\n\n#[derive(Clone, Debug)]\nstruct Item<A> {\n    opt: Option<A>\n}\n\nimpl<A> Iterator for Item<A> {\n    type Item = A;\n\n    #[inline]\n    fn next(&mut self) -> Option<A> {\n        self.opt.take()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        match self.opt {\n            Some(_) => (1, Some(1)),\n            None => (0, Some(0)),\n        }\n    }\n}\n\nimpl<A> DoubleEndedIterator for Item<A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<A> {\n        self.opt.take()\n    }\n}\n\nimpl<A> ExactSizeIterator for Item<A> {}\nimpl<A> FusedIterator for Item<A> {}\nunsafe impl<A> TrustedLen for Item<A> {}\n\n/// An iterator over a reference to the [`Some`] variant of an [`Option`].\n///\n/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.\n///\n/// This `struct` is created by the [`Option::iter`] function.\n///\n/// [`Option`]: enum.Option.html\n/// [`Some`]: enum.Option.html#variant.Some\n/// [`Option::iter`]: enum.Option.html#method.iter\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Iter<'a, A: 'a> { inner: Item<&'a A> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, A> Iterator for Iter<'a, A> {\n    type Item = &'a A;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a A> { self.inner.next() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, A> DoubleEndedIterator for Iter<'a, A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a A> { self.inner.next_back() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> ExactSizeIterator for Iter<'_, A> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A> FusedIterator for Iter<'_, A> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for Iter<'_, A> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> Clone for Iter<'_, A> {\n    #[inline]\n    fn clone(&self) -> Self {\n        Iter { inner: self.inner.clone() }\n    }\n}\n\n/// An iterator over a mutable reference to the [`Some`] variant of an [`Option`].\n///\n/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.\n///\n/// This `struct` is created by the [`Option::iter_mut`] function.\n///\n/// [`Option`]: enum.Option.html\n/// [`Some`]: enum.Option.html#variant.Some\n/// [`Option::iter_mut`]: enum.Option.html#method.iter_mut\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct IterMut<'a, A: 'a> { inner: Item<&'a mut A> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, A> Iterator for IterMut<'a, A> {\n    type Item = &'a mut A;\n\n    #[inline]\n    fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, A> DoubleEndedIterator for IterMut<'a, A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<&'a mut A> { self.inner.next_back() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> ExactSizeIterator for IterMut<'_, A> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A> FusedIterator for IterMut<'_, A> {}\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for IterMut<'_, A> {}\n\n/// An iterator over the value in [`Some`] variant of an [`Option`].\n///\n/// The iterator yields one value if the [`Option`] is a [`Some`], otherwise none.\n///\n/// This `struct` is created by the [`Option::into_iter`] function.\n///\n/// [`Option`]: enum.Option.html\n/// [`Some`]: enum.Option.html#variant.Some\n/// [`Option::into_iter`]: enum.Option.html#method.into_iter\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoIter<A> { inner: Item<A> }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> Iterator for IntoIter<A> {\n    type Item = A;\n\n    #[inline]\n    fn next(&mut self) -> Option<A> { self.inner.next() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> DoubleEndedIterator for IntoIter<A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<A> { self.inner.next_back() }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A> ExactSizeIterator for IntoIter<A> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A> FusedIterator for IntoIter<A> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A> TrustedLen for IntoIter<A> {}\n\n/////////////////////////////////////////////////////////////////////////////\n// FromIterator\n/////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {\n    /// Takes each element in the [`Iterator`]: if it is [`None`][Option::None],\n    /// no further elements are taken, and the [`None`][Option::None] is\n    /// returned. Should no [`None`][Option::None] occur, a container with the\n    /// values of each [`Option`] is returned.\n    ///\n    /// Here is an example which increments every integer in a vector,\n    /// checking for overflow:\n    ///\n    /// ```\n    /// use std::u16;\n    ///\n    /// let v = vec![1, 2];\n    /// let res: Option<Vec<u16>> = v.iter().map(|&x: &u16|\n    ///     if x == u16::MAX { None }\n    ///     else { Some(x + 1) }\n    /// ).collect();\n    /// assert!(res == Some(vec![2, 3]));\n    /// ```\n    ///\n    /// [`Iterator`]: ../iter/trait.Iterator.html\n    #[inline]\n    fn from_iter<I: IntoIterator<Item=Option<A>>>(iter: I) -> Option<V> {\n        // FIXME(#11084): This could be replaced with Iterator::scan when this\n        // performance bug is closed.\n\n        struct Adapter<Iter> {\n            iter: Iter,\n            found_none: bool,\n        }\n\n        impl<T, Iter: Iterator<Item=Option<T>>> Iterator for Adapter<Iter> {\n            type Item = T;\n\n            #[inline]\n            fn next(&mut self) -> Option<T> {\n                match self.iter.next() {\n                    Some(Some(value)) => Some(value),\n                    Some(None) => {\n                        self.found_none = true;\n                        None\n                    }\n                    None => None,\n                }\n            }\n\n            #[inline]\n            fn size_hint(&self) -> (usize, Option<usize>) {\n                if self.found_none {\n                    (0, Some(0))\n                } else {\n                    let (_, upper) = self.iter.size_hint();\n                    (0, upper)\n                }\n            }\n        }\n\n        let mut adapter = Adapter { iter: iter.into_iter(), found_none: false };\n        let v: V = FromIterator::from_iter(adapter.by_ref());\n\n        if adapter.found_none {\n            None\n        } else {\n            Some(v)\n        }\n    }\n}\n\n/// The error type that results from applying the try operator (`?`) to a `None` value. If you wish\n/// to allow `x?` (where `x` is an `Option<T>`) to be converted into your error type, you can\n/// implement `impl From<NoneError>` for `YourErrorType`. In that case, `x?` within a function that\n/// returns `Result<_, YourErrorType>` will translate a `None` value into an `Err` result.\n#[unstable(feature = \"try_trait\", issue = \"42327\")]\n#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Debug, Hash)]\npub struct NoneError;\n\n#[unstable(feature = \"try_trait\", issue = \"42327\")]\nimpl<T> ops::Try for Option<T> {\n    type Ok = T;\n    type Error = NoneError;\n\n    #[inline]\n    fn into_result(self) -> Result<T, NoneError> {\n        self.ok_or(NoneError)\n    }\n\n    #[inline]\n    fn from_ok(v: T) -> Self {\n        Some(v)\n    }\n\n    #[inline]\n    fn from_error(_: NoneError) -> Self {\n        None\n    }\n}\n","// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Utilities for formatting and printing strings.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse cell::{UnsafeCell, Cell, RefCell, Ref, RefMut};\nuse marker::PhantomData;\nuse mem;\nuse num::flt2dec;\nuse ops::Deref;\nuse result;\nuse slice;\nuse str;\n\nmod float;\nmod num;\nmod builders;\n\n#[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\n/// Possible alignments returned by `Formatter::align`\n#[derive(Debug)]\npub enum Alignment {\n    #[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\n    /// Indication that contents should be left-aligned.\n    Left,\n    #[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\n    /// Indication that contents should be right-aligned.\n    Right,\n    #[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\n    /// Indication that contents should be center-aligned.\n    Center,\n}\n\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub use self::builders::{DebugStruct, DebugTuple, DebugSet, DebugList, DebugMap};\n\n#[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n           issue = \"0\")]\n#[doc(hidden)]\npub mod rt {\n    pub mod v1;\n}\n\n/// The type returned by formatter methods.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// #[derive(Debug)]\n/// struct Triangle {\n///     a: f32,\n///     b: f32,\n///     c: f32\n/// }\n///\n/// impl fmt::Display for Triangle {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         write!(f, \"({}, {}, {})\", self.a, self.b, self.c)\n///     }\n/// }\n///\n/// let pythagorean_triple = Triangle { a: 3.0, b: 4.0, c: 5.0 };\n///\n/// println!(\"{}\", pythagorean_triple);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub type Result = result::Result<(), Error>;\n\n/// The error type which is returned from formatting a message into a stream.\n///\n/// This type does not support transmission of an error other than that an error\n/// occurred. Any extra information must be arranged to be transmitted through\n/// some other means.\n///\n/// An important thing to remember is that the type `fmt::Error` should not be\n/// confused with [`std::io::Error`] or [`std::error::Error`], which you may also\n/// have in scope.\n///\n/// [`std::io::Error`]: ../../std/io/struct.Error.html\n/// [`std::error::Error`]: ../../std/error/trait.Error.html\n///\n/// # Examples\n///\n/// ```rust\n/// use std::fmt::{self, write};\n///\n/// let mut output = String::new();\n/// if let Err(fmt::Error) = write(&mut output, format_args!(\"Hello {}!\", \"world\")) {\n///     panic!(\"An error occurred\");\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]\npub struct Error;\n\n/// A collection of methods that are required to format a message into a stream.\n///\n/// This trait is the type which this modules requires when formatting\n/// information. This is similar to the standard library's [`io::Write`] trait,\n/// but it is only intended for use in libcore.\n///\n/// This trait should generally not be implemented by consumers of the standard\n/// library. The [`write!`] macro accepts an instance of [`io::Write`], and the\n/// [`io::Write`] trait is favored over implementing this trait.\n///\n/// [`write!`]: ../../std/macro.write.html\n/// [`io::Write`]: ../../std/io/trait.Write.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Write {\n    /// Writes a slice of bytes into this writer, returning whether the write\n    /// succeeded.\n    ///\n    /// This method can only succeed if the entire byte slice was successfully\n    /// written, and this method will not return until all data has been\n    /// written or an error occurs.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an instance of [`Error`] on error.\n    ///\n    /// [`Error`]: struct.Error.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt::{Error, Write};\n    ///\n    /// fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {\n    ///     f.write_str(s)\n    /// }\n    ///\n    /// let mut buf = String::new();\n    /// writer(&mut buf, \"hola\").unwrap();\n    /// assert_eq!(&buf, \"hola\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn write_str(&mut self, s: &str) -> Result;\n\n    /// Writes a [`char`] into this writer, returning whether the write succeeded.\n    ///\n    /// A single [`char`] may be encoded as more than one byte.\n    /// This method can only succeed if the entire byte sequence was successfully\n    /// written, and this method will not return until all data has been\n    /// written or an error occurs.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an instance of [`Error`] on error.\n    ///\n    /// [`char`]: ../../std/primitive.char.html\n    /// [`Error`]: struct.Error.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt::{Error, Write};\n    ///\n    /// fn writer<W: Write>(f: &mut W, c: char) -> Result<(), Error> {\n    ///     f.write_char(c)\n    /// }\n    ///\n    /// let mut buf = String::new();\n    /// writer(&mut buf, 'a').unwrap();\n    /// writer(&mut buf, 'b').unwrap();\n    /// assert_eq!(&buf, \"ab\");\n    /// ```\n    #[stable(feature = \"fmt_write_char\", since = \"1.1.0\")]\n    fn write_char(&mut self, c: char) -> Result {\n        self.write_str(c.encode_utf8(&mut [0; 4]))\n    }\n\n    /// Glue for usage of the [`write!`] macro with implementors of this trait.\n    ///\n    /// This method should generally not be invoked manually, but rather through\n    /// the [`write!`] macro itself.\n    ///\n    /// [`write!`]: ../../std/macro.write.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt::{Error, Write};\n    ///\n    /// fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {\n    ///     f.write_fmt(format_args!(\"{}\", s))\n    /// }\n    ///\n    /// let mut buf = String::new();\n    /// writer(&mut buf, \"world\").unwrap();\n    /// assert_eq!(&buf, \"world\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn write_fmt(&mut self, args: Arguments) -> Result {\n        // This Adapter is needed to allow `self` (of type `&mut\n        // Self`) to be cast to a Write (below) without\n        // requiring a `Sized` bound.\n        struct Adapter<'a,T: ?Sized +'a>(&'a mut T);\n\n        impl<T: ?Sized> Write for Adapter<'_, T>\n            where T: Write\n        {\n            fn write_str(&mut self, s: &str) -> Result {\n                self.0.write_str(s)\n            }\n\n            fn write_char(&mut self, c: char) -> Result {\n                self.0.write_char(c)\n            }\n\n            fn write_fmt(&mut self, args: Arguments) -> Result {\n                self.0.write_fmt(args)\n            }\n        }\n\n        write(&mut Adapter(self), args)\n    }\n}\n\n#[stable(feature = \"fmt_write_blanket_impl\", since = \"1.4.0\")]\nimpl<W: Write + ?Sized> Write for &mut W {\n    fn write_str(&mut self, s: &str) -> Result {\n        (**self).write_str(s)\n    }\n\n    fn write_char(&mut self, c: char) -> Result {\n        (**self).write_char(c)\n    }\n\n    fn write_fmt(&mut self, args: Arguments) -> Result {\n        (**self).write_fmt(args)\n    }\n}\n\n/// A struct to represent both where to emit formatting strings to and how they\n/// should be formatted. A mutable version of this is passed to all formatting\n/// traits.\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Formatter<'a> {\n    flags: u32,\n    fill: char,\n    align: rt::v1::Alignment,\n    width: Option<usize>,\n    precision: Option<usize>,\n\n    buf: &'a mut (dyn Write+'a),\n    curarg: slice::Iter<'a, ArgumentV1<'a>>,\n    args: &'a [ArgumentV1<'a>],\n}\n\n// NB. Argument is essentially an optimized partially applied formatting function,\n// equivalent to `exists T.(&T, fn(&T, &mut Formatter) -> Result`.\n\nstruct Void {\n    _priv: (),\n    /// Erases all oibits, because `Void` erases the type of the object that\n    /// will be used to produce formatted output. Since we do not know what\n    /// oibits the real types have (and they can have any or none), we need to\n    /// take the most conservative approach and forbid all oibits.\n    ///\n    /// It was added after #45197 showed that one could share a `!Sync`\n    /// object across threads by passing it into `format_args!`.\n    _oibit_remover: PhantomData<*mut dyn Fn()>,\n}\n\n/// This struct represents the generic \"argument\" which is taken by the Xprintf\n/// family of functions. It contains a function to format the given value. At\n/// compile time it is ensured that the function and the value have the correct\n/// types, and then this struct is used to canonicalize arguments to one type.\n#[derive(Copy)]\n#[allow(missing_debug_implementations)]\n#[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n           issue = \"0\")]\n#[doc(hidden)]\npub struct ArgumentV1<'a> {\n    value: &'a Void,\n    formatter: fn(&Void, &mut Formatter) -> Result,\n}\n\n#[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n           issue = \"0\")]\nimpl Clone for ArgumentV1<'_> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\nimpl<'a> ArgumentV1<'a> {\n    #[inline(never)]\n    fn show_usize(x: &usize, f: &mut Formatter) -> Result {\n        Display::fmt(x, f)\n    }\n\n    #[doc(hidden)]\n    #[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n               issue = \"0\")]\n    pub fn new<'b, T>(x: &'b T,\n                      f: fn(&T, &mut Formatter) -> Result) -> ArgumentV1<'b> {\n        unsafe {\n            ArgumentV1 {\n                formatter: mem::transmute(f),\n                value: mem::transmute(x)\n            }\n        }\n    }\n\n    #[doc(hidden)]\n    #[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n               issue = \"0\")]\n    pub fn from_usize(x: &usize) -> ArgumentV1 {\n        ArgumentV1::new(x, ArgumentV1::show_usize)\n    }\n\n    fn as_usize(&self) -> Option<usize> {\n        if self.formatter as usize == ArgumentV1::show_usize as usize {\n            Some(unsafe { *(self.value as *const _ as *const usize) })\n        } else {\n            None\n        }\n    }\n}\n\n// flags available in the v1 format of format_args\n#[derive(Copy, Clone)]\nenum FlagV1 { SignPlus, SignMinus, Alternate, SignAwareZeroPad, DebugLowerHex, DebugUpperHex }\n\nimpl<'a> Arguments<'a> {\n    /// When using the format_args!() macro, this function is used to generate the\n    /// Arguments structure.\n    #[doc(hidden)] #[inline]\n    #[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n               issue = \"0\")]\n    pub fn new_v1(pieces: &'a [&'a str],\n                  args: &'a [ArgumentV1<'a>]) -> Arguments<'a> {\n        Arguments {\n            pieces,\n            fmt: None,\n            args,\n        }\n    }\n\n    /// This function is used to specify nonstandard formatting parameters.\n    /// The `pieces` array must be at least as long as `fmt` to construct\n    /// a valid Arguments structure. Also, any `Count` within `fmt` that is\n    /// `CountIsParam` or `CountIsNextParam` has to point to an argument\n    /// created with `argumentusize`. However, failing to do so doesn't cause\n    /// unsafety, but will ignore invalid .\n    #[doc(hidden)] #[inline]\n    #[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n               issue = \"0\")]\n    pub fn new_v1_formatted(pieces: &'a [&'a str],\n                            args: &'a [ArgumentV1<'a>],\n                            fmt: &'a [rt::v1::Argument]) -> Arguments<'a> {\n        Arguments {\n            pieces,\n            fmt: Some(fmt),\n            args,\n        }\n    }\n\n    /// Estimates the length of the formatted text.\n    ///\n    /// This is intended to be used for setting initial `String` capacity\n    /// when using `format!`. Note: this is neither the lower nor upper bound.\n    #[doc(hidden)] #[inline]\n    #[unstable(feature = \"fmt_internals\", reason = \"internal to format_args!\",\n               issue = \"0\")]\n    pub fn estimated_capacity(&self) -> usize {\n        let pieces_length: usize = self.pieces.iter()\n            .map(|x| x.len()).sum();\n\n        if self.args.is_empty() {\n            pieces_length\n        } else if self.pieces[0] == \"\" && pieces_length < 16 {\n            // If the format string starts with an argument,\n            // don't preallocate anything, unless length\n            // of pieces is significant.\n            0\n        } else {\n            // There are some arguments, so any additional push\n            // will reallocate the string. To avoid that,\n            // we're \"pre-doubling\" the capacity here.\n            pieces_length.checked_mul(2).unwrap_or(0)\n        }\n    }\n}\n\n/// This structure represents a safely precompiled version of a format string\n/// and its arguments. This cannot be generated at runtime because it cannot\n/// safely be done, so no constructors are given and the fields are private\n/// to prevent modification.\n///\n/// The [`format_args!`] macro will safely create an instance of this structure.\n/// The macro validates the format string at compile-time so usage of the\n/// [`write`] and [`format`] functions can be safely performed.\n///\n/// You can use the `Arguments<'a>` that [`format_args!`] returns in `Debug`\n/// and `Display` contexts as seen below. The example also shows that `Debug`\n/// and `Display` format to the same thing: the interpolated format string\n/// in `format_args!`.\n///\n/// ```rust\n/// let debug = format!(\"{:?}\", format_args!(\"{} foo {:?}\", 1, 2));\n/// let display = format!(\"{}\", format_args!(\"{} foo {:?}\", 1, 2));\n/// assert_eq!(\"1 foo 2\", display);\n/// assert_eq!(display, debug);\n/// ```\n///\n/// [`format_args!`]: ../../std/macro.format_args.html\n/// [`format`]: ../../std/fmt/fn.format.html\n/// [`write`]: ../../std/fmt/fn.write.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Copy, Clone)]\npub struct Arguments<'a> {\n    // Format string pieces to print.\n    pieces: &'a [&'a str],\n\n    // Placeholder specs, or `None` if all specs are default (as in \"{}{}\").\n    fmt: Option<&'a [rt::v1::Argument]>,\n\n    // Dynamic arguments for interpolation, to be interleaved with string\n    // pieces. (Every argument is preceded by a string piece.)\n    args: &'a [ArgumentV1<'a>],\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Debug for Arguments<'_> {\n    fn fmt(&self, fmt: &mut Formatter) -> Result {\n        Display::fmt(self, fmt)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Display for Arguments<'_> {\n    fn fmt(&self, fmt: &mut Formatter) -> Result {\n        write(fmt.buf, *self)\n    }\n}\n\n/// `?` formatting.\n///\n/// `Debug` should format the output in a programmer-facing, debugging context.\n///\n/// Generally speaking, you should just `derive` a `Debug` implementation.\n///\n/// When used with the alternate format specifier `#?`, the output is pretty-printed.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// This trait can be used with `#[derive]` if all fields implement `Debug`. When\n/// `derive`d for structs, it will use the name of the `struct`, then `{`, then a\n/// comma-separated list of each field's name and `Debug` value, then `}`. For\n/// `enum`s, it will use the name of the variant and, if applicable, `(`, then the\n/// `Debug` values of the fields, then `)`.\n///\n/// # Examples\n///\n/// Deriving an implementation:\n///\n/// ```\n/// #[derive(Debug)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// let origin = Point { x: 0, y: 0 };\n///\n/// println!(\"The origin is: {:?}\", origin);\n/// ```\n///\n/// Manually implementing:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl fmt::Debug for Point {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         write!(f, \"Point {{ x: {}, y: {} }}\", self.x, self.y)\n///     }\n/// }\n///\n/// let origin = Point { x: 0, y: 0 };\n///\n/// println!(\"The origin is: {:?}\", origin);\n/// ```\n///\n/// This outputs:\n///\n/// ```text\n/// The origin is: Point { x: 0, y: 0 }\n/// ```\n///\n/// There are a number of `debug_*` methods on [`Formatter`] to help you with manual\n/// implementations, such as [`debug_struct`][debug_struct].\n///\n/// `Debug` implementations using either `derive` or the debug builder API\n/// on [`Formatter`] support pretty printing using the alternate flag: `{:#?}`.\n///\n/// [debug_struct]: ../../std/fmt/struct.Formatter.html#method.debug_struct\n/// [`Formatter`]: ../../std/fmt/struct.Formatter.html\n///\n/// Pretty printing with `#?`:\n///\n/// ```\n/// #[derive(Debug)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// let origin = Point { x: 0, y: 0 };\n///\n/// println!(\"The origin is: {:#?}\", origin);\n/// ```\n///\n/// This outputs:\n///\n/// ```text\n/// The origin is: Point {\n///     x: 0,\n///     y: 0\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    on(crate_local, label=\"`{Self}` cannot be formatted using `{{:?}}`\",\n                    note=\"add `#[derive(Debug)]` or manually implement `{Debug}`\"),\n    message=\"`{Self}` doesn't implement `{Debug}`\",\n    label=\"`{Self}` cannot be formatted using `{{:?}}` because it doesn't implement `{Debug}`\",\n)]\n#[doc(alias = \"{:?}\")]\n#[lang = \"debug_trait\"]\npub trait Debug {\n    /// Formats the value using the given formatter.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Position {\n    ///     longitude: f32,\n    ///     latitude: f32,\n    /// }\n    ///\n    /// impl fmt::Debug for Position {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"({:?}, {:?})\", self.longitude, self.latitude)\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(\"(1.987, 2.983)\".to_owned(),\n    ///            format!(\"{:?}\", Position { longitude: 1.987, latitude: 2.983, }));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// Format trait for an empty format, `{}`.\n///\n/// `Display` is similar to [`Debug`][debug], but `Display` is for user-facing\n/// output, and so cannot be derived.\n///\n/// [debug]: trait.Debug.html\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Implementing `Display` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl fmt::Display for Point {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         write!(f, \"({}, {})\", self.x, self.y)\n///     }\n/// }\n///\n/// let origin = Point { x: 0, y: 0 };\n///\n/// println!(\"The origin is: {}\", origin);\n/// ```\n#[rustc_on_unimplemented(\n    message=\"`{Self}` doesn't implement `{Display}`\",\n    label=\"`{Self}` cannot be formatted with the default formatter\",\n    note=\"in format strings you may be able to use `{{:?}}` \\\n          (or {{:#?}} for pretty-print) instead\",\n)]\n#[doc(alias = \"{}\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Display {\n    /// Formats the value using the given formatter.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Position {\n    ///     longitude: f32,\n    ///     latitude: f32,\n    /// }\n    ///\n    /// impl fmt::Display for Position {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"({}, {})\", self.longitude, self.latitude)\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(\"(1.987, 2.983)\".to_owned(),\n    ///            format!(\"{}\", Position { longitude: 1.987, latitude: 2.983, }));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `o` formatting.\n///\n/// The `Octal` trait should format its output as a number in base-8.\n///\n/// For primitive signed integers (`i8` to `i128`, and `isize`),\n/// negative values are formatted as the two\u2019s complement representation.\n///\n/// The alternate flag, `#`, adds a `0o` in front of the output.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `i32`:\n///\n/// ```\n/// let x = 42; // 42 is '52' in octal\n///\n/// assert_eq!(format!(\"{:o}\", x), \"52\");\n/// assert_eq!(format!(\"{:#o}\", x), \"0o52\");\n///\n/// assert_eq!(format!(\"{:o}\", -16), \"37777777760\");\n/// ```\n///\n/// Implementing `Octal` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::Octal for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///\n///         write!(f, \"{:o}\", val) // delegate to i32's implementation\n///     }\n/// }\n///\n/// let l = Length(9);\n///\n/// println!(\"l as octal is: {:o}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Octal {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `b` formatting.\n///\n/// The `Binary` trait should format its output as a number in binary.\n///\n/// For primitive signed integers ([`i8`] to [`i128`], and [`isize`]),\n/// negative values are formatted as the two\u2019s complement representation.\n///\n/// The alternate flag, `#`, adds a `0b` in front of the output.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// # Examples\n///\n/// Basic usage with [`i32`]:\n///\n/// ```\n/// let x = 42; // 42 is '101010' in binary\n///\n/// assert_eq!(format!(\"{:b}\", x), \"101010\");\n/// assert_eq!(format!(\"{:#b}\", x), \"0b101010\");\n///\n/// assert_eq!(format!(\"{:b}\", -16), \"11111111111111111111111111110000\");\n/// ```\n///\n/// Implementing `Binary` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::Binary for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///\n///         write!(f, \"{:b}\", val) // delegate to i32's implementation\n///     }\n/// }\n///\n/// let l = Length(107);\n///\n/// println!(\"l as binary is: {:b}\", l);\n/// ```\n///\n/// [module]: ../../std/fmt/index.html\n/// [`i8`]: ../../std/primitive.i8.html\n/// [`i128`]: ../../std/primitive.i128.html\n/// [`isize`]: ../../std/primitive.isize.html\n/// [`i32`]: ../../std/primitive.i32.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Binary {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `x` formatting.\n///\n/// The `LowerHex` trait should format its output as a number in hexadecimal, with `a` through `f`\n/// in lower case.\n///\n/// For primitive signed integers (`i8` to `i128`, and `isize`),\n/// negative values are formatted as the two\u2019s complement representation.\n///\n/// The alternate flag, `#`, adds a `0x` in front of the output.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `i32`:\n///\n/// ```\n/// let x = 42; // 42 is '2a' in hex\n///\n/// assert_eq!(format!(\"{:x}\", x), \"2a\");\n/// assert_eq!(format!(\"{:#x}\", x), \"0x2a\");\n///\n/// assert_eq!(format!(\"{:x}\", -16), \"fffffff0\");\n/// ```\n///\n/// Implementing `LowerHex` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::LowerHex for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///\n///         write!(f, \"{:x}\", val) // delegate to i32's implementation\n///     }\n/// }\n///\n/// let l = Length(9);\n///\n/// println!(\"l as hex is: {:x}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait LowerHex {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `X` formatting.\n///\n/// The `UpperHex` trait should format its output as a number in hexadecimal, with `A` through `F`\n/// in upper case.\n///\n/// For primitive signed integers (`i8` to `i128`, and `isize`),\n/// negative values are formatted as the two\u2019s complement representation.\n///\n/// The alternate flag, `#`, adds a `0x` in front of the output.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `i32`:\n///\n/// ```\n/// let x = 42; // 42 is '2A' in hex\n///\n/// assert_eq!(format!(\"{:X}\", x), \"2A\");\n/// assert_eq!(format!(\"{:#X}\", x), \"0x2A\");\n///\n/// assert_eq!(format!(\"{:X}\", -16), \"FFFFFFF0\");\n/// ```\n///\n/// Implementing `UpperHex` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::UpperHex for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///\n///         write!(f, \"{:X}\", val) // delegate to i32's implementation\n///     }\n/// }\n///\n/// let l = Length(9);\n///\n/// println!(\"l as hex is: {:X}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait UpperHex {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `p` formatting.\n///\n/// The `Pointer` trait should format its output as a memory location. This is commonly presented\n/// as hexadecimal.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `&i32`:\n///\n/// ```\n/// let x = &42;\n///\n/// let address = format!(\"{:p}\", x); // this produces something like '0x7f06092ac6d0'\n/// ```\n///\n/// Implementing `Pointer` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::Pointer for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         // use `as` to convert to a `*const T`, which implements Pointer, which we can use\n///\n///         write!(f, \"{:p}\", self as *const Length)\n///     }\n/// }\n///\n/// let l = Length(42);\n///\n/// println!(\"l is in memory here: {:p}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Pointer {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `e` formatting.\n///\n/// The `LowerExp` trait should format its output in scientific notation with a lower-case `e`.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `i32`:\n///\n/// ```\n/// let x = 42.0; // 42.0 is '4.2e1' in scientific notation\n///\n/// assert_eq!(format!(\"{:e}\", x), \"4.2e1\");\n/// ```\n///\n/// Implementing `LowerExp` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::LowerExp for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///         write!(f, \"{}e1\", val / 10)\n///     }\n/// }\n///\n/// let l = Length(100);\n///\n/// println!(\"l in scientific notation is: {:e}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait LowerExp {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// `E` formatting.\n///\n/// The `UpperExp` trait should format its output in scientific notation with an upper-case `E`.\n///\n/// For more information on formatters, see [the module-level documentation][module].\n///\n/// [module]: ../../std/fmt/index.html\n///\n/// # Examples\n///\n/// Basic usage with `f32`:\n///\n/// ```\n/// let x = 42.0; // 42.0 is '4.2E1' in scientific notation\n///\n/// assert_eq!(format!(\"{:E}\", x), \"4.2E1\");\n/// ```\n///\n/// Implementing `UpperExp` on a type:\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Length(i32);\n///\n/// impl fmt::UpperExp for Length {\n///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n///         let val = self.0;\n///         write!(f, \"{}E1\", val / 10)\n///     }\n/// }\n///\n/// let l = Length(100);\n///\n/// println!(\"l in scientific notation is: {:E}\", l);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait UpperExp {\n    /// Formats the value using the given formatter.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fmt(&self, f: &mut Formatter) -> Result;\n}\n\n/// The `write` function takes an output stream, and an `Arguments` struct\n/// that can be precompiled with the `format_args!` macro.\n///\n/// The arguments will be formatted according to the specified format string\n/// into the output stream provided.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::fmt;\n///\n/// let mut output = String::new();\n/// fmt::write(&mut output, format_args!(\"Hello {}!\", \"world\"))\n///     .expect(\"Error occurred while trying to write in String\");\n/// assert_eq!(output, \"Hello world!\");\n/// ```\n///\n/// Please note that using [`write!`] might be preferable. Example:\n///\n/// ```\n/// use std::fmt::Write;\n///\n/// let mut output = String::new();\n/// write!(&mut output, \"Hello {}!\", \"world\")\n///     .expect(\"Error occurred while trying to write in String\");\n/// assert_eq!(output, \"Hello world!\");\n/// ```\n///\n/// [`write!`]: ../../std/macro.write.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn write(output: &mut dyn Write, args: Arguments) -> Result {\n    let mut formatter = Formatter {\n        flags: 0,\n        width: None,\n        precision: None,\n        buf: output,\n        align: rt::v1::Alignment::Unknown,\n        fill: ' ',\n        args: args.args,\n        curarg: args.args.iter(),\n    };\n\n    let mut pieces = args.pieces.iter();\n\n    match args.fmt {\n        None => {\n            // We can use default formatting parameters for all arguments.\n            for (arg, piece) in args.args.iter().zip(pieces.by_ref()) {\n                formatter.buf.write_str(*piece)?;\n                (arg.formatter)(arg.value, &mut formatter)?;\n            }\n        }\n        Some(fmt) => {\n            // Every spec has a corresponding argument that is preceded by\n            // a string piece.\n            for (arg, piece) in fmt.iter().zip(pieces.by_ref()) {\n                formatter.buf.write_str(*piece)?;\n                formatter.run(arg)?;\n            }\n        }\n    }\n\n    // There can be only one trailing string piece left.\n    if let Some(piece) = pieces.next() {\n        formatter.buf.write_str(*piece)?;\n    }\n\n    Ok(())\n}\n\nimpl<'a> Formatter<'a> {\n    fn wrap_buf<'b, 'c, F>(&'b mut self, wrap: F) -> Formatter<'c>\n        where 'b: 'c, F: FnOnce(&'b mut (dyn Write+'b)) -> &'c mut (dyn Write+'c)\n    {\n        Formatter {\n            // We want to change this\n            buf: wrap(self.buf),\n\n            // And preserve these\n            flags: self.flags,\n            fill: self.fill,\n            align: self.align,\n            width: self.width,\n            precision: self.precision,\n\n            // These only exist in the struct for the `run` method,\n            // which won\u2019t be used together with this method.\n            curarg: self.curarg.clone(),\n            args: self.args,\n        }\n    }\n\n    // First up is the collection of functions used to execute a format string\n    // at runtime. This consumes all of the compile-time statics generated by\n    // the format! syntax extension.\n    fn run(&mut self, arg: &rt::v1::Argument) -> Result {\n        // Fill in the format parameters into the formatter\n        self.fill = arg.format.fill;\n        self.align = arg.format.align;\n        self.flags = arg.format.flags;\n        self.width = self.getcount(&arg.format.width);\n        self.precision = self.getcount(&arg.format.precision);\n\n        // Extract the correct argument\n        let value = match arg.position {\n            rt::v1::Position::Next => { *self.curarg.next().unwrap() }\n            rt::v1::Position::At(i) => self.args[i],\n        };\n\n        // Then actually do some printing\n        (value.formatter)(value.value, self)\n    }\n\n    fn getcount(&mut self, cnt: &rt::v1::Count) -> Option<usize> {\n        match *cnt {\n            rt::v1::Count::Is(n) => Some(n),\n            rt::v1::Count::Implied => None,\n            rt::v1::Count::Param(i) => {\n                self.args[i].as_usize()\n            }\n            rt::v1::Count::NextParam => {\n                self.curarg.next().and_then(|arg| arg.as_usize())\n            }\n        }\n    }\n\n    // Helper methods used for padding and processing formatting arguments that\n    // all formatting traits can use.\n\n    /// Performs the correct padding for an integer which has already been\n    /// emitted into a str. The str should *not* contain the sign for the\n    /// integer, that will be added by this method.\n    ///\n    /// # Arguments\n    ///\n    /// * is_nonnegative - whether the original integer was either positive or zero.\n    /// * prefix - if the '#' character (Alternate) is provided, this\n    ///   is the prefix to put in front of the number.\n    /// * buf - the byte array that the number has been formatted into\n    ///\n    /// This function will correctly account for the flags provided as well as\n    /// the minimum width. It will not take precision into account.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo { nb: i32 };\n    ///\n    /// impl Foo {\n    ///     fn new(nb: i32) -> Foo {\n    ///         Foo {\n    ///             nb,\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         // We need to remove \"-\" from the number output.\n    ///         let tmp = self.nb.abs().to_string();\n    ///\n    ///         formatter.pad_integral(self.nb > 0, \"Foo \", &tmp)\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{}\", Foo::new(2)), \"2\");\n    /// assert_eq!(&format!(\"{}\", Foo::new(-1)), \"-1\");\n    /// assert_eq!(&format!(\"{:#}\", Foo::new(-1)), \"-Foo 1\");\n    /// assert_eq!(&format!(\"{:0>#8}\", Foo::new(-1)), \"00-Foo 1\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn pad_integral(&mut self,\n                        is_nonnegative: bool,\n                        prefix: &str,\n                        buf: &str)\n                        -> Result {\n        let mut width = buf.len();\n\n        let mut sign = None;\n        if !is_nonnegative {\n            sign = Some('-'); width += 1;\n        } else if self.sign_plus() {\n            sign = Some('+'); width += 1;\n        }\n\n        let mut prefixed = false;\n        if self.alternate() {\n            prefixed = true; width += prefix.chars().count();\n        }\n\n        // Writes the sign if it exists, and then the prefix if it was requested\n        let write_prefix = |f: &mut Formatter| {\n            if let Some(c) = sign {\n                f.buf.write_str(c.encode_utf8(&mut [0; 4]))?;\n            }\n            if prefixed { f.buf.write_str(prefix) }\n            else { Ok(()) }\n        };\n\n        // The `width` field is more of a `min-width` parameter at this point.\n        match self.width {\n            // If there's no minimum length requirements then we can just\n            // write the bytes.\n            None => {\n                write_prefix(self)?; self.buf.write_str(buf)\n            }\n            // Check if we're over the minimum width, if so then we can also\n            // just write the bytes.\n            Some(min) if width >= min => {\n                write_prefix(self)?; self.buf.write_str(buf)\n            }\n            // The sign and prefix goes before the padding if the fill character\n            // is zero\n            Some(min) if self.sign_aware_zero_pad() => {\n                self.fill = '0';\n                self.align = rt::v1::Alignment::Right;\n                write_prefix(self)?;\n                self.with_padding(min - width, rt::v1::Alignment::Right, |f| {\n                    f.buf.write_str(buf)\n                })\n            }\n            // Otherwise, the sign and prefix goes after the padding\n            Some(min) => {\n                self.with_padding(min - width, rt::v1::Alignment::Right, |f| {\n                    write_prefix(f)?; f.buf.write_str(buf)\n                })\n            }\n        }\n    }\n\n    /// This function takes a string slice and emits it to the internal buffer\n    /// after applying the relevant formatting flags specified. The flags\n    /// recognized for generic strings are:\n    ///\n    /// * width - the minimum width of what to emit\n    /// * fill/align - what to emit and where to emit it if the string\n    ///                provided needs to be padded\n    /// * precision - the maximum length to emit, the string is truncated if it\n    ///               is longer than this length\n    ///\n    /// Notably this function ignores the `flag` parameters.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo;\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         formatter.pad(\"Foo\")\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:<4}\", Foo), \"Foo \");\n    /// assert_eq!(&format!(\"{:0>4}\", Foo), \"0Foo\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn pad(&mut self, s: &str) -> Result {\n        // Make sure there's a fast path up front\n        if self.width.is_none() && self.precision.is_none() {\n            return self.buf.write_str(s);\n        }\n        // The `precision` field can be interpreted as a `max-width` for the\n        // string being formatted.\n        let s = if let Some(max) = self.precision {\n            // If our string is longer that the precision, then we must have\n            // truncation. However other flags like `fill`, `width` and `align`\n            // must act as always.\n            if let Some((i, _)) = s.char_indices().nth(max) {\n                // LLVM here can't prove that `..i` won't panic `&s[..i]`, but\n                // we know that it can't panic. Use `get` + `unwrap_or` to avoid\n                // `unsafe` and otherwise don't emit any panic-related code\n                // here.\n                s.get(..i).unwrap_or(&s)\n            } else {\n                &s\n            }\n        } else {\n            &s\n        };\n        // The `width` field is more of a `min-width` parameter at this point.\n        match self.width {\n            // If we're under the maximum length, and there's no minimum length\n            // requirements, then we can just emit the string\n            None => self.buf.write_str(s),\n            // If we're under the maximum width, check if we're over the minimum\n            // width, if so it's as easy as just emitting the string.\n            Some(width) if s.chars().count() >= width => {\n                self.buf.write_str(s)\n            }\n            // If we're under both the maximum and the minimum width, then fill\n            // up the minimum width with the specified string + some alignment.\n            Some(width) => {\n                let align = rt::v1::Alignment::Left;\n                self.with_padding(width - s.chars().count(), align, |me| {\n                    me.buf.write_str(s)\n                })\n            }\n        }\n    }\n\n    /// Runs a callback, emitting the correct padding either before or\n    /// afterwards depending on whether right or left alignment is requested.\n    fn with_padding<F>(&mut self, padding: usize, default: rt::v1::Alignment,\n                       f: F) -> Result\n        where F: FnOnce(&mut Formatter) -> Result,\n    {\n        let align = match self.align {\n            rt::v1::Alignment::Unknown => default,\n            _ => self.align\n        };\n\n        let (pre_pad, post_pad) = match align {\n            rt::v1::Alignment::Left => (0, padding),\n            rt::v1::Alignment::Right |\n            rt::v1::Alignment::Unknown => (padding, 0),\n            rt::v1::Alignment::Center => (padding / 2, (padding + 1) / 2),\n        };\n\n        let mut fill = [0; 4];\n        let fill = self.fill.encode_utf8(&mut fill);\n\n        for _ in 0..pre_pad {\n            self.buf.write_str(fill)?;\n        }\n\n        f(self)?;\n\n        for _ in 0..post_pad {\n            self.buf.write_str(fill)?;\n        }\n\n        Ok(())\n    }\n\n    /// Takes the formatted parts and applies the padding.\n    /// Assumes that the caller already has rendered the parts with required precision,\n    /// so that `self.precision` can be ignored.\n    fn pad_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {\n        if let Some(mut width) = self.width {\n            // for the sign-aware zero padding, we render the sign first and\n            // behave as if we had no sign from the beginning.\n            let mut formatted = formatted.clone();\n            let old_fill = self.fill;\n            let old_align = self.align;\n            let mut align = old_align;\n            if self.sign_aware_zero_pad() {\n                // a sign always goes first\n                let sign = unsafe { str::from_utf8_unchecked(formatted.sign) };\n                self.buf.write_str(sign)?;\n\n                // remove the sign from the formatted parts\n                formatted.sign = b\"\";\n                width = if width < sign.len() { 0 } else { width - sign.len() };\n                align = rt::v1::Alignment::Right;\n                self.fill = '0';\n                self.align = rt::v1::Alignment::Right;\n            }\n\n            // remaining parts go through the ordinary padding process.\n            let len = formatted.len();\n            let ret = if width <= len { // no padding\n                self.write_formatted_parts(&formatted)\n            } else {\n                self.with_padding(width - len, align, |f| {\n                    f.write_formatted_parts(&formatted)\n                })\n            };\n            self.fill = old_fill;\n            self.align = old_align;\n            ret\n        } else {\n            // this is the common case and we take a shortcut\n            self.write_formatted_parts(formatted)\n        }\n    }\n\n    fn write_formatted_parts(&mut self, formatted: &flt2dec::Formatted) -> Result {\n        fn write_bytes(buf: &mut dyn Write, s: &[u8]) -> Result {\n            buf.write_str(unsafe { str::from_utf8_unchecked(s) })\n        }\n\n        if !formatted.sign.is_empty() {\n            write_bytes(self.buf, formatted.sign)?;\n        }\n        for part in formatted.parts {\n            match *part {\n                flt2dec::Part::Zero(mut nzeroes) => {\n                    const ZEROES: &'static str = // 64 zeroes\n                        \"0000000000000000000000000000000000000000000000000000000000000000\";\n                    while nzeroes > ZEROES.len() {\n                        self.buf.write_str(ZEROES)?;\n                        nzeroes -= ZEROES.len();\n                    }\n                    if nzeroes > 0 {\n                        self.buf.write_str(&ZEROES[..nzeroes])?;\n                    }\n                }\n                flt2dec::Part::Num(mut v) => {\n                    let mut s = [0; 5];\n                    let len = part.len();\n                    for c in s[..len].iter_mut().rev() {\n                        *c = b'0' + (v % 10) as u8;\n                        v /= 10;\n                    }\n                    write_bytes(self.buf, &s[..len])?;\n                }\n                flt2dec::Part::Copy(buf) => {\n                    write_bytes(self.buf, buf)?;\n                }\n            }\n        }\n        Ok(())\n    }\n\n    /// Writes some data to the underlying buffer contained within this\n    /// formatter.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo;\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         formatter.write_str(\"Foo\")\n    ///         // This is equivalent to:\n    ///         // write!(formatter, \"Foo\")\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{}\", Foo), \"Foo\");\n    /// assert_eq!(&format!(\"{:0>8}\", Foo), \"Foo\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn write_str(&mut self, data: &str) -> Result {\n        self.buf.write_str(data)\n    }\n\n    /// Writes some formatted information into this instance.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         formatter.write_fmt(format_args!(\"Foo {}\", self.0))\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{}\", Foo(-1)), \"Foo -1\");\n    /// assert_eq!(&format!(\"{:0>8}\", Foo(2)), \"Foo 2\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn write_fmt(&mut self, fmt: Arguments) -> Result {\n        write(self.buf, fmt)\n    }\n\n    /// Flags for formatting\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.24.0\",\n                       reason = \"use the `sign_plus`, `sign_minus`, `alternate`, \\\n                                 or `sign_aware_zero_pad` methods instead\")]\n    pub fn flags(&self) -> u32 { self.flags }\n\n    /// Character used as 'fill' whenever there is alignment.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo;\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         let c = formatter.fill();\n    ///         if let Some(width) = formatter.width() {\n    ///             for _ in 0..width {\n    ///                 write!(formatter, \"{}\", c)?;\n    ///             }\n    ///             Ok(())\n    ///         } else {\n    ///             write!(formatter, \"{}\", c)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// // We set alignment to the left with \">\".\n    /// assert_eq!(&format!(\"{:G>3}\", Foo), \"GGG\");\n    /// assert_eq!(&format!(\"{:t>6}\", Foo), \"tttttt\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn fill(&self) -> char { self.fill }\n\n    /// Flag indicating what form of alignment was requested.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// extern crate core;\n    ///\n    /// use std::fmt::{self, Alignment};\n    ///\n    /// struct Foo;\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         let s = if let Some(s) = formatter.align() {\n    ///             match s {\n    ///                 Alignment::Left    => \"left\",\n    ///                 Alignment::Right   => \"right\",\n    ///                 Alignment::Center  => \"center\",\n    ///             }\n    ///         } else {\n    ///             \"into the void\"\n    ///         };\n    ///         write!(formatter, \"{}\", s)\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     assert_eq!(&format!(\"{:<}\", Foo), \"left\");\n    ///     assert_eq!(&format!(\"{:>}\", Foo), \"right\");\n    ///     assert_eq!(&format!(\"{:^}\", Foo), \"center\");\n    ///     assert_eq!(&format!(\"{}\", Foo), \"into the void\");\n    /// }\n    /// ```\n    #[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\n    pub fn align(&self) -> Option<Alignment> {\n        match self.align {\n            rt::v1::Alignment::Left => Some(Alignment::Left),\n            rt::v1::Alignment::Right => Some(Alignment::Right),\n            rt::v1::Alignment::Center => Some(Alignment::Center),\n            rt::v1::Alignment::Unknown => None,\n        }\n    }\n\n    /// Optionally specified integer width that the output should be.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         if let Some(width) = formatter.width() {\n    ///             // If we received a width, we use it\n    ///             write!(formatter, \"{:width$}\", &format!(\"Foo({})\", self.0), width = width)\n    ///         } else {\n    ///             // Otherwise we do nothing special\n    ///             write!(formatter, \"Foo({})\", self.0)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:10}\", Foo(23)), \"Foo(23)   \");\n    /// assert_eq!(&format!(\"{}\", Foo(23)), \"Foo(23)\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn width(&self) -> Option<usize> { self.width }\n\n    /// Optionally specified precision for numeric types.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(f32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         if let Some(precision) = formatter.precision() {\n    ///             // If we received a precision, we use it.\n    ///             write!(formatter, \"Foo({1:.*})\", precision, self.0)\n    ///         } else {\n    ///             // Otherwise we default to 2.\n    ///             write!(formatter, \"Foo({:.2})\", self.0)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:.4}\", Foo(23.2)), \"Foo(23.2000)\");\n    /// assert_eq!(&format!(\"{}\", Foo(23.2)), \"Foo(23.20)\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn precision(&self) -> Option<usize> { self.precision }\n\n    /// Determines if the `+` flag was specified.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         if formatter.sign_plus() {\n    ///             write!(formatter,\n    ///                    \"Foo({}{})\",\n    ///                    if self.0 < 0 { '-' } else { '+' },\n    ///                    self.0)\n    ///         } else {\n    ///             write!(formatter, \"Foo({})\", self.0)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:+}\", Foo(23)), \"Foo(+23)\");\n    /// assert_eq!(&format!(\"{}\", Foo(23)), \"Foo(23)\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn sign_plus(&self) -> bool { self.flags & (1 << FlagV1::SignPlus as u32) != 0 }\n\n    /// Determines if the `-` flag was specified.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         if formatter.sign_minus() {\n    ///             // You want a minus sign? Have one!\n    ///             write!(formatter, \"-Foo({})\", self.0)\n    ///         } else {\n    ///             write!(formatter, \"Foo({})\", self.0)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:-}\", Foo(23)), \"-Foo(23)\");\n    /// assert_eq!(&format!(\"{}\", Foo(23)), \"Foo(23)\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn sign_minus(&self) -> bool { self.flags & (1 << FlagV1::SignMinus as u32) != 0 }\n\n    /// Determines if the `#` flag was specified.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         if formatter.alternate() {\n    ///             write!(formatter, \"Foo({})\", self.0)\n    ///         } else {\n    ///             write!(formatter, \"{}\", self.0)\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:#}\", Foo(23)), \"Foo(23)\");\n    /// assert_eq!(&format!(\"{}\", Foo(23)), \"23\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn alternate(&self) -> bool { self.flags & (1 << FlagV1::Alternate as u32) != 0 }\n\n    /// Determines if the `0` flag was specified.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fmt;\n    ///\n    /// struct Foo(i32);\n    ///\n    /// impl fmt::Display for Foo {\n    ///     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n    ///         assert!(formatter.sign_aware_zero_pad());\n    ///         assert_eq!(formatter.width(), Some(4));\n    ///         // We ignore the formatter's options.\n    ///         write!(formatter, \"{}\", self.0)\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(&format!(\"{:04}\", Foo(23)), \"23\");\n    /// ```\n    #[stable(feature = \"fmt_flags\", since = \"1.5.0\")]\n    pub fn sign_aware_zero_pad(&self) -> bool {\n        self.flags & (1 << FlagV1::SignAwareZeroPad as u32) != 0\n    }\n\n    // FIXME: Decide what public API we want for these two flags.\n    // https://github.com/rust-lang/rust/issues/48584\n    fn debug_lower_hex(&self) -> bool { self.flags & (1 << FlagV1::DebugLowerHex as u32) != 0 }\n\n    fn debug_upper_hex(&self) -> bool { self.flags & (1 << FlagV1::DebugUpperHex as u32) != 0 }\n\n    /// Creates a [`DebugStruct`] builder designed to assist with creation of\n    /// [`fmt::Debug`] implementations for structs.\n    ///\n    /// [`DebugStruct`]: ../../std/fmt/struct.DebugStruct.html\n    /// [`fmt::Debug`]: ../../std/fmt/trait.Debug.html\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::fmt;\n    /// use std::net::Ipv4Addr;\n    ///\n    /// struct Foo {\n    ///     bar: i32,\n    ///     baz: String,\n    ///     addr: Ipv4Addr,\n    /// }\n    ///\n    /// impl fmt::Debug for Foo {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_struct(\"Foo\")\n    ///             .field(\"bar\", &self.bar)\n    ///             .field(\"baz\", &self.baz)\n    ///             .field(\"addr\", &format_args!(\"{}\", self.addr))\n    ///             .finish()\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(\n    ///     \"Foo { bar: 10, baz: \\\"Hello World\\\", addr: 127.0.0.1 }\",\n    ///     format!(\"{:?}\", Foo {\n    ///         bar: 10,\n    ///         baz: \"Hello World\".to_string(),\n    ///         addr: Ipv4Addr::new(127, 0, 0, 1),\n    ///     })\n    /// );\n    /// ```\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn debug_struct<'b>(&'b mut self, name: &str) -> DebugStruct<'b, 'a> {\n        builders::debug_struct_new(self, name)\n    }\n\n    /// Creates a `DebugTuple` builder designed to assist with creation of\n    /// `fmt::Debug` implementations for tuple structs.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::fmt;\n    /// use std::marker::PhantomData;\n    ///\n    /// struct Foo<T>(i32, String, PhantomData<T>);\n    ///\n    /// impl<T> fmt::Debug for Foo<T> {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_tuple(\"Foo\")\n    ///             .field(&self.0)\n    ///             .field(&self.1)\n    ///             .field(&format_args!(\"_\"))\n    ///             .finish()\n    ///     }\n    /// }\n    ///\n    /// assert_eq!(\n    ///     \"Foo(10, \\\"Hello\\\", _)\",\n    ///     format!(\"{:?}\", Foo(10, \"Hello\".to_string(), PhantomData::<u8>))\n    /// );\n    /// ```\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn debug_tuple<'b>(&'b mut self, name: &str) -> DebugTuple<'b, 'a> {\n        builders::debug_tuple_new(self, name)\n    }\n\n    /// Creates a `DebugList` builder designed to assist with creation of\n    /// `fmt::Debug` implementations for list-like structures.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::fmt;\n    ///\n    /// struct Foo(Vec<i32>);\n    ///\n    /// impl fmt::Debug for Foo {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_list().entries(self.0.iter()).finish()\n    ///     }\n    /// }\n    ///\n    /// // prints \"[10, 11]\"\n    /// println!(\"{:?}\", Foo(vec![10, 11]));\n    /// ```\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn debug_list<'b>(&'b mut self) -> DebugList<'b, 'a> {\n        builders::debug_list_new(self)\n    }\n\n    /// Creates a `DebugSet` builder designed to assist with creation of\n    /// `fmt::Debug` implementations for set-like structures.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::fmt;\n    ///\n    /// struct Foo(Vec<i32>);\n    ///\n    /// impl fmt::Debug for Foo {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_set().entries(self.0.iter()).finish()\n    ///     }\n    /// }\n    ///\n    /// // prints \"{10, 11}\"\n    /// println!(\"{:?}\", Foo(vec![10, 11]));\n    /// ```\n    ///\n    /// [`format_args!`]: ../../std/macro.format_args.html\n    ///\n    /// In this more complex example, we use [`format_args!`] and `.debug_set()`\n    /// to build a list of match arms:\n    ///\n    /// ```rust\n    /// use std::fmt;\n    ///\n    /// struct Arm<'a, L: 'a, R: 'a>(&'a (L, R));\n    /// struct Table<'a, K: 'a, V: 'a>(&'a [(K, V)], V);\n    ///\n    /// impl<'a, L, R> fmt::Debug for Arm<'a, L, R>\n    /// where\n    ///     L: 'a + fmt::Debug, R: 'a + fmt::Debug\n    /// {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         L::fmt(&(self.0).0, fmt)?;\n    ///         fmt.write_str(\" => \")?;\n    ///         R::fmt(&(self.0).1, fmt)\n    ///     }\n    /// }\n    ///\n    /// impl<'a, K, V> fmt::Debug for Table<'a, K, V>\n    /// where\n    ///     K: 'a + fmt::Debug, V: 'a + fmt::Debug\n    /// {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_set()\n    ///         .entries(self.0.iter().map(Arm))\n    ///         .entry(&Arm(&(format_args!(\"_\"), &self.1)))\n    ///         .finish()\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn debug_set<'b>(&'b mut self) -> DebugSet<'b, 'a> {\n        builders::debug_set_new(self)\n    }\n\n    /// Creates a `DebugMap` builder designed to assist with creation of\n    /// `fmt::Debug` implementations for map-like structures.\n    ///\n    /// # Examples\n    ///\n    /// ```rust\n    /// use std::fmt;\n    ///\n    /// struct Foo(Vec<(String, i32)>);\n    ///\n    /// impl fmt::Debug for Foo {\n    ///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n    ///         fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish()\n    ///     }\n    /// }\n    ///\n    /// // prints \"{\"A\": 10, \"B\": 11}\"\n    /// println!(\"{:?}\", Foo(vec![(\"A\".to_string(), 10), (\"B\".to_string(), 11)]));\n    /// ```\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn debug_map<'b>(&'b mut self) -> DebugMap<'b, 'a> {\n        builders::debug_map_new(self)\n    }\n}\n\n#[stable(since = \"1.2.0\", feature = \"formatter_write\")]\nimpl Write for Formatter<'_> {\n    fn write_str(&mut self, s: &str) -> Result {\n        self.buf.write_str(s)\n    }\n\n    fn write_char(&mut self, c: char) -> Result {\n        self.buf.write_char(c)\n    }\n\n    fn write_fmt(&mut self, args: Arguments) -> Result {\n        write(self.buf, args)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Display for Error {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Display::fmt(\"an error occurred when formatting an argument\", f)\n    }\n}\n\n// Implementations of the core formatting traits\n\nmacro_rules! fmt_refs {\n    ($($tr:ident),*) => {\n        $(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<T: ?Sized + $tr> $tr for &T {\n            fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }\n        }\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<T: ?Sized + $tr> $tr for &mut T {\n            fn fmt(&self, f: &mut Formatter) -> Result { $tr::fmt(&**self, f) }\n        }\n        )*\n    }\n}\n\nfmt_refs! { Debug, Display, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }\n\n#[unstable(feature = \"never_type\", issue = \"35121\")]\nimpl Debug for ! {\n    fn fmt(&self, _: &mut Formatter) -> Result {\n        *self\n    }\n}\n\n#[unstable(feature = \"never_type\", issue = \"35121\")]\nimpl Display for ! {\n    fn fmt(&self, _: &mut Formatter) -> Result {\n        *self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Debug for bool {\n    #[inline]\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Display::fmt(self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Display for bool {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Display::fmt(if *self { \"true\" } else { \"false\" }, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Debug for str {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.write_char('\"')?;\n        let mut from = 0;\n        for (i, c) in self.char_indices() {\n            let esc = c.escape_debug();\n            // If char needs escaping, flush backlog so far and write, else skip\n            if esc.len() != 1 {\n                f.write_str(&self[from..i])?;\n                for c in esc {\n                    f.write_char(c)?;\n                }\n                from = i + c.len_utf8();\n            }\n        }\n        f.write_str(&self[from..])?;\n        f.write_char('\"')\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Display for str {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.pad(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Debug for char {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.write_char('\\'')?;\n        for c in self.escape_debug() {\n            f.write_char(c)?\n        }\n        f.write_char('\\'')\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Display for char {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        if f.width.is_none() && f.precision.is_none() {\n            f.write_char(*self)\n        } else {\n            f.pad(self.encode_utf8(&mut [0; 4]))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Pointer for *const T {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        let old_width = f.width;\n        let old_flags = f.flags;\n\n        // The alternate flag is already treated by LowerHex as being special-\n        // it denotes whether to prefix with 0x. We use it to work out whether\n        // or not to zero extend, and then unconditionally set it to get the\n        // prefix.\n        if f.alternate() {\n            f.flags |= 1 << (FlagV1::SignAwareZeroPad as u32);\n\n            if let None = f.width {\n                f.width = Some(((mem::size_of::<usize>() * 8) / 4) + 2);\n            }\n        }\n        f.flags |= 1 << (FlagV1::Alternate as u32);\n\n        let ret = LowerHex::fmt(&(*self as *const () as usize), f);\n\n        f.width = old_width;\n        f.flags = old_flags;\n\n        ret\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Pointer for *mut T {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Pointer::fmt(&(*self as *const T), f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Pointer for &T {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Pointer::fmt(&(*self as *const T), f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Pointer for &mut T {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Pointer::fmt(&(&**self as *const T), f)\n    }\n}\n\n// Implementation of Display/Debug for various core types\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Debug for *const T {\n    fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Debug for *mut T {\n    fn fmt(&self, f: &mut Formatter) -> Result { Pointer::fmt(self, f) }\n}\n\nmacro_rules! peel {\n    ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })\n}\n\nmacro_rules! tuple {\n    () => ();\n    ( $($name:ident,)+ ) => (\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<$($name:Debug),*> Debug for ($($name,)*) where last_type!($($name,)+): ?Sized {\n            #[allow(non_snake_case, unused_assignments, deprecated)]\n            fn fmt(&self, f: &mut Formatter) -> Result {\n                let mut builder = f.debug_tuple(\"\");\n                let ($(ref $name,)*) = *self;\n                $(\n                    builder.field(&$name);\n                )*\n\n                builder.finish()\n            }\n        }\n        peel! { $($name,)* }\n    )\n}\n\nmacro_rules! last_type {\n    ($a:ident,) => { $a };\n    ($a:ident, $($rest_a:ident,)+) => { last_type!($($rest_a,)+) };\n}\n\ntuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Debug> Debug for [T] {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.debug_list().entries(self.iter()).finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Debug for () {\n    #[inline]\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.pad(\"()\")\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Debug for PhantomData<T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.pad(\"PhantomData\")\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Copy + Debug> Debug for Cell<T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.debug_struct(\"Cell\")\n            .field(\"value\", &self.get())\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Debug> Debug for RefCell<T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        match self.try_borrow() {\n            Ok(borrow) => {\n                f.debug_struct(\"RefCell\")\n                    .field(\"value\", &borrow)\n                    .finish()\n            }\n            Err(_) => {\n                // The RefCell is mutably borrowed so we can't look at its value\n                // here. Show a placeholder instead.\n                struct BorrowedPlaceholder;\n\n                impl Debug for BorrowedPlaceholder {\n                    fn fmt(&self, f: &mut Formatter) -> Result {\n                        f.write_str(\"<borrowed>\")\n                    }\n                }\n\n                f.debug_struct(\"RefCell\")\n                    .field(\"value\", &BorrowedPlaceholder)\n                    .finish()\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Debug> Debug for Ref<'_, T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Debug> Debug for RefMut<'_, T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        Debug::fmt(&*(self.deref()), f)\n    }\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<T: ?Sized + Debug> Debug for UnsafeCell<T> {\n    fn fmt(&self, f: &mut Formatter) -> Result {\n        f.pad(\"UnsafeCell\")\n    }\n}\n\n// If you expected tests to be here, look instead at the run-pass/ifmt.rs test,\n// it's a lot easier than creating all of the rt::Piece structures here.\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Functionality for ordering and comparison.\n//!\n//! This module defines both [`PartialOrd`] and [`PartialEq`] traits which are used\n//! by the compiler to implement comparison operators. Rust programs may\n//! implement [`PartialOrd`] to overload the `<`, `<=`, `>`, and `>=` operators,\n//! and may implement [`PartialEq`] to overload the `==` and `!=` operators.\n//!\n//! [`PartialOrd`]: trait.PartialOrd.html\n//! [`PartialEq`]: trait.PartialEq.html\n//!\n//! # Examples\n//!\n//! ```\n//! let x: u32 = 0;\n//! let y: u32 = 1;\n//!\n//! // these two lines are equivalent\n//! assert_eq!(x < y, true);\n//! assert_eq!(x.lt(&y), true);\n//!\n//! // these two lines are also equivalent\n//! assert_eq!(x == y, false);\n//! assert_eq!(x.eq(&y), false);\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse self::Ordering::*;\n\n/// Trait for equality comparisons which are [partial equivalence\n/// relations](http://en.wikipedia.org/wiki/Partial_equivalence_relation).\n///\n/// This trait allows for partial equality, for types that do not have a full\n/// equivalence relation.  For example, in floating point numbers `NaN != NaN`,\n/// so floating point types implement `PartialEq` but not `Eq`.\n///\n/// Formally, the equality must be (for all `a`, `b` and `c`):\n///\n/// - symmetric: `a == b` implies `b == a`; and\n/// - transitive: `a == b` and `b == c` implies `a == c`.\n///\n/// Note that these requirements mean that the trait itself must be implemented\n/// symmetrically and transitively: if `T: PartialEq<U>` and `U: PartialEq<V>`\n/// then `U: PartialEq<T>` and `T: PartialEq<V>`.\n///\n/// ## Derivable\n///\n/// This trait can be used with `#[derive]`. When `derive`d on structs, two\n/// instances are equal if all fields are equal, and not equal if any fields\n/// are not equal. When `derive`d on enums, each variant is equal to itself\n/// and not equal to the other variants.\n///\n/// ## How can I implement `PartialEq`?\n///\n/// PartialEq only requires the `eq` method to be implemented; `ne` is defined\n/// in terms of it by default. Any manual implementation of `ne` *must* respect\n/// the rule that `eq` is a strict inverse of `ne`; that is, `!(a == b)` if and\n/// only if `a != b`.\n///\n/// Implementations of `PartialEq`, `PartialOrd`, and `Ord` *must* agree with\n/// each other. It's easy to accidentally make them disagree by deriving some\n/// of the traits and manually implementing others.\n///\n/// An example implementation for a domain in which two books are considered\n/// the same book if their ISBN matches, even if the formats differ:\n///\n/// ```\n/// enum BookFormat {\n///     Paperback,\n///     Hardback,\n///     Ebook,\n/// }\n///\n/// struct Book {\n///     isbn: i32,\n///     format: BookFormat,\n/// }\n///\n/// impl PartialEq for Book {\n///     fn eq(&self, other: &Book) -> bool {\n///         self.isbn == other.isbn\n///     }\n/// }\n///\n/// let b1 = Book { isbn: 3, format: BookFormat::Paperback };\n/// let b2 = Book { isbn: 3, format: BookFormat::Ebook };\n/// let b3 = Book { isbn: 10, format: BookFormat::Paperback };\n///\n/// assert!(b1 == b2);\n/// assert!(b1 != b3);\n/// ```\n///\n/// ## How can I compare two different types?\n///\n/// The type you can compare with is controlled by `PartialEq`'s type parameter.\n/// For example, let's tweak our previous code a bit:\n///\n/// ```\n/// enum BookFormat {\n///     Paperback,\n///     Hardback,\n///     Ebook,\n/// }\n///\n/// struct Book {\n///     isbn: i32,\n///     format: BookFormat,\n/// }\n///\n/// impl PartialEq<BookFormat> for Book {\n///     fn eq(&self, other: &BookFormat) -> bool {\n///         match (&self.format, other) {\n///            (BookFormat::Paperback, BookFormat::Paperback) => true,\n///            (BookFormat::Hardback,  BookFormat::Hardback)  => true,\n///            (BookFormat::Ebook,     BookFormat::Ebook)     => true,\n///            (_, _) => false,\n///         }\n///     }\n/// }\n///\n/// let b1 = Book { isbn: 3, format: BookFormat::Paperback };\n///\n/// assert!(b1 == BookFormat::Paperback);\n/// assert!(b1 != BookFormat::Ebook);\n/// ```\n///\n/// By changing `impl PartialEq for Book` to `impl PartialEq<BookFormat> for Book`,\n/// we've changed what type we can use on the right side of the `==` operator.\n/// This lets us use it in the `assert!` statements at the bottom.\n///\n/// You can also combine these implementations to let the `==` operator work with\n/// two different types:\n///\n/// ```\n/// enum BookFormat {\n///     Paperback,\n///     Hardback,\n///     Ebook,\n/// }\n///\n/// struct Book {\n///     isbn: i32,\n///     format: BookFormat,\n/// }\n///\n/// impl PartialEq<BookFormat> for Book {\n///     fn eq(&self, other: &BookFormat) -> bool {\n///         match (&self.format, other) {\n///            (&BookFormat::Paperback, &BookFormat::Paperback) => true,\n///            (&BookFormat::Hardback,  &BookFormat::Hardback)  => true,\n///            (&BookFormat::Ebook,     &BookFormat::Ebook)     => true,\n///            (_, _) => false,\n///         }\n///     }\n/// }\n///\n/// impl PartialEq for Book {\n///     fn eq(&self, other: &Book) -> bool {\n///         self.isbn == other.isbn\n///     }\n/// }\n///\n/// let b1 = Book { isbn: 3, format: BookFormat::Paperback };\n/// let b2 = Book { isbn: 3, format: BookFormat::Ebook };\n///\n/// assert!(b1 == BookFormat::Paperback);\n/// assert!(b1 != BookFormat::Ebook);\n/// assert!(b1 == b2);\n/// ```\n///\n/// # Examples\n///\n/// ```\n/// let x: u32 = 0;\n/// let y: u32 = 1;\n///\n/// assert_eq!(x == y, false);\n/// assert_eq!(x.eq(&y), false);\n/// ```\n#[lang = \"eq\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(alias = \"==\")]\n#[doc(alias = \"!=\")]\n#[rustc_on_unimplemented(\n    message=\"can't compare `{Self}` with `{Rhs}`\",\n    label=\"no implementation for `{Self} == {Rhs}`\",\n)]\npub trait PartialEq<Rhs: ?Sized = Self> {\n    /// This method tests for `self` and `other` values to be equal, and is used\n    /// by `==`.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn eq(&self, other: &Rhs) -> bool;\n\n    /// This method tests for `!=`.\n    #[inline]\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn ne(&self, other: &Rhs) -> bool { !self.eq(other) }\n}\n\n/// Trait for equality comparisons which are [equivalence relations](\n/// https://en.wikipedia.org/wiki/Equivalence_relation).\n///\n/// This means, that in addition to `a == b` and `a != b` being strict inverses, the equality must\n/// be (for all `a`, `b` and `c`):\n///\n/// - reflexive: `a == a`;\n/// - symmetric: `a == b` implies `b == a`; and\n/// - transitive: `a == b` and `b == c` implies `a == c`.\n///\n/// This property cannot be checked by the compiler, and therefore `Eq` implies\n/// `PartialEq`, and has no extra methods.\n///\n/// ## Derivable\n///\n/// This trait can be used with `#[derive]`. When `derive`d, because `Eq` has\n/// no extra methods, it is only informing the compiler that this is an\n/// equivalence relation rather than a partial equivalence relation. Note that\n/// the `derive` strategy requires all fields are `Eq`, which isn't\n/// always desired.\n///\n/// ## How can I implement `Eq`?\n///\n/// If you cannot use the `derive` strategy, specify that your type implements\n/// `Eq`, which has no methods:\n///\n/// ```\n/// enum BookFormat { Paperback, Hardback, Ebook }\n/// struct Book {\n///     isbn: i32,\n///     format: BookFormat,\n/// }\n/// impl PartialEq for Book {\n///     fn eq(&self, other: &Book) -> bool {\n///         self.isbn == other.isbn\n///     }\n/// }\n/// impl Eq for Book {}\n/// ```\n#[doc(alias = \"==\")]\n#[doc(alias = \"!=\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Eq: PartialEq<Self> {\n    // this method is used solely by #[deriving] to assert\n    // that every component of a type implements #[deriving]\n    // itself, the current deriving infrastructure means doing this\n    // assertion without using a method on this trait is nearly\n    // impossible.\n    //\n    // This should never be implemented by hand.\n    #[doc(hidden)]\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn assert_receiver_is_total_eq(&self) {}\n}\n\n// FIXME: this struct is used solely by #[derive] to\n// assert that every component of a type implements Eq.\n//\n// This struct should never appear in user code.\n#[doc(hidden)]\n#[allow(missing_debug_implementations)]\n#[unstable(feature = \"derive_eq\",\n           reason = \"deriving hack, should not be public\",\n           issue = \"0\")]\npub struct AssertParamIsEq<T: Eq + ?Sized> { _field: ::marker::PhantomData<T> }\n\n/// An `Ordering` is the result of a comparison between two values.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp::Ordering;\n///\n/// let result = 1.cmp(&2);\n/// assert_eq!(Ordering::Less, result);\n///\n/// let result = 1.cmp(&1);\n/// assert_eq!(Ordering::Equal, result);\n///\n/// let result = 2.cmp(&1);\n/// assert_eq!(Ordering::Greater, result);\n/// ```\n#[derive(Clone, Copy, PartialEq, Debug, Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Ordering {\n    /// An ordering where a compared value is less [than another].\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Less = -1,\n    /// An ordering where a compared value is equal [to another].\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Equal = 0,\n    /// An ordering where a compared value is greater [than another].\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Greater = 1,\n}\n\nimpl Ordering {\n    /// Reverses the `Ordering`.\n    ///\n    /// * `Less` becomes `Greater`.\n    /// * `Greater` becomes `Less`.\n    /// * `Equal` becomes `Equal`.\n    ///\n    /// # Examples\n    ///\n    /// Basic behavior:\n    ///\n    /// ```\n    /// use std::cmp::Ordering;\n    ///\n    /// assert_eq!(Ordering::Less.reverse(), Ordering::Greater);\n    /// assert_eq!(Ordering::Equal.reverse(), Ordering::Equal);\n    /// assert_eq!(Ordering::Greater.reverse(), Ordering::Less);\n    /// ```\n    ///\n    /// This method can be used to reverse a comparison:\n    ///\n    /// ```\n    /// let mut data: &mut [_] = &mut [2, 10, 5, 8];\n    ///\n    /// // sort the array from largest to smallest.\n    /// data.sort_by(|a, b| a.cmp(b).reverse());\n    ///\n    /// let b: &mut [_] = &mut [10, 8, 5, 2];\n    /// assert!(data == b);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reverse(self) -> Ordering {\n        match self {\n            Less => Greater,\n            Equal => Equal,\n            Greater => Less,\n        }\n    }\n\n    /// Chains two orderings.\n    ///\n    /// Returns `self` when it's not `Equal`. Otherwise returns `other`.\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cmp::Ordering;\n    ///\n    /// let result = Ordering::Equal.then(Ordering::Less);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Less.then(Ordering::Equal);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Less.then(Ordering::Greater);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Equal.then(Ordering::Equal);\n    /// assert_eq!(result, Ordering::Equal);\n    ///\n    /// let x: (i64, i64, i64) = (1, 2, 7);\n    /// let y: (i64, i64, i64) = (1, 5, 3);\n    /// let result = x.0.cmp(&y.0).then(x.1.cmp(&y.1)).then(x.2.cmp(&y.2));\n    ///\n    /// assert_eq!(result, Ordering::Less);\n    /// ```\n    #[inline]\n    #[stable(feature = \"ordering_chaining\", since = \"1.17.0\")]\n    pub fn then(self, other: Ordering) -> Ordering {\n        match self {\n            Equal => other,\n            _ => self,\n        }\n    }\n\n    /// Chains the ordering with the given function.\n    ///\n    /// Returns `self` when it's not `Equal`. Otherwise calls `f` and returns\n    /// the result.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cmp::Ordering;\n    ///\n    /// let result = Ordering::Equal.then_with(|| Ordering::Less);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Less.then_with(|| Ordering::Equal);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Less.then_with(|| Ordering::Greater);\n    /// assert_eq!(result, Ordering::Less);\n    ///\n    /// let result = Ordering::Equal.then_with(|| Ordering::Equal);\n    /// assert_eq!(result, Ordering::Equal);\n    ///\n    /// let x: (i64, i64, i64) = (1, 2, 7);\n    /// let y: (i64, i64, i64)  = (1, 5, 3);\n    /// let result = x.0.cmp(&y.0).then_with(|| x.1.cmp(&y.1)).then_with(|| x.2.cmp(&y.2));\n    ///\n    /// assert_eq!(result, Ordering::Less);\n    /// ```\n    #[inline]\n    #[stable(feature = \"ordering_chaining\", since = \"1.17.0\")]\n    pub fn then_with<F: FnOnce() -> Ordering>(self, f: F) -> Ordering {\n        match self {\n            Equal => f(),\n            _ => self,\n        }\n    }\n}\n\n/// A helper struct for reverse ordering.\n///\n/// This struct is a helper to be used with functions like `Vec::sort_by_key` and\n/// can be used to reverse order a part of a key.\n///\n/// Example usage:\n///\n/// ```\n/// use std::cmp::Reverse;\n///\n/// let mut v = vec![1, 2, 3, 4, 5, 6];\n/// v.sort_by_key(|&num| (num > 3, Reverse(num)));\n/// assert_eq!(v, vec![3, 2, 1, 6, 5, 4]);\n/// ```\n#[derive(PartialEq, Eq, Debug, Copy, Clone, Default, Hash)]\n#[stable(feature = \"reverse_cmp_key\", since = \"1.19.0\")]\npub struct Reverse<T>(#[stable(feature = \"reverse_cmp_key\", since = \"1.19.0\")] pub T);\n\n#[stable(feature = \"reverse_cmp_key\", since = \"1.19.0\")]\nimpl<T: PartialOrd> PartialOrd for Reverse<T> {\n    #[inline]\n    fn partial_cmp(&self, other: &Reverse<T>) -> Option<Ordering> {\n        other.0.partial_cmp(&self.0)\n    }\n\n    #[inline]\n    fn lt(&self, other: &Self) -> bool { other.0 < self.0 }\n    #[inline]\n    fn le(&self, other: &Self) -> bool { other.0 <= self.0 }\n    #[inline]\n    fn ge(&self, other: &Self) -> bool { other.0 >= self.0 }\n    #[inline]\n    fn gt(&self, other: &Self) -> bool { other.0 > self.0 }\n}\n\n#[stable(feature = \"reverse_cmp_key\", since = \"1.19.0\")]\nimpl<T: Ord> Ord for Reverse<T> {\n    #[inline]\n    fn cmp(&self, other: &Reverse<T>) -> Ordering {\n        other.0.cmp(&self.0)\n    }\n}\n\n/// Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order).\n///\n/// An order is a total order if it is (for all `a`, `b` and `c`):\n///\n/// - total and antisymmetric: exactly one of `a < b`, `a == b` or `a > b` is true; and\n/// - transitive, `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.\n///\n/// ## Derivable\n///\n/// This trait can be used with `#[derive]`. When `derive`d on structs, it will produce a\n/// lexicographic ordering based on the top-to-bottom declaration order of the struct's members.\n/// When `derive`d on enums, variants are ordered by their top-to-bottom declaration order.\n///\n/// ## How can I implement `Ord`?\n///\n/// `Ord` requires that the type also be `PartialOrd` and `Eq` (which requires `PartialEq`).\n///\n/// Then you must define an implementation for `cmp()`. You may find it useful to use\n/// `cmp()` on your type's fields.\n///\n/// Implementations of `PartialEq`, `PartialOrd`, and `Ord` *must* agree with each other. It's\n/// easy to accidentally make them disagree by deriving some of the traits and manually\n/// implementing others.\n///\n/// Here's an example where you want to sort people by height only, disregarding `id`\n/// and `name`:\n///\n/// ```\n/// use std::cmp::Ordering;\n///\n/// #[derive(Eq)]\n/// struct Person {\n///     id: u32,\n///     name: String,\n///     height: u32,\n/// }\n///\n/// impl Ord for Person {\n///     fn cmp(&self, other: &Person) -> Ordering {\n///         self.height.cmp(&other.height)\n///     }\n/// }\n///\n/// impl PartialOrd for Person {\n///     fn partial_cmp(&self, other: &Person) -> Option<Ordering> {\n///         Some(self.cmp(other))\n///     }\n/// }\n///\n/// impl PartialEq for Person {\n///     fn eq(&self, other: &Person) -> bool {\n///         self.height == other.height\n///     }\n/// }\n/// ```\n#[lang = \"ord\"]\n#[doc(alias = \"<\")]\n#[doc(alias = \">\")]\n#[doc(alias = \"<=\")]\n#[doc(alias = \">=\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Ord: Eq + PartialOrd<Self> {\n    /// This method returns an `Ordering` between `self` and `other`.\n    ///\n    /// By convention, `self.cmp(&other)` returns the ordering matching the expression\n    /// `self <operator> other` if true.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cmp::Ordering;\n    ///\n    /// assert_eq!(5.cmp(&10), Ordering::Less);\n    /// assert_eq!(10.cmp(&5), Ordering::Greater);\n    /// assert_eq!(5.cmp(&5), Ordering::Equal);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn cmp(&self, other: &Self) -> Ordering;\n\n    /// Compares and returns the maximum of two values.\n    ///\n    /// Returns the second argument if the comparison determines them to be equal.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!(2, 1.max(2));\n    /// assert_eq!(2, 2.max(2));\n    /// ```\n    #[stable(feature = \"ord_max_min\", since = \"1.21.0\")]\n    #[inline]\n    fn max(self, other: Self) -> Self\n    where Self: Sized {\n        if other >= self { other } else { self }\n    }\n\n    /// Compares and returns the minimum of two values.\n    ///\n    /// Returns the first argument if the comparison determines them to be equal.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!(1, 1.min(2));\n    /// assert_eq!(2, 2.min(2));\n    /// ```\n    #[stable(feature = \"ord_max_min\", since = \"1.21.0\")]\n    #[inline]\n    fn min(self, other: Self) -> Self\n    where Self: Sized {\n        if self <= other { self } else { other }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for Ordering {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for Ordering {\n    #[inline]\n    fn cmp(&self, other: &Ordering) -> Ordering {\n        (*self as i32).cmp(&(*other as i32))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for Ordering {\n    #[inline]\n    fn partial_cmp(&self, other: &Ordering) -> Option<Ordering> {\n        (*self as i32).partial_cmp(&(*other as i32))\n    }\n}\n\n/// Trait for values that can be compared for a sort-order.\n///\n/// The comparison must satisfy, for all `a`, `b` and `c`:\n///\n/// - antisymmetry: if `a < b` then `!(a > b)`, as well as `a > b` implying `!(a < b)`; and\n/// - transitivity: `a < b` and `b < c` implies `a < c`. The same must hold for both `==` and `>`.\n///\n/// Note that these requirements mean that the trait itself must be implemented symmetrically and\n/// transitively: if `T: PartialOrd<U>` and `U: PartialOrd<V>` then `U: PartialOrd<T>` and `T:\n/// PartialOrd<V>`.\n///\n/// ## Derivable\n///\n/// This trait can be used with `#[derive]`. When `derive`d on structs, it will produce a\n/// lexicographic ordering based on the top-to-bottom declaration order of the struct's members.\n/// When `derive`d on enums, variants are ordered by their top-to-bottom declaration order.\n///\n/// ## How can I implement `PartialOrd`?\n///\n/// `PartialOrd` only requires implementation of the `partial_cmp` method, with the others\n/// generated from default implementations.\n///\n/// However it remains possible to implement the others separately for types which do not have a\n/// total order. For example, for floating point numbers, `NaN < 0 == false` and `NaN >= 0 ==\n/// false` (cf. IEEE 754-2008 section 5.11).\n///\n/// `PartialOrd` requires your type to be `PartialEq`.\n///\n/// Implementations of `PartialEq`, `PartialOrd`, and `Ord` *must* agree with each other. It's\n/// easy to accidentally make them disagree by deriving some of the traits and manually\n/// implementing others.\n///\n/// If your type is `Ord`, you can implement `partial_cmp()` by using `cmp()`:\n///\n/// ```\n/// use std::cmp::Ordering;\n///\n/// #[derive(Eq)]\n/// struct Person {\n///     id: u32,\n///     name: String,\n///     height: u32,\n/// }\n///\n/// impl PartialOrd for Person {\n///     fn partial_cmp(&self, other: &Person) -> Option<Ordering> {\n///         Some(self.cmp(other))\n///     }\n/// }\n///\n/// impl Ord for Person {\n///     fn cmp(&self, other: &Person) -> Ordering {\n///         self.height.cmp(&other.height)\n///     }\n/// }\n///\n/// impl PartialEq for Person {\n///     fn eq(&self, other: &Person) -> bool {\n///         self.height == other.height\n///     }\n/// }\n/// ```\n///\n/// You may also find it useful to use `partial_cmp()` on your type's fields. Here\n/// is an example of `Person` types who have a floating-point `height` field that\n/// is the only field to be used for sorting:\n///\n/// ```\n/// use std::cmp::Ordering;\n///\n/// struct Person {\n///     id: u32,\n///     name: String,\n///     height: f64,\n/// }\n///\n/// impl PartialOrd for Person {\n///     fn partial_cmp(&self, other: &Person) -> Option<Ordering> {\n///         self.height.partial_cmp(&other.height)\n///     }\n/// }\n///\n/// impl PartialEq for Person {\n///     fn eq(&self, other: &Person) -> bool {\n///         self.height == other.height\n///     }\n/// }\n/// ```\n///\n/// # Examples\n///\n/// ```\n/// let x : u32 = 0;\n/// let y : u32 = 1;\n///\n/// assert_eq!(x < y, true);\n/// assert_eq!(x.lt(&y), true);\n/// ```\n#[lang = \"partial_ord\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(alias = \">\")]\n#[doc(alias = \"<\")]\n#[doc(alias = \"<=\")]\n#[doc(alias = \">=\")]\n#[rustc_on_unimplemented(\n    message=\"can't compare `{Self}` with `{Rhs}`\",\n    label=\"no implementation for `{Self} < {Rhs}` and `{Self} > {Rhs}`\",\n)]\npub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {\n    /// This method returns an ordering between `self` and `other` values if one exists.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cmp::Ordering;\n    ///\n    /// let result = 1.0.partial_cmp(&2.0);\n    /// assert_eq!(result, Some(Ordering::Less));\n    ///\n    /// let result = 1.0.partial_cmp(&1.0);\n    /// assert_eq!(result, Some(Ordering::Equal));\n    ///\n    /// let result = 2.0.partial_cmp(&1.0);\n    /// assert_eq!(result, Some(Ordering::Greater));\n    /// ```\n    ///\n    /// When comparison is impossible:\n    ///\n    /// ```\n    /// let result = std::f64::NAN.partial_cmp(&1.0);\n    /// assert_eq!(result, None);\n    /// ```\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;\n\n    /// This method tests less than (for `self` and `other`) and is used by the `<` operator.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let result = 1.0 < 2.0;\n    /// assert_eq!(result, true);\n    ///\n    /// let result = 2.0 < 1.0;\n    /// assert_eq!(result, false);\n    /// ```\n    #[inline]\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn lt(&self, other: &Rhs) -> bool {\n        match self.partial_cmp(other) {\n            Some(Less) => true,\n            _ => false,\n        }\n    }\n\n    /// This method tests less than or equal to (for `self` and `other`) and is used by the `<=`\n    /// operator.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let result = 1.0 <= 2.0;\n    /// assert_eq!(result, true);\n    ///\n    /// let result = 2.0 <= 2.0;\n    /// assert_eq!(result, true);\n    /// ```\n    #[inline]\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn le(&self, other: &Rhs) -> bool {\n        match self.partial_cmp(other) {\n            Some(Less) | Some(Equal) => true,\n            _ => false,\n        }\n    }\n\n    /// This method tests greater than (for `self` and `other`) and is used by the `>` operator.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let result = 1.0 > 2.0;\n    /// assert_eq!(result, false);\n    ///\n    /// let result = 2.0 > 2.0;\n    /// assert_eq!(result, false);\n    /// ```\n    #[inline]\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn gt(&self, other: &Rhs) -> bool {\n        match self.partial_cmp(other) {\n            Some(Greater) => true,\n            _ => false,\n        }\n    }\n\n    /// This method tests greater than or equal to (for `self` and `other`) and is used by the `>=`\n    /// operator.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let result = 2.0 >= 1.0;\n    /// assert_eq!(result, true);\n    ///\n    /// let result = 2.0 >= 2.0;\n    /// assert_eq!(result, true);\n    /// ```\n    #[inline]\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn ge(&self, other: &Rhs) -> bool {\n        match self.partial_cmp(other) {\n            Some(Greater) | Some(Equal) => true,\n            _ => false,\n        }\n    }\n}\n\n/// Compares and returns the minimum of two values.\n///\n/// Returns the first argument if the comparison determines them to be equal.\n///\n/// Internally uses an alias to `Ord::min`.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq!(1, cmp::min(1, 2));\n/// assert_eq!(2, cmp::min(2, 2));\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn min<T: Ord>(v1: T, v2: T) -> T {\n    v1.min(v2)\n}\n\n/// Compares and returns the maximum of two values.\n///\n/// Returns the second argument if the comparison determines them to be equal.\n///\n/// Internally uses an alias to `Ord::max`.\n///\n/// # Examples\n///\n/// ```\n/// use std::cmp;\n///\n/// assert_eq!(2, cmp::max(1, 2));\n/// assert_eq!(2, cmp::max(2, 2));\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn max<T: Ord>(v1: T, v2: T) -> T {\n    v1.max(v2)\n}\n\n// Implementation of PartialEq, Eq, PartialOrd and Ord for primitive types\nmod impls {\n    use cmp::Ordering::{self, Less, Greater, Equal};\n\n    macro_rules! partial_eq_impl {\n        ($($t:ty)*) => ($(\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl PartialEq for $t {\n                #[inline]\n                fn eq(&self, other: &$t) -> bool { (*self) == (*other) }\n                #[inline]\n                fn ne(&self, other: &$t) -> bool { (*self) != (*other) }\n            }\n        )*)\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl PartialEq for () {\n        #[inline]\n        fn eq(&self, _other: &()) -> bool { true }\n        #[inline]\n        fn ne(&self, _other: &()) -> bool { false }\n    }\n\n    partial_eq_impl! {\n        bool char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64\n    }\n\n    macro_rules! eq_impl {\n        ($($t:ty)*) => ($(\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl Eq for $t {}\n        )*)\n    }\n\n    eq_impl! { () bool char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n    macro_rules! partial_ord_impl {\n        ($($t:ty)*) => ($(\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl PartialOrd for $t {\n                #[inline]\n                fn partial_cmp(&self, other: &$t) -> Option<Ordering> {\n                    match (self <= other, self >= other) {\n                        (false, false) => None,\n                        (false, true) => Some(Greater),\n                        (true, false) => Some(Less),\n                        (true, true) => Some(Equal),\n                    }\n                }\n                #[inline]\n                fn lt(&self, other: &$t) -> bool { (*self) < (*other) }\n                #[inline]\n                fn le(&self, other: &$t) -> bool { (*self) <= (*other) }\n                #[inline]\n                fn ge(&self, other: &$t) -> bool { (*self) >= (*other) }\n                #[inline]\n                fn gt(&self, other: &$t) -> bool { (*self) > (*other) }\n            }\n        )*)\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl PartialOrd for () {\n        #[inline]\n        fn partial_cmp(&self, _: &()) -> Option<Ordering> {\n            Some(Equal)\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl PartialOrd for bool {\n        #[inline]\n        fn partial_cmp(&self, other: &bool) -> Option<Ordering> {\n            (*self as u8).partial_cmp(&(*other as u8))\n        }\n    }\n\n    partial_ord_impl! { f32 f64 }\n\n    macro_rules! ord_impl {\n        ($($t:ty)*) => ($(\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl PartialOrd for $t {\n                #[inline]\n                fn partial_cmp(&self, other: &$t) -> Option<Ordering> {\n                    Some(self.cmp(other))\n                }\n                #[inline]\n                fn lt(&self, other: &$t) -> bool { (*self) < (*other) }\n                #[inline]\n                fn le(&self, other: &$t) -> bool { (*self) <= (*other) }\n                #[inline]\n                fn ge(&self, other: &$t) -> bool { (*self) >= (*other) }\n                #[inline]\n                fn gt(&self, other: &$t) -> bool { (*self) > (*other) }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl Ord for $t {\n                #[inline]\n                fn cmp(&self, other: &$t) -> Ordering {\n                    if *self == *other { Equal }\n                    else if *self < *other { Less }\n                    else { Greater }\n                }\n            }\n        )*)\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl Ord for () {\n        #[inline]\n        fn cmp(&self, _other: &()) -> Ordering { Equal }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl Ord for bool {\n        #[inline]\n        fn cmp(&self, other: &bool) -> Ordering {\n            (*self as u8).cmp(&(*other as u8))\n        }\n    }\n\n    ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n    #[unstable(feature = \"never_type\", issue = \"35121\")]\n    impl PartialEq for ! {\n        fn eq(&self, _: &!) -> bool {\n            *self\n        }\n    }\n\n    #[unstable(feature = \"never_type\", issue = \"35121\")]\n    impl Eq for ! {}\n\n    #[unstable(feature = \"never_type\", issue = \"35121\")]\n    impl PartialOrd for ! {\n        fn partial_cmp(&self, _: &!) -> Option<Ordering> {\n            *self\n        }\n    }\n\n    #[unstable(feature = \"never_type\", issue = \"35121\")]\n    impl Ord for ! {\n        fn cmp(&self, _: &!) -> Ordering {\n            *self\n        }\n    }\n\n    // & pointers\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a A where A: PartialEq<B> {\n        #[inline]\n        fn eq(&self, other: & &'b B) -> bool { PartialEq::eq(*self, *other) }\n        #[inline]\n        fn ne(&self, other: & &'b B) -> bool { PartialEq::ne(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b B> for &'a A where A: PartialOrd<B> {\n        #[inline]\n        fn partial_cmp(&self, other: &&'b B) -> Option<Ordering> {\n            PartialOrd::partial_cmp(*self, *other)\n        }\n        #[inline]\n        fn lt(&self, other: & &'b B) -> bool { PartialOrd::lt(*self, *other) }\n        #[inline]\n        fn le(&self, other: & &'b B) -> bool { PartialOrd::le(*self, *other) }\n        #[inline]\n        fn ge(&self, other: & &'b B) -> bool { PartialOrd::ge(*self, *other) }\n        #[inline]\n        fn gt(&self, other: & &'b B) -> bool { PartialOrd::gt(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A: ?Sized> Ord for &A where A: Ord {\n        #[inline]\n        fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A: ?Sized> Eq for &A where A: Eq {}\n\n    // &mut pointers\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a mut A where A: PartialEq<B> {\n        #[inline]\n        fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }\n        #[inline]\n        fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialOrd<&'b mut B> for &'a mut A where A: PartialOrd<B> {\n        #[inline]\n        fn partial_cmp(&self, other: &&'b mut B) -> Option<Ordering> {\n            PartialOrd::partial_cmp(*self, *other)\n        }\n        #[inline]\n        fn lt(&self, other: &&'b mut B) -> bool { PartialOrd::lt(*self, *other) }\n        #[inline]\n        fn le(&self, other: &&'b mut B) -> bool { PartialOrd::le(*self, *other) }\n        #[inline]\n        fn ge(&self, other: &&'b mut B) -> bool { PartialOrd::ge(*self, *other) }\n        #[inline]\n        fn gt(&self, other: &&'b mut B) -> bool { PartialOrd::gt(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A: ?Sized> Ord for &mut A where A: Ord {\n        #[inline]\n        fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(*self, *other) }\n    }\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A: ?Sized> Eq for &mut A where A: Eq {}\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b mut B> for &'a A where A: PartialEq<B> {\n        #[inline]\n        fn eq(&self, other: &&'b mut B) -> bool { PartialEq::eq(*self, *other) }\n        #[inline]\n        fn ne(&self, other: &&'b mut B) -> bool { PartialEq::ne(*self, *other) }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<'a, 'b, A: ?Sized, B: ?Sized> PartialEq<&'b B> for &'a mut A where A: PartialEq<B> {\n        #[inline]\n        fn eq(&self, other: &&'b B) -> bool { PartialEq::eq(*self, *other) }\n        #[inline]\n        fn ne(&self, other: &&'b B) -> bool { PartialEq::ne(*self, *other) }\n    }\n}\n","// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! This module implements the `Any` trait, which enables dynamic typing\n//! of any `'static` type through runtime reflection.\n//!\n//! `Any` itself can be used to get a `TypeId`, and has more features when used\n//! as a trait object. As `&Any` (a borrowed trait object), it has the `is` and\n//! `downcast_ref` methods, to test if the contained value is of a given type,\n//! and to get a reference to the inner value as a type. As `&mut Any`, there\n//! is also the `downcast_mut` method, for getting a mutable reference to the\n//! inner value. `Box<Any>` adds the `downcast` method, which attempts to\n//! convert to a `Box<T>`. See the [`Box`] documentation for the full details.\n//!\n//! Note that &Any is limited to testing whether a value is of a specified\n//! concrete type, and cannot be used to test whether a type implements a trait.\n//!\n//! [`Box`]: ../../std/boxed/struct.Box.html\n//!\n//! # Examples\n//!\n//! Consider a situation where we want to log out a value passed to a function.\n//! We know the value we're working on implements Debug, but we don't know its\n//! concrete type.  We want to give special treatment to certain types: in this\n//! case printing out the length of String values prior to their value.\n//! We don't know the concrete type of our value at compile time, so we need to\n//! use runtime reflection instead.\n//!\n//! ```rust\n//! use std::fmt::Debug;\n//! use std::any::Any;\n//!\n//! // Logger function for any type that implements Debug.\n//! fn log<T: Any + Debug>(value: &T) {\n//!     let value_any = value as &Any;\n//!\n//!     // try to convert our value to a String.  If successful, we want to\n//!     // output the String's length as well as its value.  If not, it's a\n//!     // different type: just print it out unadorned.\n//!     match value_any.downcast_ref::<String>() {\n//!         Some(as_string) => {\n//!             println!(\"String ({}): {}\", as_string.len(), as_string);\n//!         }\n//!         None => {\n//!             println!(\"{:?}\", value);\n//!         }\n//!     }\n//! }\n//!\n//! // This function wants to log its parameter out prior to doing work with it.\n//! fn do_work<T: Any + Debug>(value: &T) {\n//!     log(value);\n//!     // ...do some other work\n//! }\n//!\n//! fn main() {\n//!     let my_string = \"Hello World\".to_string();\n//!     do_work(&my_string);\n//!\n//!     let my_i8: i8 = 100;\n//!     do_work(&my_i8);\n//! }\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse fmt;\nuse intrinsics;\n\n///////////////////////////////////////////////////////////////////////////////\n// Any trait\n///////////////////////////////////////////////////////////////////////////////\n\n/// A type to emulate dynamic typing.\n///\n/// Most types implement `Any`. However, any type which contains a non-`'static` reference does not.\n/// See the [module-level documentation][mod] for more details.\n///\n/// [mod]: index.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Any: 'static {\n    /// Gets the `TypeId` of `self`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(get_type_id)]\n    ///\n    /// use std::any::{Any, TypeId};\n    ///\n    /// fn is_string(s: &Any) -> bool {\n    ///     TypeId::of::<String>() == s.get_type_id()\n    /// }\n    ///\n    /// fn main() {\n    ///     assert_eq!(is_string(&0), false);\n    ///     assert_eq!(is_string(&\"cookie monster\".to_string()), true);\n    /// }\n    /// ```\n    #[unstable(feature = \"get_type_id\",\n               reason = \"this method will likely be replaced by an associated static\",\n               issue = \"27745\")]\n    fn get_type_id(&self) -> TypeId;\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: 'static + ?Sized > Any for T {\n    fn get_type_id(&self) -> TypeId { TypeId::of::<T>() }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// Extension methods for Any trait objects.\n///////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for dyn Any {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Any\")\n    }\n}\n\n// Ensure that the result of e.g. joining a thread can be printed and\n// hence used with `unwrap`. May eventually no longer be needed if\n// dispatch works with upcasting.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for dyn Any + Send {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Any\")\n    }\n}\n\n#[stable(feature = \"any_send_sync_methods\", since = \"1.28.0\")]\nimpl fmt::Debug for dyn Any + Send + Sync {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Any\")\n    }\n}\n\nimpl dyn Any {\n    /// Returns `true` if the boxed type is the same as `T`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn is_string(s: &Any) {\n    ///     if s.is::<String>() {\n    ///         println!(\"It's a string!\");\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     is_string(&0);\n    ///     is_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is<T: Any>(&self) -> bool {\n        // Get TypeId of the type this function is instantiated with\n        let t = TypeId::of::<T>();\n\n        // Get TypeId of the type in the trait object\n        let boxed = self.get_type_id();\n\n        // Compare both TypeIds on equality\n        t == boxed\n    }\n\n    /// Returns some reference to the boxed value if it is of type `T`, or\n    /// `None` if it isn't.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn print_if_string(s: &Any) {\n    ///     if let Some(string) = s.downcast_ref::<String>() {\n    ///         println!(\"It's a string({}): '{}'\", string.len(), string);\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     print_if_string(&0);\n    ///     print_if_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Any>(&self) -> Option<&T> {\n        if self.is::<T>() {\n            unsafe {\n                Some(&*(self as *const dyn Any as *const T))\n            }\n        } else {\n            None\n        }\n    }\n\n    /// Returns some mutable reference to the boxed value if it is of type `T`, or\n    /// `None` if it isn't.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn modify_if_u32(s: &mut Any) {\n    ///     if let Some(num) = s.downcast_mut::<u32>() {\n    ///         *num = 42;\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let mut x = 10u32;\n    ///     let mut s = \"starlord\".to_string();\n    ///\n    ///     modify_if_u32(&mut x);\n    ///     modify_if_u32(&mut s);\n    ///\n    ///     assert_eq!(x, 42);\n    ///     assert_eq!(&s, \"starlord\");\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {\n        if self.is::<T>() {\n            unsafe {\n                Some(&mut *(self as *mut dyn Any as *mut T))\n            }\n        } else {\n            None\n        }\n    }\n}\n\nimpl dyn Any+Send {\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn is_string(s: &(Any + Send)) {\n    ///     if s.is::<String>() {\n    ///         println!(\"It's a string!\");\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     is_string(&0);\n    ///     is_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is<T: Any>(&self) -> bool {\n        Any::is::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn print_if_string(s: &(Any + Send)) {\n    ///     if let Some(string) = s.downcast_ref::<String>() {\n    ///         println!(\"It's a string({}): '{}'\", string.len(), string);\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     print_if_string(&0);\n    ///     print_if_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Any>(&self) -> Option<&T> {\n        Any::downcast_ref::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn modify_if_u32(s: &mut (Any + Send)) {\n    ///     if let Some(num) = s.downcast_mut::<u32>() {\n    ///         *num = 42;\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let mut x = 10u32;\n    ///     let mut s = \"starlord\".to_string();\n    ///\n    ///     modify_if_u32(&mut x);\n    ///     modify_if_u32(&mut s);\n    ///\n    ///     assert_eq!(x, 42);\n    ///     assert_eq!(&s, \"starlord\");\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {\n        Any::downcast_mut::<T>(self)\n    }\n}\n\nimpl dyn Any+Send+Sync {\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn is_string(s: &(Any + Send + Sync)) {\n    ///     if s.is::<String>() {\n    ///         println!(\"It's a string!\");\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     is_string(&0);\n    ///     is_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"any_send_sync_methods\", since = \"1.28.0\")]\n    #[inline]\n    pub fn is<T: Any>(&self) -> bool {\n        Any::is::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn print_if_string(s: &(Any + Send + Sync)) {\n    ///     if let Some(string) = s.downcast_ref::<String>() {\n    ///         println!(\"It's a string({}): '{}'\", string.len(), string);\n    ///     } else {\n    ///         println!(\"Not a string...\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     print_if_string(&0);\n    ///     print_if_string(&\"cookie monster\".to_string());\n    /// }\n    /// ```\n    #[stable(feature = \"any_send_sync_methods\", since = \"1.28.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Any>(&self) -> Option<&T> {\n        Any::downcast_ref::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn modify_if_u32(s: &mut (Any + Send + Sync)) {\n    ///     if let Some(num) = s.downcast_mut::<u32>() {\n    ///         *num = 42;\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let mut x = 10u32;\n    ///     let mut s = \"starlord\".to_string();\n    ///\n    ///     modify_if_u32(&mut x);\n    ///     modify_if_u32(&mut s);\n    ///\n    ///     assert_eq!(x, 42);\n    ///     assert_eq!(&s, \"starlord\");\n    /// }\n    /// ```\n    #[stable(feature = \"any_send_sync_methods\", since = \"1.28.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {\n        Any::downcast_mut::<T>(self)\n    }\n}\n\n///////////////////////////////////////////////////////////////////////////////\n// TypeID and its methods\n///////////////////////////////////////////////////////////////////////////////\n\n/// A `TypeId` represents a globally unique identifier for a type.\n///\n/// Each `TypeId` is an opaque object which does not allow inspection of what's\n/// inside but does allow basic operations such as cloning, comparison,\n/// printing, and showing.\n///\n/// A `TypeId` is currently only available for types which ascribe to `'static`,\n/// but this limitation may be removed in the future.\n///\n/// While `TypeId` implements `Hash`, `PartialOrd`, and `Ord`, it is worth\n/// noting that the hashes and ordering will vary between Rust releases. Beware\n/// of relying on them inside of your code!\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct TypeId {\n    t: u64,\n}\n\nimpl TypeId {\n    /// Returns the `TypeId` of the type this generic function has been\n    /// instantiated with.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::{Any, TypeId};\n    ///\n    /// fn is_string<T: ?Sized + Any>(_s: &T) -> bool {\n    ///     TypeId::of::<String>() == TypeId::of::<T>()\n    /// }\n    ///\n    /// fn main() {\n    ///     assert_eq!(is_string(&0), false);\n    ///     assert_eq!(is_string(&\"cookie monster\".to_string()), true);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature=\"const_type_id\")]\n    pub const fn of<T: ?Sized + 'static>() -> TypeId {\n        TypeId {\n            t: unsafe { intrinsics::type_id::<T>() },\n        }\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! impl char {}\n\nuse slice;\nuse str::from_utf8_unchecked_mut;\nuse super::*;\nuse unicode::printable::is_printable;\nuse unicode::tables::{conversions, derived_property, general_category, property};\n\n#[lang = \"char\"]\nimpl char {\n    /// Checks if a `char` is a digit in the given radix.\n    ///\n    /// A 'radix' here is sometimes also called a 'base'. A radix of two\n    /// indicates a binary number, a radix of ten, decimal, and a radix of\n    /// sixteen, hexadecimal, to give some common values. Arbitrary\n    /// radices are supported.\n    ///\n    /// Compared to `is_numeric()`, this function only recognizes the characters\n    /// `0-9`, `a-z` and `A-Z`.\n    ///\n    /// 'Digit' is defined to be only the following characters:\n    ///\n    /// * `0-9`\n    /// * `a-z`\n    /// * `A-Z`\n    ///\n    /// For a more comprehensive understanding of 'digit', see [`is_numeric`][is_numeric].\n    ///\n    /// [is_numeric]: #method.is_numeric\n    ///\n    /// # Panics\n    ///\n    /// Panics if given a radix larger than 36.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!('1'.is_digit(10));\n    /// assert!('f'.is_digit(16));\n    /// assert!(!'f'.is_digit(10));\n    /// ```\n    ///\n    /// Passing a large radix, causing a panic:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(|| {\n    ///     // this panics\n    ///     '1'.is_digit(37);\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_digit(self, radix: u32) -> bool {\n        self.to_digit(radix).is_some()\n    }\n\n    /// Converts a `char` to a digit in the given radix.\n    ///\n    /// A 'radix' here is sometimes also called a 'base'. A radix of two\n    /// indicates a binary number, a radix of ten, decimal, and a radix of\n    /// sixteen, hexadecimal, to give some common values. Arbitrary\n    /// radices are supported.\n    ///\n    /// 'Digit' is defined to be only the following characters:\n    ///\n    /// * `0-9`\n    /// * `a-z`\n    /// * `A-Z`\n    ///\n    /// # Errors\n    ///\n    /// Returns `None` if the `char` does not refer to a digit in the given radix.\n    ///\n    /// # Panics\n    ///\n    /// Panics if given a radix larger than 36.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert_eq!('1'.to_digit(10), Some(1));\n    /// assert_eq!('f'.to_digit(16), Some(15));\n    /// ```\n    ///\n    /// Passing a non-digit results in failure:\n    ///\n    /// ```\n    /// assert_eq!('f'.to_digit(10), None);\n    /// assert_eq!('z'.to_digit(16), None);\n    /// ```\n    ///\n    /// Passing a large radix, causing a panic:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(|| {\n    ///     '1'.to_digit(37);\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_digit(self, radix: u32) -> Option<u32> {\n        if radix > 36 {\n            panic!(\"to_digit: radix is too high (maximum 36)\");\n        }\n        let val = match self {\n          '0' ..= '9' => self as u32 - '0' as u32,\n          'a' ..= 'z' => self as u32 - 'a' as u32 + 10,\n          'A' ..= 'Z' => self as u32 - 'A' as u32 + 10,\n          _ => return None,\n        };\n        if val < radix { Some(val) }\n        else { None }\n    }\n\n    /// Returns an iterator that yields the hexadecimal Unicode escape of a\n    /// character as `char`s.\n    ///\n    /// This will escape characters with the Rust syntax of the form\n    /// `\\u{NNNNNN}` where `NNNNNN` is a hexadecimal representation.\n    ///\n    /// # Examples\n    ///\n    /// As an iterator:\n    ///\n    /// ```\n    /// for c in '\u2764'.escape_unicode() {\n    ///     print!(\"{}\", c);\n    /// }\n    /// println!();\n    /// ```\n    ///\n    /// Using `println!` directly:\n    ///\n    /// ```\n    /// println!(\"{}\", '\u2764'.escape_unicode());\n    /// ```\n    ///\n    /// Both are equivalent to:\n    ///\n    /// ```\n    /// println!(\"\\\\u{{2764}}\");\n    /// ```\n    ///\n    /// Using `to_string`:\n    ///\n    /// ```\n    /// assert_eq!('\u2764'.escape_unicode().to_string(), \"\\\\u{2764}\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn escape_unicode(self) -> EscapeUnicode {\n        let c = self as u32;\n\n        // or-ing 1 ensures that for c==0 the code computes that one\n        // digit should be printed and (which is the same) avoids the\n        // (31 - 32) underflow\n        let msb = 31 - (c | 1).leading_zeros();\n\n        // the index of the most significant hex digit\n        let ms_hex_digit = msb / 4;\n        EscapeUnicode {\n            c: self,\n            state: EscapeUnicodeState::Backslash,\n            hex_digit_idx: ms_hex_digit as usize,\n        }\n    }\n\n    /// An extended version of `escape_debug` that optionally permits escaping\n    /// Extended Grapheme codepoints. This allows us to format characters like\n    /// nonspacing marks better when they're at the start of a string.\n    #[doc(hidden)]\n    #[unstable(feature = \"str_internals\", issue = \"0\")]\n    #[inline]\n    pub fn escape_debug_ext(self, escape_grapheme_extended: bool) -> EscapeDebug {\n        let init_state = match self {\n            '\\t' => EscapeDefaultState::Backslash('t'),\n            '\\r' => EscapeDefaultState::Backslash('r'),\n            '\\n' => EscapeDefaultState::Backslash('n'),\n            '\\\\' | '\\'' | '\"' => EscapeDefaultState::Backslash(self),\n            _ if escape_grapheme_extended && self.is_grapheme_extended() => {\n                EscapeDefaultState::Unicode(self.escape_unicode())\n            }\n            _ if is_printable(self) => EscapeDefaultState::Char(self),\n            _ => EscapeDefaultState::Unicode(self.escape_unicode()),\n        };\n        EscapeDebug(EscapeDefault { state: init_state })\n    }\n\n    /// Returns an iterator that yields the literal escape code of a character\n    /// as `char`s.\n    ///\n    /// This will escape the characters similar to the `Debug` implementations\n    /// of `str` or `char`.\n    ///\n    /// # Examples\n    ///\n    /// As an iterator:\n    ///\n    /// ```\n    /// for c in '\\n'.escape_debug() {\n    ///     print!(\"{}\", c);\n    /// }\n    /// println!();\n    /// ```\n    ///\n    /// Using `println!` directly:\n    ///\n    /// ```\n    /// println!(\"{}\", '\\n'.escape_debug());\n    /// ```\n    ///\n    /// Both are equivalent to:\n    ///\n    /// ```\n    /// println!(\"\\\\n\");\n    /// ```\n    ///\n    /// Using `to_string`:\n    ///\n    /// ```\n    /// assert_eq!('\\n'.escape_debug().to_string(), \"\\\\n\");\n    /// ```\n    #[stable(feature = \"char_escape_debug\", since = \"1.20.0\")]\n    #[inline]\n    pub fn escape_debug(self) -> EscapeDebug {\n        self.escape_debug_ext(true)\n    }\n\n    /// Returns an iterator that yields the literal escape code of a character\n    /// as `char`s.\n    ///\n    /// The default is chosen with a bias toward producing literals that are\n    /// legal in a variety of languages, including C++11 and similar C-family\n    /// languages. The exact rules are:\n    ///\n    /// * Tab is escaped as `\\t`.\n    /// * Carriage return is escaped as `\\r`.\n    /// * Line feed is escaped as `\\n`.\n    /// * Single quote is escaped as `\\'`.\n    /// * Double quote is escaped as `\\\"`.\n    /// * Backslash is escaped as `\\\\`.\n    /// * Any character in the 'printable ASCII' range `0x20` .. `0x7e`\n    ///   inclusive is not escaped.\n    /// * All other characters are given hexadecimal Unicode escapes; see\n    ///   [`escape_unicode`][escape_unicode].\n    ///\n    /// [escape_unicode]: #method.escape_unicode\n    ///\n    /// # Examples\n    ///\n    /// As an iterator:\n    ///\n    /// ```\n    /// for c in '\"'.escape_default() {\n    ///     print!(\"{}\", c);\n    /// }\n    /// println!();\n    /// ```\n    ///\n    /// Using `println!` directly:\n    ///\n    /// ```\n    /// println!(\"{}\", '\"'.escape_default());\n    /// ```\n    ///\n    ///\n    /// Both are equivalent to:\n    ///\n    /// ```\n    /// println!(\"\\\\\\\"\");\n    /// ```\n    ///\n    /// Using `to_string`:\n    ///\n    /// ```\n    /// assert_eq!('\"'.escape_default().to_string(), \"\\\\\\\"\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn escape_default(self) -> EscapeDefault {\n        let init_state = match self {\n            '\\t' => EscapeDefaultState::Backslash('t'),\n            '\\r' => EscapeDefaultState::Backslash('r'),\n            '\\n' => EscapeDefaultState::Backslash('n'),\n            '\\\\' | '\\'' | '\"' => EscapeDefaultState::Backslash(self),\n            '\\x20' ..= '\\x7e' => EscapeDefaultState::Char(self),\n            _ => EscapeDefaultState::Unicode(self.escape_unicode())\n        };\n        EscapeDefault { state: init_state }\n    }\n\n    /// Returns the number of bytes this `char` would need if encoded in UTF-8.\n    ///\n    /// That number of bytes is always between 1 and 4, inclusive.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let len = 'A'.len_utf8();\n    /// assert_eq!(len, 1);\n    ///\n    /// let len = '\u00df'.len_utf8();\n    /// assert_eq!(len, 2);\n    ///\n    /// let len = '\u211d'.len_utf8();\n    /// assert_eq!(len, 3);\n    ///\n    /// let len = '\ud83d\udca3'.len_utf8();\n    /// assert_eq!(len, 4);\n    /// ```\n    ///\n    /// The `&str` type guarantees that its contents are UTF-8, and so we can compare the length it\n    /// would take if each code point was represented as a `char` vs in the `&str` itself:\n    ///\n    /// ```\n    /// // as chars\n    /// let eastern = '\u6771';\n    /// let capitol = '\u4eac';\n    ///\n    /// // both can be represented as three bytes\n    /// assert_eq!(3, eastern.len_utf8());\n    /// assert_eq!(3, capitol.len_utf8());\n    ///\n    /// // as a &str, these two are encoded in UTF-8\n    /// let tokyo = \"\u6771\u4eac\";\n    ///\n    /// let len = eastern.len_utf8() + capitol.len_utf8();\n    ///\n    /// // we can see that they take six bytes total...\n    /// assert_eq!(6, tokyo.len());\n    ///\n    /// // ... just like the &str\n    /// assert_eq!(len, tokyo.len());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn len_utf8(self) -> usize {\n        let code = self as u32;\n        if code < MAX_ONE_B {\n            1\n        } else if code < MAX_TWO_B {\n            2\n        } else if code < MAX_THREE_B {\n            3\n        } else {\n            4\n        }\n    }\n\n    /// Returns the number of 16-bit code units this `char` would need if\n    /// encoded in UTF-16.\n    ///\n    /// See the documentation for [`len_utf8`] for more explanation of this\n    /// concept. This function is a mirror, but for UTF-16 instead of UTF-8.\n    ///\n    /// [`len_utf8`]: #method.len_utf8\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let n = '\u00df'.len_utf16();\n    /// assert_eq!(n, 1);\n    ///\n    /// let len = '\ud83d\udca3'.len_utf16();\n    /// assert_eq!(len, 2);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn len_utf16(self) -> usize {\n        let ch = self as u32;\n        if (ch & 0xFFFF) == ch { 1 } else { 2 }\n    }\n\n    /// Encodes this character as UTF-8 into the provided byte buffer,\n    /// and then returns the subslice of the buffer that contains the encoded character.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the buffer is not large enough.\n    /// A buffer of length four is large enough to encode any `char`.\n    ///\n    /// # Examples\n    ///\n    /// In both of these examples, '\u00df' takes two bytes to encode.\n    ///\n    /// ```\n    /// let mut b = [0; 2];\n    ///\n    /// let result = '\u00df'.encode_utf8(&mut b);\n    ///\n    /// assert_eq!(result, \"\u00df\");\n    ///\n    /// assert_eq!(result.len(), 2);\n    /// ```\n    ///\n    /// A buffer that's too small:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(|| {\n    ///     let mut b = [0; 1];\n    ///\n    ///     // this panics\n    ///    '\u00df'.encode_utf8(&mut b);\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")]\n    #[inline]\n    pub fn encode_utf8(self, dst: &mut [u8]) -> &mut str {\n        let code = self as u32;\n        unsafe {\n            let len =\n            if code < MAX_ONE_B && !dst.is_empty() {\n                *dst.get_unchecked_mut(0) = code as u8;\n                1\n            } else if code < MAX_TWO_B && dst.len() >= 2 {\n                *dst.get_unchecked_mut(0) = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;\n                *dst.get_unchecked_mut(1) = (code & 0x3F) as u8 | TAG_CONT;\n                2\n            } else if code < MAX_THREE_B && dst.len() >= 3  {\n                *dst.get_unchecked_mut(0) = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;\n                *dst.get_unchecked_mut(1) = (code >>  6 & 0x3F) as u8 | TAG_CONT;\n                *dst.get_unchecked_mut(2) = (code & 0x3F) as u8 | TAG_CONT;\n                3\n            } else if dst.len() >= 4 {\n                *dst.get_unchecked_mut(0) = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;\n                *dst.get_unchecked_mut(1) = (code >> 12 & 0x3F) as u8 | TAG_CONT;\n                *dst.get_unchecked_mut(2) = (code >>  6 & 0x3F) as u8 | TAG_CONT;\n                *dst.get_unchecked_mut(3) = (code & 0x3F) as u8 | TAG_CONT;\n                4\n            } else {\n                panic!(\"encode_utf8: need {} bytes to encode U+{:X}, but the buffer has {}\",\n                    from_u32_unchecked(code).len_utf8(),\n                    code,\n                    dst.len())\n            };\n            from_utf8_unchecked_mut(dst.get_unchecked_mut(..len))\n        }\n    }\n\n    /// Encodes this character as UTF-16 into the provided `u16` buffer,\n    /// and then returns the subslice of the buffer that contains the encoded character.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the buffer is not large enough.\n    /// A buffer of length 2 is large enough to encode any `char`.\n    ///\n    /// # Examples\n    ///\n    /// In both of these examples, '\ud835\udd4a' takes two `u16`s to encode.\n    ///\n    /// ```\n    /// let mut b = [0; 2];\n    ///\n    /// let result = '\ud835\udd4a'.encode_utf16(&mut b);\n    ///\n    /// assert_eq!(result.len(), 2);\n    /// ```\n    ///\n    /// A buffer that's too small:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(|| {\n    ///     let mut b = [0; 1];\n    ///\n    ///     // this panics\n    ///     '\ud835\udd4a'.encode_utf16(&mut b);\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"unicode_encode_char\", since = \"1.15.0\")]\n    #[inline]\n    pub fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16] {\n        let mut code = self as u32;\n        unsafe {\n            if (code & 0xFFFF) == code && !dst.is_empty() {\n                // The BMP falls through (assuming non-surrogate, as it should)\n                *dst.get_unchecked_mut(0) = code as u16;\n                slice::from_raw_parts_mut(dst.as_mut_ptr(), 1)\n            } else if dst.len() >= 2 {\n                // Supplementary planes break into surrogates.\n                code -= 0x1_0000;\n                *dst.get_unchecked_mut(0) = 0xD800 | ((code >> 10) as u16);\n                *dst.get_unchecked_mut(1) = 0xDC00 | ((code as u16) & 0x3FF);\n                slice::from_raw_parts_mut(dst.as_mut_ptr(), 2)\n            } else {\n                panic!(\"encode_utf16: need {} units to encode U+{:X}, but the buffer has {}\",\n                    from_u32_unchecked(code).len_utf16(),\n                    code,\n                    dst.len())\n            }\n        }\n    }\n\n    /// Returns true if this `char` is an alphabetic code point, and false if not.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!('a'.is_alphabetic());\n    /// assert!('\u4eac'.is_alphabetic());\n    ///\n    /// let c = '\ud83d\udc9d';\n    /// // love is many things, but it is not alphabetic\n    /// assert!(!c.is_alphabetic());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_alphabetic(self) -> bool {\n        match self {\n            'a'..='z' | 'A'..='Z' => true,\n            c if c > '\\x7f' => derived_property::Alphabetic(c),\n            _ => false,\n        }\n    }\n\n    /// Returns true if this `char` satisfies the 'XID_Start' Unicode property, and false\n    /// otherwise.\n    ///\n    /// 'XID_Start' is a Unicode Derived Property specified in\n    /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),\n    /// mostly similar to `ID_Start` but modified for closure under `NFKx`.\n    #[unstable(feature = \"rustc_private\",\n               reason = \"mainly needed for compiler internals\",\n               issue = \"27812\")]\n    #[inline]\n    pub fn is_xid_start(self) -> bool {\n        derived_property::XID_Start(self)\n    }\n\n    /// Returns true if this `char` satisfies the 'XID_Continue' Unicode property, and false\n    /// otherwise.\n    ///\n    /// 'XID_Continue' is a Unicode Derived Property specified in\n    /// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),\n    /// mostly similar to 'ID_Continue' but modified for closure under NFKx.\n    #[unstable(feature = \"rustc_private\",\n               reason = \"mainly needed for compiler internals\",\n               issue = \"27812\")]\n    #[inline]\n    pub fn is_xid_continue(self) -> bool {\n        derived_property::XID_Continue(self)\n    }\n\n    /// Returns true if this `char` is lowercase, and false otherwise.\n    ///\n    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core\n    /// Property `Lowercase`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!('a'.is_lowercase());\n    /// assert!('\u03b4'.is_lowercase());\n    /// assert!(!'A'.is_lowercase());\n    /// assert!(!'\u0394'.is_lowercase());\n    ///\n    /// // The various Chinese scripts do not have case, and so:\n    /// assert!(!'\u4e2d'.is_lowercase());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_lowercase(self) -> bool {\n        match self {\n            'a'..='z' => true,\n            c if c > '\\x7f' => derived_property::Lowercase(c),\n            _ => false,\n        }\n    }\n\n    /// Returns true if this `char` is uppercase, and false otherwise.\n    ///\n    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core\n    /// Property `Uppercase`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!(!'a'.is_uppercase());\n    /// assert!(!'\u03b4'.is_uppercase());\n    /// assert!('A'.is_uppercase());\n    /// assert!('\u0394'.is_uppercase());\n    ///\n    /// // The various Chinese scripts do not have case, and so:\n    /// assert!(!'\u4e2d'.is_uppercase());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_uppercase(self) -> bool {\n        match self {\n            'A'..='Z' => true,\n            c if c > '\\x7f' => derived_property::Uppercase(c),\n            _ => false,\n        }\n    }\n\n    /// Returns true if this `char` is whitespace, and false otherwise.\n    ///\n    /// 'Whitespace' is defined according to the terms of the Unicode Derived Core\n    /// Property `White_Space`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!(' '.is_whitespace());\n    ///\n    /// // a non-breaking space\n    /// assert!('\\u{A0}'.is_whitespace());\n    ///\n    /// assert!(!'\u8d8a'.is_whitespace());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_whitespace(self) -> bool {\n        match self {\n            ' ' | '\\x09'..='\\x0d' => true,\n            c if c > '\\x7f' => property::White_Space(c),\n            _ => false,\n        }\n    }\n\n    /// Returns true if this `char` is alphanumeric, and false otherwise.\n    ///\n    /// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories\n    /// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!('\u0663'.is_alphanumeric());\n    /// assert!('7'.is_alphanumeric());\n    /// assert!('\u09ec'.is_alphanumeric());\n    /// assert!('\u00be'.is_alphanumeric());\n    /// assert!('\u2460'.is_alphanumeric());\n    /// assert!('K'.is_alphanumeric());\n    /// assert!('\u0648'.is_alphanumeric());\n    /// assert!('\u85cf'.is_alphanumeric());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_alphanumeric(self) -> bool {\n        self.is_alphabetic() || self.is_numeric()\n    }\n\n    /// Returns true if this `char` is a control code point, and false otherwise.\n    ///\n    /// 'Control code point' is defined in terms of the Unicode General\n    /// Category `Cc`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // U+009C, STRING TERMINATOR\n    /// assert!('\u009c'.is_control());\n    /// assert!(!'q'.is_control());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_control(self) -> bool {\n        general_category::Cc(self)\n    }\n\n    /// Returns true if this `char` is an extended grapheme character, and false otherwise.\n    ///\n    /// 'Extended grapheme character' is defined in terms of the Unicode Shaping and Rendering\n    /// Category `Grapheme_Extend`.\n    #[inline]\n    pub(crate) fn is_grapheme_extended(self) -> bool {\n        derived_property::Grapheme_Extend(self)\n    }\n\n    /// Returns true if this `char` is numeric, and false otherwise.\n    ///\n    /// 'Numeric'-ness is defined in terms of the Unicode General Categories\n    /// 'Nd', 'Nl', 'No'.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert!('\u0663'.is_numeric());\n    /// assert!('7'.is_numeric());\n    /// assert!('\u09ec'.is_numeric());\n    /// assert!('\u00be'.is_numeric());\n    /// assert!('\u2460'.is_numeric());\n    /// assert!(!'K'.is_numeric());\n    /// assert!(!'\u0648'.is_numeric());\n    /// assert!(!'\u85cf'.is_numeric());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_numeric(self) -> bool {\n        match self {\n            '0'..='9' => true,\n            c if c > '\\x7f' => general_category::N(c),\n            _ => false,\n        }\n    }\n\n    /// Returns an iterator that yields the lowercase equivalent of a `char`\n    /// as one or more `char`s.\n    ///\n    /// If a character does not have a lowercase equivalent, the same character\n    /// will be returned back by the iterator.\n    ///\n    /// This performs complex unconditional mappings with no tailoring: it maps\n    /// one Unicode character to its lowercase equivalent according to the\n    /// [Unicode database] and the additional complex mappings\n    /// [`SpecialCasing.txt`]. Conditional mappings (based on context or\n    /// language) are not considered here.\n    ///\n    /// For a full reference, see [here][reference].\n    ///\n    /// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt\n    ///\n    /// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt\n    ///\n    /// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992\n    ///\n    /// # Examples\n    ///\n    /// As an iterator:\n    ///\n    /// ```\n    /// for c in '\u0130'.to_lowercase() {\n    ///     print!(\"{}\", c);\n    /// }\n    /// println!();\n    /// ```\n    ///\n    /// Using `println!` directly:\n    ///\n    /// ```\n    /// println!(\"{}\", '\u0130'.to_lowercase());\n    /// ```\n    ///\n    /// Both are equivalent to:\n    ///\n    /// ```\n    /// println!(\"i\\u{307}\");\n    /// ```\n    ///\n    /// Using `to_string`:\n    ///\n    /// ```\n    /// assert_eq!('C'.to_lowercase().to_string(), \"c\");\n    ///\n    /// // Sometimes the result is more than one character:\n    /// assert_eq!('\u0130'.to_lowercase().to_string(), \"i\\u{307}\");\n    ///\n    /// // Characters that do not have both uppercase and lowercase\n    /// // convert into themselves.\n    /// assert_eq!('\u5c71'.to_lowercase().to_string(), \"\u5c71\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_lowercase(self) -> ToLowercase {\n        ToLowercase(CaseMappingIter::new(conversions::to_lower(self)))\n    }\n\n    /// Returns an iterator that yields the uppercase equivalent of a `char`\n    /// as one or more `char`s.\n    ///\n    /// If a character does not have an uppercase equivalent, the same character\n    /// will be returned back by the iterator.\n    ///\n    /// This performs complex unconditional mappings with no tailoring: it maps\n    /// one Unicode character to its uppercase equivalent according to the\n    /// [Unicode database] and the additional complex mappings\n    /// [`SpecialCasing.txt`]. Conditional mappings (based on context or\n    /// language) are not considered here.\n    ///\n    /// For a full reference, see [here][reference].\n    ///\n    /// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt\n    ///\n    /// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt\n    ///\n    /// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992\n    ///\n    /// # Examples\n    ///\n    /// As an iterator:\n    ///\n    /// ```\n    /// for c in '\u00df'.to_uppercase() {\n    ///     print!(\"{}\", c);\n    /// }\n    /// println!();\n    /// ```\n    ///\n    /// Using `println!` directly:\n    ///\n    /// ```\n    /// println!(\"{}\", '\u00df'.to_uppercase());\n    /// ```\n    ///\n    /// Both are equivalent to:\n    ///\n    /// ```\n    /// println!(\"SS\");\n    /// ```\n    ///\n    /// Using `to_string`:\n    ///\n    /// ```\n    /// assert_eq!('c'.to_uppercase().to_string(), \"C\");\n    ///\n    /// // Sometimes the result is more than one character:\n    /// assert_eq!('\u00df'.to_uppercase().to_string(), \"SS\");\n    ///\n    /// // Characters that do not have both uppercase and lowercase\n    /// // convert into themselves.\n    /// assert_eq!('\u5c71'.to_uppercase().to_string(), \"\u5c71\");\n    /// ```\n    ///\n    /// # Note on locale\n    ///\n    /// In Turkish, the equivalent of 'i' in Latin has five forms instead of two:\n    ///\n    /// * 'Dotless': I / \u0131, sometimes written \u00ef\n    /// * 'Dotted': \u0130 / i\n    ///\n    /// Note that the lowercase dotted 'i' is the same as the Latin. Therefore:\n    ///\n    /// ```\n    /// let upper_i = 'i'.to_uppercase().to_string();\n    /// ```\n    ///\n    /// The value of `upper_i` here relies on the language of the text: if we're\n    /// in `en-US`, it should be `\"I\"`, but if we're in `tr_TR`, it should\n    /// be `\"\u0130\"`. `to_uppercase()` does not take this into account, and so:\n    ///\n    /// ```\n    /// let upper_i = 'i'.to_uppercase().to_string();\n    ///\n    /// assert_eq!(upper_i, \"I\");\n    /// ```\n    ///\n    /// holds across languages.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_uppercase(self) -> ToUppercase {\n        ToUppercase(CaseMappingIter::new(conversions::to_upper(self)))\n    }\n\n    /// Checks if the value is within the ASCII range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let ascii = 'a';\n    /// let non_ascii = '\u2764';\n    ///\n    /// assert!(ascii.is_ascii());\n    /// assert!(!non_ascii.is_ascii());\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn is_ascii(&self) -> bool {\n        *self as u32 <= 0x7F\n    }\n\n    /// Makes a copy of the value in its ASCII upper case equivalent.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To uppercase the value in-place, use [`make_ascii_uppercase`].\n    ///\n    /// To uppercase ASCII characters in addition to non-ASCII characters, use\n    /// [`to_uppercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let ascii = 'a';\n    /// let non_ascii = '\u2764';\n    ///\n    /// assert_eq!('A', ascii.to_ascii_uppercase());\n    /// assert_eq!('\u2764', non_ascii.to_ascii_uppercase());\n    /// ```\n    ///\n    /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase\n    /// [`to_uppercase`]: #method.to_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_uppercase(&self) -> char {\n        if self.is_ascii() {\n            (*self as u8).to_ascii_uppercase() as char\n        } else {\n            *self\n        }\n    }\n\n    /// Makes a copy of the value in its ASCII lower case equivalent.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To lowercase the value in-place, use [`make_ascii_lowercase`].\n    ///\n    /// To lowercase ASCII characters in addition to non-ASCII characters, use\n    /// [`to_lowercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let ascii = 'A';\n    /// let non_ascii = '\u2764';\n    ///\n    /// assert_eq!('a', ascii.to_ascii_lowercase());\n    /// assert_eq!('\u2764', non_ascii.to_ascii_lowercase());\n    /// ```\n    ///\n    /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase\n    /// [`to_lowercase`]: #method.to_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_lowercase(&self) -> char {\n        if self.is_ascii() {\n            (*self as u8).to_ascii_lowercase() as char\n        } else {\n            *self\n        }\n    }\n\n    /// Checks that two values are an ASCII case-insensitive match.\n    ///\n    /// Equivalent to `to_ascii_lowercase(a) == to_ascii_lowercase(b)`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let upper_a = 'A';\n    /// let lower_a = 'a';\n    /// let lower_z = 'z';\n    ///\n    /// assert!(upper_a.eq_ignore_ascii_case(&lower_a));\n    /// assert!(upper_a.eq_ignore_ascii_case(&upper_a));\n    /// assert!(!upper_a.eq_ignore_ascii_case(&lower_z));\n    /// ```\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn eq_ignore_ascii_case(&self, other: &char) -> bool {\n        self.to_ascii_lowercase() == other.to_ascii_lowercase()\n    }\n\n    /// Converts this type to its ASCII upper case equivalent in-place.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new uppercased value without modifying the existing one, use\n    /// [`to_ascii_uppercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut ascii = 'a';\n    ///\n    /// ascii.make_ascii_uppercase();\n    ///\n    /// assert_eq!('A', ascii);\n    /// ```\n    ///\n    /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_uppercase(&mut self) {\n        *self = self.to_ascii_uppercase();\n    }\n\n    /// Converts this type to its ASCII lower case equivalent in-place.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To return a new lowercased value without modifying the existing one, use\n    /// [`to_ascii_lowercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut ascii = 'A';\n    ///\n    /// ascii.make_ascii_lowercase();\n    ///\n    /// assert_eq!('a', ascii);\n    /// ```\n    ///\n    /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn make_ascii_lowercase(&mut self) {\n        *self = self.to_ascii_lowercase();\n    }\n\n    /// Checks if the value is an ASCII alphabetic character:\n    ///\n    /// - U+0041 'A' ... U+005A 'Z', or\n    /// - U+0061 'a' ... U+007A 'z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(uppercase_a.is_ascii_alphabetic());\n    /// assert!(uppercase_g.is_ascii_alphabetic());\n    /// assert!(a.is_ascii_alphabetic());\n    /// assert!(g.is_ascii_alphabetic());\n    /// assert!(!zero.is_ascii_alphabetic());\n    /// assert!(!percent.is_ascii_alphabetic());\n    /// assert!(!space.is_ascii_alphabetic());\n    /// assert!(!lf.is_ascii_alphabetic());\n    /// assert!(!esc.is_ascii_alphabetic());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_alphabetic(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_alphabetic()\n    }\n\n    /// Checks if the value is an ASCII uppercase character:\n    /// U+0041 'A' ... U+005A 'Z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(uppercase_a.is_ascii_uppercase());\n    /// assert!(uppercase_g.is_ascii_uppercase());\n    /// assert!(!a.is_ascii_uppercase());\n    /// assert!(!g.is_ascii_uppercase());\n    /// assert!(!zero.is_ascii_uppercase());\n    /// assert!(!percent.is_ascii_uppercase());\n    /// assert!(!space.is_ascii_uppercase());\n    /// assert!(!lf.is_ascii_uppercase());\n    /// assert!(!esc.is_ascii_uppercase());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_uppercase(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_uppercase()\n    }\n\n    /// Checks if the value is an ASCII lowercase character:\n    /// U+0061 'a' ... U+007A 'z'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(!uppercase_a.is_ascii_lowercase());\n    /// assert!(!uppercase_g.is_ascii_lowercase());\n    /// assert!(a.is_ascii_lowercase());\n    /// assert!(g.is_ascii_lowercase());\n    /// assert!(!zero.is_ascii_lowercase());\n    /// assert!(!percent.is_ascii_lowercase());\n    /// assert!(!space.is_ascii_lowercase());\n    /// assert!(!lf.is_ascii_lowercase());\n    /// assert!(!esc.is_ascii_lowercase());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_lowercase(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_lowercase()\n    }\n\n    /// Checks if the value is an ASCII alphanumeric character:\n    ///\n    /// - U+0041 'A' ... U+005A 'Z', or\n    /// - U+0061 'a' ... U+007A 'z', or\n    /// - U+0030 '0' ... U+0039 '9'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(uppercase_a.is_ascii_alphanumeric());\n    /// assert!(uppercase_g.is_ascii_alphanumeric());\n    /// assert!(a.is_ascii_alphanumeric());\n    /// assert!(g.is_ascii_alphanumeric());\n    /// assert!(zero.is_ascii_alphanumeric());\n    /// assert!(!percent.is_ascii_alphanumeric());\n    /// assert!(!space.is_ascii_alphanumeric());\n    /// assert!(!lf.is_ascii_alphanumeric());\n    /// assert!(!esc.is_ascii_alphanumeric());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_alphanumeric(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_alphanumeric()\n    }\n\n    /// Checks if the value is an ASCII decimal digit:\n    /// U+0030 '0' ... U+0039 '9'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(!uppercase_a.is_ascii_digit());\n    /// assert!(!uppercase_g.is_ascii_digit());\n    /// assert!(!a.is_ascii_digit());\n    /// assert!(!g.is_ascii_digit());\n    /// assert!(zero.is_ascii_digit());\n    /// assert!(!percent.is_ascii_digit());\n    /// assert!(!space.is_ascii_digit());\n    /// assert!(!lf.is_ascii_digit());\n    /// assert!(!esc.is_ascii_digit());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_digit(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_digit()\n    }\n\n    /// Checks if the value is an ASCII hexadecimal digit:\n    ///\n    /// - U+0030 '0' ... U+0039 '9', or\n    /// - U+0041 'A' ... U+0046 'F', or\n    /// - U+0061 'a' ... U+0066 'f'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(uppercase_a.is_ascii_hexdigit());\n    /// assert!(!uppercase_g.is_ascii_hexdigit());\n    /// assert!(a.is_ascii_hexdigit());\n    /// assert!(!g.is_ascii_hexdigit());\n    /// assert!(zero.is_ascii_hexdigit());\n    /// assert!(!percent.is_ascii_hexdigit());\n    /// assert!(!space.is_ascii_hexdigit());\n    /// assert!(!lf.is_ascii_hexdigit());\n    /// assert!(!esc.is_ascii_hexdigit());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_hexdigit(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_hexdigit()\n    }\n\n    /// Checks if the value is an ASCII punctuation character:\n    ///\n    /// - U+0021 ... U+002F `! \" # $ % & ' ( ) * + , - . /`, or\n    /// - U+003A ... U+0040 `: ; < = > ? @`, or\n    /// - U+005B ... U+0060 ``[ \\ ] ^ _ ` ``, or\n    /// - U+007B ... U+007E `{ | } ~`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(!uppercase_a.is_ascii_punctuation());\n    /// assert!(!uppercase_g.is_ascii_punctuation());\n    /// assert!(!a.is_ascii_punctuation());\n    /// assert!(!g.is_ascii_punctuation());\n    /// assert!(!zero.is_ascii_punctuation());\n    /// assert!(percent.is_ascii_punctuation());\n    /// assert!(!space.is_ascii_punctuation());\n    /// assert!(!lf.is_ascii_punctuation());\n    /// assert!(!esc.is_ascii_punctuation());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_punctuation(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_punctuation()\n    }\n\n    /// Checks if the value is an ASCII graphic character:\n    /// U+0021 '!' ... U+007E '~'.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(uppercase_a.is_ascii_graphic());\n    /// assert!(uppercase_g.is_ascii_graphic());\n    /// assert!(a.is_ascii_graphic());\n    /// assert!(g.is_ascii_graphic());\n    /// assert!(zero.is_ascii_graphic());\n    /// assert!(percent.is_ascii_graphic());\n    /// assert!(!space.is_ascii_graphic());\n    /// assert!(!lf.is_ascii_graphic());\n    /// assert!(!esc.is_ascii_graphic());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_graphic(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_graphic()\n    }\n\n    /// Checks if the value is an ASCII whitespace character:\n    /// U+0020 SPACE, U+0009 HORIZONTAL TAB, U+000A LINE FEED,\n    /// U+000C FORM FEED, or U+000D CARRIAGE RETURN.\n    ///\n    /// Rust uses the WhatWG Infra Standard's [definition of ASCII\n    /// whitespace][infra-aw]. There are several other definitions in\n    /// wide use. For instance, [the POSIX locale][pct] includes\n    /// U+000B VERTICAL TAB as well as all the above characters,\n    /// but\u2014from the very same specification\u2014[the default rule for\n    /// \"field splitting\" in the Bourne shell][bfs] considers *only*\n    /// SPACE, HORIZONTAL TAB, and LINE FEED as whitespace.\n    ///\n    /// If you are writing a program that will process an existing\n    /// file format, check what that format's definition of whitespace is\n    /// before using this function.\n    ///\n    /// [infra-aw]: https://infra.spec.whatwg.org/#ascii-whitespace\n    /// [pct]: http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_01\n    /// [bfs]: http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_18_06_05\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(!uppercase_a.is_ascii_whitespace());\n    /// assert!(!uppercase_g.is_ascii_whitespace());\n    /// assert!(!a.is_ascii_whitespace());\n    /// assert!(!g.is_ascii_whitespace());\n    /// assert!(!zero.is_ascii_whitespace());\n    /// assert!(!percent.is_ascii_whitespace());\n    /// assert!(space.is_ascii_whitespace());\n    /// assert!(lf.is_ascii_whitespace());\n    /// assert!(!esc.is_ascii_whitespace());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_whitespace(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_whitespace()\n    }\n\n    /// Checks if the value is an ASCII control character:\n    /// U+0000 NUL ... U+001F UNIT SEPARATOR, or U+007F DELETE.\n    /// Note that most ASCII whitespace characters are control\n    /// characters, but SPACE is not.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let uppercase_a = 'A';\n    /// let uppercase_g = 'G';\n    /// let a = 'a';\n    /// let g = 'g';\n    /// let zero = '0';\n    /// let percent = '%';\n    /// let space = ' ';\n    /// let lf = '\\n';\n    /// let esc: char = 0x1b_u8.into();\n    ///\n    /// assert!(!uppercase_a.is_ascii_control());\n    /// assert!(!uppercase_g.is_ascii_control());\n    /// assert!(!a.is_ascii_control());\n    /// assert!(!g.is_ascii_control());\n    /// assert!(!zero.is_ascii_control());\n    /// assert!(!percent.is_ascii_control());\n    /// assert!(!space.is_ascii_control());\n    /// assert!(lf.is_ascii_control());\n    /// assert!(esc.is_ascii_control());\n    /// ```\n    #[stable(feature = \"ascii_ctype_on_intrinsics\", since = \"1.24.0\")]\n    #[inline]\n    pub fn is_ascii_control(&self) -> bool {\n        self.is_ascii() && (*self as u8).is_ascii_control()\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Memory allocation APIs\n//!\n//! In a given program, the standard library has one \u201cglobal\u201d memory allocator\n//! that is used for example by `Box<T>` and `Vec<T>`.\n//!\n//! Currently the default global allocator is unspecified. Libraries, however,\n//! like `cdylib`s and `staticlib`s are guaranteed to use the [`System`] by\n//! default.\n//!\n//! [`System`]: struct.System.html\n//!\n//! # The `#[global_allocator]` attribute\n//!\n//! This attribute allows configuring the choice of global allocator.\n//! You can use this to implement a completely custom global allocator\n//! to route all default allocation requests to a custom object.\n//!\n//! ```rust\n//! use std::alloc::{GlobalAlloc, System, Layout};\n//!\n//! struct MyAllocator;\n//!\n//! unsafe impl GlobalAlloc for MyAllocator {\n//!     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {\n//!         System.alloc(layout)\n//!     }\n//!\n//!     unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {\n//!         System.dealloc(ptr, layout)\n//!     }\n//! }\n//!\n//! #[global_allocator]\n//! static GLOBAL: MyAllocator = MyAllocator;\n//!\n//! fn main() {\n//!     // This `Vec` will allocate memory through `GLOBAL` above\n//!     let mut v = Vec::new();\n//!     v.push(1);\n//! }\n//! ```\n//!\n//! The attribute is used on a `static` item whose type implements the\n//! [`GlobalAlloc`] trait. This type can be provided by an external library:\n//!\n//! [`GlobalAlloc`]: ../../core/alloc/trait.GlobalAlloc.html\n//!\n//! ```rust,ignore (demonstrates crates.io usage)\n//! extern crate jemallocator;\n//!\n//! use jemallocator::Jemalloc;\n//!\n//! #[global_allocator]\n//! static GLOBAL: Jemalloc = Jemalloc;\n//!\n//! fn main() {}\n//! ```\n//!\n//! The `#[global_allocator]` can only be used once in a crate\n//! or its recursive dependencies.\n\n#![stable(feature = \"alloc_module\", since = \"1.28.0\")]\n\nuse core::sync::atomic::{AtomicPtr, Ordering};\nuse core::{mem, ptr};\nuse sys_common::util::dumb_print;\n\n#[stable(feature = \"alloc_module\", since = \"1.28.0\")]\n#[doc(inline)]\npub use alloc_crate::alloc::*;\n\n#[stable(feature = \"alloc_system_type\", since = \"1.28.0\")]\n#[doc(inline)]\npub use alloc_system::System;\n\nstatic HOOK: AtomicPtr<()> = AtomicPtr::new(ptr::null_mut());\n\n/// Registers a custom allocation error hook, replacing any that was previously registered.\n///\n/// The allocation error hook is invoked when an infallible memory allocation fails, before\n/// the runtime aborts. The default hook prints a message to standard error,\n/// but this behavior can be customized with the [`set_alloc_error_hook`] and\n/// [`take_alloc_error_hook`] functions.\n///\n/// The hook is provided with a `Layout` struct which contains information\n/// about the allocation that failed.\n///\n/// The allocation error hook is a global resource.\n#[unstable(feature = \"alloc_error_hook\", issue = \"51245\")]\npub fn set_alloc_error_hook(hook: fn(Layout)) {\n    HOOK.store(hook as *mut (), Ordering::SeqCst);\n}\n\n/// Unregisters the current allocation error hook, returning it.\n///\n/// *See also the function [`set_alloc_error_hook`].*\n///\n/// If no custom hook is registered, the default hook will be returned.\n#[unstable(feature = \"alloc_error_hook\", issue = \"51245\")]\npub fn take_alloc_error_hook() -> fn(Layout) {\n    let hook = HOOK.swap(ptr::null_mut(), Ordering::SeqCst);\n    if hook.is_null() {\n        default_alloc_error_hook\n    } else {\n        unsafe { mem::transmute(hook) }\n    }\n}\n\nfn default_alloc_error_hook(layout: Layout) {\n    dumb_print(format_args!(\"memory allocation of {} bytes failed\", layout.size()));\n}\n\n#[cfg(not(test))]\n#[doc(hidden)]\n#[alloc_error_handler]\n#[unstable(feature = \"alloc_internals\", issue = \"0\")]\npub fn rust_oom(layout: Layout) -> ! {\n    let hook = HOOK.load(Ordering::SeqCst);\n    let hook: fn(Layout) = if hook.is_null() {\n        default_alloc_error_hook\n    } else {\n        unsafe { mem::transmute(hook) }\n    };\n    hook(layout);\n    unsafe { ::sys::abort_internal(); }\n}\n\n#[cfg(not(test))]\n#[doc(hidden)]\n#[allow(unused_attributes)]\n#[unstable(feature = \"alloc_internals\", issue = \"0\")]\npub mod __default_lib_allocator {\n    use super::{System, Layout, GlobalAlloc};\n    // for symbol names src/librustc/middle/allocator.rs\n    // for signatures src/librustc_allocator/lib.rs\n\n    // linkage directives are provided as part of the current compiler allocator\n    // ABI\n\n    #[rustc_std_internal_symbol]\n    pub unsafe extern fn __rdl_alloc(size: usize, align: usize) -> *mut u8 {\n        let layout = Layout::from_size_align_unchecked(size, align);\n        System.alloc(layout)\n    }\n\n    #[rustc_std_internal_symbol]\n    pub unsafe extern fn __rdl_dealloc(ptr: *mut u8,\n                                       size: usize,\n                                       align: usize) {\n        System.dealloc(ptr, Layout::from_size_align_unchecked(size, align))\n    }\n\n    #[rustc_std_internal_symbol]\n    pub unsafe extern fn __rdl_realloc(ptr: *mut u8,\n                                       old_size: usize,\n                                       align: usize,\n                                       new_size: usize) -> *mut u8 {\n        let old_layout = Layout::from_size_align_unchecked(old_size, align);\n        System.realloc(ptr, old_layout, new_size)\n    }\n\n    #[rustc_std_internal_symbol]\n    pub unsafe extern fn __rdl_alloc_zeroed(size: usize, align: usize) -> *mut u8 {\n        let layout = Layout::from_size_align_unchecked(size, align);\n        System.alloc_zeroed(layout)\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Atomic types\n//!\n//! Atomic types provide primitive shared-memory communication between\n//! threads, and are the building blocks of other concurrent\n//! types.\n//!\n//! This module defines atomic versions of a select number of primitive\n//! types, including [`AtomicBool`], [`AtomicIsize`], and [`AtomicUsize`].\n//! Atomic types present operations that, when used correctly, synchronize\n//! updates between threads.\n//!\n//! [`AtomicBool`]: struct.AtomicBool.html\n//! [`AtomicIsize`]: struct.AtomicIsize.html\n//! [`AtomicUsize`]: struct.AtomicUsize.html\n//!\n//! Each method takes an [`Ordering`] which represents the strength of\n//! the memory barrier for that operation. These orderings are the\n//! same as [LLVM atomic orderings][1]. For more information see the [nomicon][2].\n//!\n//! [`Ordering`]: enum.Ordering.html\n//!\n//! [1]: https://llvm.org/docs/LangRef.html#memory-model-for-concurrent-operations\n//! [2]: ../../../nomicon/atomics.html\n//!\n//! Atomic variables are safe to share between threads (they implement [`Sync`])\n//! but they do not themselves provide the mechanism for sharing and follow the\n//! [threading model](../../../std/thread/index.html#the-threading-model) of rust.\n//! The most common way to share an atomic variable is to put it into an [`Arc`][arc] (an\n//! atomically-reference-counted shared pointer).\n//!\n//! [`Sync`]: ../../marker/trait.Sync.html\n//! [arc]: ../../../std/sync/struct.Arc.html\n//!\n//! Most atomic types may be stored in static variables, initialized using\n//! the provided static initializers like [`ATOMIC_BOOL_INIT`]. Atomic statics\n//! are often used for lazy global initialization.\n//!\n//! [`ATOMIC_BOOL_INIT`]: constant.ATOMIC_BOOL_INIT.html\n//!\n//! # Examples\n//!\n//! A simple spinlock:\n//!\n//! ```\n//! use std::sync::Arc;\n//! use std::sync::atomic::{AtomicUsize, Ordering};\n//! use std::thread;\n//!\n//! fn main() {\n//!     let spinlock = Arc::new(AtomicUsize::new(1));\n//!\n//!     let spinlock_clone = spinlock.clone();\n//!     let thread = thread::spawn(move|| {\n//!         spinlock_clone.store(0, Ordering::SeqCst);\n//!     });\n//!\n//!     // Wait for the other thread to release the lock\n//!     while spinlock.load(Ordering::SeqCst) != 0 {}\n//!\n//!     if let Err(panic) = thread.join() {\n//!         println!(\"Thread had an error: {:?}\", panic);\n//!     }\n//! }\n//! ```\n//!\n//! Keep a global count of live threads:\n//!\n//! ```\n//! use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};\n//!\n//! static GLOBAL_THREAD_COUNT: AtomicUsize = ATOMIC_USIZE_INIT;\n//!\n//! let old_thread_count = GLOBAL_THREAD_COUNT.fetch_add(1, Ordering::SeqCst);\n//! println!(\"live threads: {}\", old_thread_count + 1);\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n#![cfg_attr(not(target_has_atomic = \"8\"), allow(dead_code))]\n#![cfg_attr(not(target_has_atomic = \"8\"), allow(unused_imports))]\n\nuse self::Ordering::*;\n\nuse intrinsics;\nuse cell::UnsafeCell;\nuse fmt;\n\n/// Save power or switch hyperthreads in a busy-wait spin-loop.\n///\n/// This function is deliberately more primitive than\n/// [`std::thread::yield_now`](../../../std/thread/fn.yield_now.html) and\n/// does not directly yield to the system's scheduler.\n/// In some cases it might be useful to use a combination of both functions.\n/// Careful benchmarking is advised.\n///\n/// On some platforms this function may not do anything at all.\n#[inline]\n#[stable(feature = \"spin_loop_hint\", since = \"1.24.0\")]\npub fn spin_loop_hint() {\n    #[cfg(any(target_arch = \"x86\", target_arch = \"x86_64\"))]\n    unsafe {\n        asm!(\"pause\" ::: \"memory\" : \"volatile\");\n    }\n\n    #[cfg(target_arch = \"aarch64\")]\n    unsafe {\n        asm!(\"yield\" ::: \"memory\" : \"volatile\");\n    }\n}\n\n/// A boolean type which can be safely shared between threads.\n///\n/// This type has the same in-memory representation as a [`bool`].\n///\n/// [`bool`]: ../../../std/primitive.bool.html\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[repr(C, align(1))]\npub struct AtomicBool {\n    v: UnsafeCell<u8>,\n}\n\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Default for AtomicBool {\n    /// Creates an `AtomicBool` initialized to `false`.\n    fn default() -> Self {\n        Self::new(false)\n    }\n}\n\n// Send is implicitly implemented for AtomicBool.\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl Sync for AtomicBool {}\n\n/// A raw pointer type which can be safely shared between threads.\n///\n/// This type has the same in-memory representation as a `*mut T`.\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[cfg_attr(target_pointer_width = \"16\", repr(C, align(2)))]\n#[cfg_attr(target_pointer_width = \"32\", repr(C, align(4)))]\n#[cfg_attr(target_pointer_width = \"64\", repr(C, align(8)))]\npub struct AtomicPtr<T> {\n    p: UnsafeCell<*mut T>,\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Default for AtomicPtr<T> {\n    /// Creates a null `AtomicPtr<T>`.\n    fn default() -> AtomicPtr<T> {\n        AtomicPtr::new(::ptr::null_mut())\n    }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T> Send for AtomicPtr<T> {}\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T> Sync for AtomicPtr<T> {}\n\n/// Atomic memory orderings\n///\n/// Memory orderings limit the ways that both the compiler and CPU may reorder\n/// instructions around atomic operations. At its most restrictive,\n/// \"sequentially consistent\" atomics allow neither reads nor writes\n/// to be moved either before or after the atomic operation; on the other end\n/// \"relaxed\" atomics allow all reorderings.\n///\n/// Rust's memory orderings are [the same as\n/// LLVM's](https://llvm.org/docs/LangRef.html#memory-model-for-concurrent-operations).\n///\n/// For more information see the [nomicon].\n///\n/// [nomicon]: ../../../nomicon/atomics.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Copy, Clone, Debug)]\n#[non_exhaustive]\npub enum Ordering {\n    /// No ordering constraints, only atomic operations.\n    ///\n    /// Corresponds to LLVM's [`Monotonic`] ordering.\n    ///\n    /// [`Monotonic`]: https://llvm.org/docs/Atomics.html#monotonic\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Relaxed,\n    /// When coupled with a store, all previous operations become ordered\n    /// before any load of this value with [`Acquire`] (or stronger) ordering.\n    /// In particular, all previous writes become visible to all threads\n    /// that perform an [`Acquire`] (or stronger) load of this value.\n    ///\n    /// Notice that using this ordering for an operation that combines loads\n    /// and stores leads to a [`Relaxed`] load operation!\n    ///\n    /// This ordering is only applicable for operations that can perform a store.\n    ///\n    /// Corresponds to LLVM's [`Release`] ordering.\n    ///\n    /// [`Release`]: https://llvm.org/docs/Atomics.html#release\n    /// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire\n    /// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Release,\n    /// When coupled with a load, if the loaded value was written by a store operation with\n    /// [`Release`] (or stronger) ordering, then all subsequent operations\n    /// become ordered after that store. In particular, all subsequent loads will see data\n    /// written before the store.\n    ///\n    /// Notice that using this ordering for an operation that combines loads\n    /// and stores leads to a [`Relaxed`] store operation!\n    ///\n    /// This ordering is only applicable for operations that can perform a load.\n    ///\n    /// Corresponds to LLVM's [`Acquire`] ordering.\n    ///\n    /// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire\n    /// [`Release`]: https://llvm.org/docs/Atomics.html#release\n    /// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Acquire,\n    /// Has the effects of both [`Acquire`] and [`Release`] together:\n    /// For loads it uses [`Acquire`] ordering. For stores it uses the [`Release`] ordering.\n    ///\n    /// Notice that in the case of `compare_and_swap`, it is possible that the operation ends up\n    /// not performing any store and hence it has just `Acquire` ordering. However,\n    /// `AcqRel` will never perform [`Relaxed`] accesses.\n    ///\n    /// This ordering is only applicable for operations that combine both loads and stores.\n    ///\n    /// Corresponds to LLVM's [`AcquireRelease`] ordering.\n    ///\n    /// [`AcquireRelease`]: https://llvm.org/docs/Atomics.html#acquirerelease\n    /// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire\n    /// [`Release`]: https://llvm.org/docs/Atomics.html#release\n    /// [`Relaxed`]: https://llvm.org/docs/Atomics.html#monotonic\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    AcqRel,\n    /// Like [`Acquire`]/[`Release`]/[`AcqRel`] (for load, store, and load-with-store\n    /// operations, respectively) with the additional guarantee that all threads see all\n    /// sequentially consistent operations in the same order.\n    ///\n    /// Corresponds to LLVM's [`SequentiallyConsistent`] ordering.\n    ///\n    /// [`SequentiallyConsistent`]: https://llvm.org/docs/Atomics.html#sequentiallyconsistent\n    /// [`Acquire`]: https://llvm.org/docs/Atomics.html#acquire\n    /// [`Release`]: https://llvm.org/docs/Atomics.html#release\n    /// [`AcqRel`]: https://llvm.org/docs/Atomics.html#acquirerelease\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    SeqCst,\n}\n\n/// An [`AtomicBool`] initialized to `false`.\n///\n/// [`AtomicBool`]: struct.AtomicBool.html\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const ATOMIC_BOOL_INIT: AtomicBool = AtomicBool::new(false);\n\n#[cfg(target_has_atomic = \"8\")]\nimpl AtomicBool {\n    /// Creates a new `AtomicBool`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::AtomicBool;\n    ///\n    /// let atomic_true  = AtomicBool::new(true);\n    /// let atomic_false = AtomicBool::new(false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const fn new(v: bool) -> AtomicBool {\n        AtomicBool { v: UnsafeCell::new(v as u8) }\n    }\n\n    /// Returns a mutable reference to the underlying [`bool`].\n    ///\n    /// This is safe because the mutable reference guarantees that no other threads are\n    /// concurrently accessing the atomic data.\n    ///\n    /// [`bool`]: ../../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let mut some_bool = AtomicBool::new(true);\n    /// assert_eq!(*some_bool.get_mut(), true);\n    /// *some_bool.get_mut() = false;\n    /// assert_eq!(some_bool.load(Ordering::SeqCst), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"atomic_access\", since = \"1.15.0\")]\n    pub fn get_mut(&mut self) -> &mut bool {\n        unsafe { &mut *(self.v.get() as *mut bool) }\n    }\n\n    /// Consumes the atomic and returns the contained value.\n    ///\n    /// This is safe because passing `self` by value guarantees that no other threads are\n    /// concurrently accessing the atomic data.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::AtomicBool;\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    /// assert_eq!(some_bool.into_inner(), true);\n    /// ```\n    #[inline]\n    #[stable(feature = \"atomic_access\", since = \"1.15.0\")]\n    pub fn into_inner(self) -> bool {\n        self.v.into_inner() != 0\n    }\n\n    /// Loads a value from the bool.\n    ///\n    /// `load` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if `order` is [`Release`] or [`AcqRel`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    ///\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), true);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn load(&self, order: Ordering) -> bool {\n        unsafe { atomic_load(self.v.get(), order) != 0 }\n    }\n\n    /// Stores a value into the bool.\n    ///\n    /// `store` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if `order` is [`Acquire`] or [`AcqRel`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    ///\n    /// some_bool.store(false, Ordering::Relaxed);\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn store(&self, val: bool, order: Ordering) {\n        unsafe {\n            atomic_store(self.v.get(), val as u8, order);\n        }\n    }\n\n    /// Stores a value into the bool, returning the previous value.\n    ///\n    /// `swap` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    ///\n    /// assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn swap(&self, val: bool, order: Ordering) -> bool {\n        unsafe { atomic_swap(self.v.get(), val as u8, order) != 0 }\n    }\n\n    /// Stores a value into the [`bool`] if the current value is the same as the `current` value.\n    ///\n    /// The return value is always the previous value. If it is equal to `current`, then the value\n    /// was updated.\n    ///\n    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory\n    /// ordering of this operation. Notice that even when using [`AcqRel`], the operation\n    /// might fail and hence just perform an `Acquire` load, but not have `Release` semantics.\n    /// Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it\n    /// happens, and using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    /// [`bool`]: ../../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    ///\n    /// assert_eq!(some_bool.compare_and_swap(true, false, Ordering::Relaxed), true);\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    ///\n    /// assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false);\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool {\n        match self.compare_exchange(current, new, order, strongest_failure_ordering(order)) {\n            Ok(x) => x,\n            Err(x) => x,\n        }\n    }\n\n    /// Stores a value into the [`bool`] if the current value is the same as the `current` value.\n    ///\n    /// The return value is a result indicating whether the new value was written and containing\n    /// the previous value. On success this value is guaranteed to be equal to `current`.\n    ///\n    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory\n    /// ordering of this operation. The first describes the required ordering if the\n    /// operation succeeds while the second describes the required ordering when the\n    /// operation fails. Using [`Acquire`] as success ordering makes the store part\n    /// of this operation [`Relaxed`], and using [`Release`] makes the successful load\n    /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\n    /// and must be equivalent to or weaker than the success ordering.\n    ///\n    ///\n    /// [`bool`]: ../../../std/primitive.bool.html\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let some_bool = AtomicBool::new(true);\n    ///\n    /// assert_eq!(some_bool.compare_exchange(true,\n    ///                                       false,\n    ///                                       Ordering::Acquire,\n    ///                                       Ordering::Relaxed),\n    ///            Ok(true));\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    ///\n    /// assert_eq!(some_bool.compare_exchange(true, true,\n    ///                                       Ordering::SeqCst,\n    ///                                       Ordering::Acquire),\n    ///            Err(false));\n    /// assert_eq!(some_bool.load(Ordering::Relaxed), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_exchange(&self,\n                            current: bool,\n                            new: bool,\n                            success: Ordering,\n                            failure: Ordering)\n                            -> Result<bool, bool> {\n        match unsafe {\n            atomic_compare_exchange(self.v.get(), current as u8, new as u8, success, failure)\n        } {\n            Ok(x) => Ok(x != 0),\n            Err(x) => Err(x != 0),\n        }\n    }\n\n    /// Stores a value into the [`bool`] if the current value is the same as the `current` value.\n    ///\n    /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even when the\n    /// comparison succeeds, which can result in more efficient code on some platforms. The\n    /// return value is a result indicating whether the new value was written and containing the\n    /// previous value.\n    ///\n    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory\n    /// ordering of this operation. The first describes the required ordering if the\n    /// operation succeeds while the second describes the required ordering when the\n    /// operation fails. Using [`Acquire`] as success ordering makes the store part\n    /// of this operation [`Relaxed`], and using [`Release`] makes the successful load\n    /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\n    /// and must be equivalent to or weaker than the success ordering.\n    ///\n    /// [`bool`]: ../../../std/primitive.bool.html\n    /// [`compare_exchange`]: #method.compare_exchange\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let val = AtomicBool::new(false);\n    ///\n    /// let new = true;\n    /// let mut old = val.load(Ordering::Relaxed);\n    /// loop {\n    ///     match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {\n    ///         Ok(_) => break,\n    ///         Err(x) => old = x,\n    ///     }\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_exchange_weak(&self,\n                                 current: bool,\n                                 new: bool,\n                                 success: Ordering,\n                                 failure: Ordering)\n                                 -> Result<bool, bool> {\n        match unsafe {\n            atomic_compare_exchange_weak(self.v.get(), current as u8, new as u8, success, failure)\n        } {\n            Ok(x) => Ok(x != 0),\n            Err(x) => Err(x != 0),\n        }\n    }\n\n    /// Logical \"and\" with a boolean value.\n    ///\n    /// Performs a logical \"and\" operation on the current value and the argument `val`, and sets\n    /// the new value to the result.\n    ///\n    /// Returns the previous value.\n    ///\n    /// `fetch_and` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    ///\n    /// let foo = AtomicBool::new(false);\n    /// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn fetch_and(&self, val: bool, order: Ordering) -> bool {\n        unsafe { atomic_and(self.v.get(), val as u8, order) != 0 }\n    }\n\n    /// Logical \"nand\" with a boolean value.\n    ///\n    /// Performs a logical \"nand\" operation on the current value and the argument `val`, and sets\n    /// the new value to the result.\n    ///\n    /// Returns the previous value.\n    ///\n    /// `fetch_nand` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    ///\n    /// let foo = AtomicBool::new(false);\n    /// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool {\n        // We can't use atomic_nand here because it can result in a bool with\n        // an invalid value. This happens because the atomic operation is done\n        // with an 8-bit integer internally, which would set the upper 7 bits.\n        // So we just use fetch_xor or swap instead.\n        if val {\n            // !(x & true) == !x\n            // We must invert the bool.\n            self.fetch_xor(true, order)\n        } else {\n            // !(x & false) == true\n            // We must set the bool to true.\n            self.swap(true, order)\n        }\n    }\n\n    /// Logical \"or\" with a boolean value.\n    ///\n    /// Performs a logical \"or\" operation on the current value and the argument `val`, and sets the\n    /// new value to the result.\n    ///\n    /// Returns the previous value.\n    ///\n    /// `fetch_or` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    ///\n    /// let foo = AtomicBool::new(false);\n    /// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn fetch_or(&self, val: bool, order: Ordering) -> bool {\n        unsafe { atomic_or(self.v.get(), val as u8, order) != 0 }\n    }\n\n    /// Logical \"xor\" with a boolean value.\n    ///\n    /// Performs a logical \"xor\" operation on the current value and the argument `val`, and sets\n    /// the new value to the result.\n    ///\n    /// Returns the previous value.\n    ///\n    /// `fetch_xor` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicBool, Ordering};\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), true);\n    ///\n    /// let foo = AtomicBool::new(true);\n    /// assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    ///\n    /// let foo = AtomicBool::new(false);\n    /// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);\n    /// assert_eq!(foo.load(Ordering::SeqCst), false);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool {\n        unsafe { atomic_xor(self.v.get(), val as u8, order) != 0 }\n    }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\nimpl<T> AtomicPtr<T> {\n    /// Creates a new `AtomicPtr`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::AtomicPtr;\n    ///\n    /// let ptr = &mut 5;\n    /// let atomic_ptr  = AtomicPtr::new(ptr);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const fn new(p: *mut T) -> AtomicPtr<T> {\n        AtomicPtr { p: UnsafeCell::new(p) }\n    }\n\n    /// Returns a mutable reference to the underlying pointer.\n    ///\n    /// This is safe because the mutable reference guarantees that no other threads are\n    /// concurrently accessing the atomic data.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let mut atomic_ptr = AtomicPtr::new(&mut 10);\n    /// *atomic_ptr.get_mut() = &mut 5;\n    /// assert_eq!(unsafe { *atomic_ptr.load(Ordering::SeqCst) }, 5);\n    /// ```\n    #[inline]\n    #[stable(feature = \"atomic_access\", since = \"1.15.0\")]\n    pub fn get_mut(&mut self) -> &mut *mut T {\n        unsafe { &mut *self.p.get() }\n    }\n\n    /// Consumes the atomic and returns the contained value.\n    ///\n    /// This is safe because passing `self` by value guarantees that no other threads are\n    /// concurrently accessing the atomic data.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::AtomicPtr;\n    ///\n    /// let atomic_ptr = AtomicPtr::new(&mut 5);\n    /// assert_eq!(unsafe { *atomic_ptr.into_inner() }, 5);\n    /// ```\n    #[inline]\n    #[stable(feature = \"atomic_access\", since = \"1.15.0\")]\n    pub fn into_inner(self) -> *mut T {\n        self.p.into_inner()\n    }\n\n    /// Loads a value from the pointer.\n    ///\n    /// `load` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if `order` is [`Release`] or [`AcqRel`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let ptr = &mut 5;\n    /// let some_ptr  = AtomicPtr::new(ptr);\n    ///\n    /// let value = some_ptr.load(Ordering::Relaxed);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn load(&self, order: Ordering) -> *mut T {\n        unsafe { atomic_load(self.p.get() as *mut usize, order) as *mut T }\n    }\n\n    /// Stores a value into the pointer.\n    ///\n    /// `store` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].\n    ///\n    /// # Panics\n    ///\n    /// Panics if `order` is [`Acquire`] or [`AcqRel`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let ptr = &mut 5;\n    /// let some_ptr  = AtomicPtr::new(ptr);\n    ///\n    /// let other_ptr = &mut 10;\n    ///\n    /// some_ptr.store(other_ptr, Ordering::Relaxed);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn store(&self, ptr: *mut T, order: Ordering) {\n        unsafe {\n            atomic_store(self.p.get() as *mut usize, ptr as usize, order);\n        }\n    }\n\n    /// Stores a value into the pointer, returning the previous value.\n    ///\n    /// `swap` takes an [`Ordering`] argument which describes the memory ordering\n    /// of this operation. All ordering modes are possible. Note that using\n    /// [`Acquire`] makes the store part of this operation [`Relaxed`], and\n    /// using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let ptr = &mut 5;\n    /// let some_ptr  = AtomicPtr::new(ptr);\n    ///\n    /// let other_ptr = &mut 10;\n    ///\n    /// let value = some_ptr.swap(other_ptr, Ordering::Relaxed);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T {\n        unsafe { atomic_swap(self.p.get() as *mut usize, ptr as usize, order) as *mut T }\n    }\n\n    /// Stores a value into the pointer if the current value is the same as the `current` value.\n    ///\n    /// The return value is always the previous value. If it is equal to `current`, then the value\n    /// was updated.\n    ///\n    /// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory\n    /// ordering of this operation. Notice that even when using [`AcqRel`], the operation\n    /// might fail and hence just perform an `Acquire` load, but not have `Release` semantics.\n    /// Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it\n    /// happens, and using [`Release`] makes the load part [`Relaxed`].\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let ptr = &mut 5;\n    /// let some_ptr  = AtomicPtr::new(ptr);\n    ///\n    /// let other_ptr   = &mut 10;\n    /// let another_ptr = &mut 10;\n    ///\n    /// let value = some_ptr.compare_and_swap(other_ptr, another_ptr, Ordering::Relaxed);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_and_swap(&self, current: *mut T, new: *mut T, order: Ordering) -> *mut T {\n        match self.compare_exchange(current, new, order, strongest_failure_ordering(order)) {\n            Ok(x) => x,\n            Err(x) => x,\n        }\n    }\n\n    /// Stores a value into the pointer if the current value is the same as the `current` value.\n    ///\n    /// The return value is a result indicating whether the new value was written and containing\n    /// the previous value. On success this value is guaranteed to be equal to `current`.\n    ///\n    /// `compare_exchange` takes two [`Ordering`] arguments to describe the memory\n    /// ordering of this operation. The first describes the required ordering if the\n    /// operation succeeds while the second describes the required ordering when the\n    /// operation fails. Using [`Acquire`] as success ordering makes the store part\n    /// of this operation [`Relaxed`], and using [`Release`] makes the successful load\n    /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\n    /// and must be equivalent to or weaker than the success ordering.\n    ///\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let ptr = &mut 5;\n    /// let some_ptr  = AtomicPtr::new(ptr);\n    ///\n    /// let other_ptr   = &mut 10;\n    /// let another_ptr = &mut 10;\n    ///\n    /// let value = some_ptr.compare_exchange(other_ptr, another_ptr,\n    ///                                       Ordering::SeqCst, Ordering::Relaxed);\n    /// ```\n    #[inline]\n    #[stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_exchange(&self,\n                            current: *mut T,\n                            new: *mut T,\n                            success: Ordering,\n                            failure: Ordering)\n                            -> Result<*mut T, *mut T> {\n        unsafe {\n            let res = atomic_compare_exchange(self.p.get() as *mut usize,\n                                              current as usize,\n                                              new as usize,\n                                              success,\n                                              failure);\n            match res {\n                Ok(x) => Ok(x as *mut T),\n                Err(x) => Err(x as *mut T),\n            }\n        }\n    }\n\n    /// Stores a value into the pointer if the current value is the same as the `current` value.\n    ///\n    /// Unlike [`compare_exchange`], this function is allowed to spuriously fail even when the\n    /// comparison succeeds, which can result in more efficient code on some platforms. The\n    /// return value is a result indicating whether the new value was written and containing the\n    /// previous value.\n    ///\n    /// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory\n    /// ordering of this operation. The first describes the required ordering if the\n    /// operation succeeds while the second describes the required ordering when the\n    /// operation fails. Using [`Acquire`] as success ordering makes the store part\n    /// of this operation [`Relaxed`], and using [`Release`] makes the successful load\n    /// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\n    /// and must be equivalent to or weaker than the success ordering.\n    ///\n    /// [`compare_exchange`]: #method.compare_exchange\n    /// [`Ordering`]: enum.Ordering.html\n    /// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n    /// [`Release`]: enum.Ordering.html#variant.Release\n    /// [`Acquire`]: enum.Ordering.html#variant.Acquire\n    /// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::atomic::{AtomicPtr, Ordering};\n    ///\n    /// let some_ptr = AtomicPtr::new(&mut 5);\n    ///\n    /// let new = &mut 10;\n    /// let mut old = some_ptr.load(Ordering::Relaxed);\n    /// loop {\n    ///     match some_ptr.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {\n    ///         Ok(_) => break,\n    ///         Err(x) => old = x,\n    ///     }\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\")]\n    #[cfg(target_has_atomic = \"cas\")]\n    pub fn compare_exchange_weak(&self,\n                                 current: *mut T,\n                                 new: *mut T,\n                                 success: Ordering,\n                                 failure: Ordering)\n                                 -> Result<*mut T, *mut T> {\n        unsafe {\n            let res = atomic_compare_exchange_weak(self.p.get() as *mut usize,\n                                                   current as usize,\n                                                   new as usize,\n                                                   success,\n                                                   failure);\n            match res {\n                Ok(x) => Ok(x as *mut T),\n                Err(x) => Err(x as *mut T),\n            }\n        }\n    }\n}\n\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"atomic_bool_from\", since = \"1.24.0\")]\nimpl From<bool> for AtomicBool {\n    #[inline]\n    fn from(b: bool) -> Self { Self::new(b) }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"atomic_from\", since = \"1.23.0\")]\nimpl<T> From<*mut T> for AtomicPtr<T> {\n    #[inline]\n    fn from(p: *mut T) -> Self { Self::new(p) }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\nmacro_rules! atomic_int {\n    ($stable:meta,\n     $stable_cxchg:meta,\n     $stable_debug:meta,\n     $stable_access:meta,\n     $stable_from:meta,\n     $stable_nand:meta,\n     $s_int_type:expr, $int_ref:expr,\n     $extra_feature:expr,\n     $min_fn:ident, $max_fn:ident,\n     $align:expr,\n     $int_type:ident $atomic_type:ident $atomic_init:ident) => {\n        /// An integer type which can be safely shared between threads.\n        ///\n        /// This type has the same in-memory representation as the underlying\n        /// integer type, [`\n        #[doc = $s_int_type]\n        /// `](\n        #[doc = $int_ref]\n        /// ). For more about the differences between atomic types and\n        /// non-atomic types, please see the [module-level documentation].\n        ///\n        /// [module-level documentation]: index.html\n        #[$stable]\n        #[repr(C, align($align))]\n        pub struct $atomic_type {\n            v: UnsafeCell<$int_type>,\n        }\n\n        /// An atomic integer initialized to `0`.\n        #[$stable]\n        pub const $atomic_init: $atomic_type = $atomic_type::new(0);\n\n        #[$stable]\n        impl Default for $atomic_type {\n            fn default() -> Self {\n                Self::new(Default::default())\n            }\n        }\n\n        #[$stable_from]\n        impl From<$int_type> for $atomic_type {\n            #[inline]\n            fn from(v: $int_type) -> Self { Self::new(v) }\n        }\n\n        #[$stable_debug]\n        impl fmt::Debug for $atomic_type {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)\n            }\n        }\n\n        // Send is implicitly implemented.\n        #[$stable]\n        unsafe impl Sync for $atomic_type {}\n\n        impl $atomic_type {\n            doc_comment! {\n                concat!(\"Creates a new atomic integer.\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::\", stringify!($atomic_type), \";\n\nlet atomic_forty_two = \", stringify!($atomic_type), \"::new(42);\n```\"),\n                #[inline]\n                #[$stable]\n                pub const fn new(v: $int_type) -> Self {\n                    $atomic_type {v: UnsafeCell::new(v)}\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Returns a mutable reference to the underlying integer.\n\nThis is safe because the mutable reference guarantees that no other threads are\nconcurrently accessing the atomic data.\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet mut some_var = \", stringify!($atomic_type), \"::new(10);\nassert_eq!(*some_var.get_mut(), 10);\n*some_var.get_mut() = 5;\nassert_eq!(some_var.load(Ordering::SeqCst), 5);\n```\"),\n                #[inline]\n                #[$stable_access]\n                pub fn get_mut(&mut self) -> &mut $int_type {\n                    unsafe { &mut *self.v.get() }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Consumes the atomic and returns the contained value.\n\nThis is safe because passing `self` by value guarantees that no other threads are\nconcurrently accessing the atomic data.\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::\", stringify!($atomic_type), \";\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\nassert_eq!(some_var.into_inner(), 5);\n```\"),\n                #[inline]\n                #[$stable_access]\n                pub fn into_inner(self) -> $int_type {\n                    self.v.into_inner()\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Loads a value from the atomic integer.\n\n`load` takes an [`Ordering`] argument which describes the memory ordering of this operation.\nPossible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].\n\n# Panics\n\nPanics if `order` is [`Release`] or [`AcqRel`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`AcqRel`]: enum.Ordering.html#variant.AcqRel\n[`SeqCst`]: enum.Ordering.html#variant.SeqCst\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\n\nassert_eq!(some_var.load(Ordering::Relaxed), 5);\n```\"),\n                #[inline]\n                #[$stable]\n                pub fn load(&self, order: Ordering) -> $int_type {\n                    unsafe { atomic_load(self.v.get(), order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Stores a value into the atomic integer.\n\n`store` takes an [`Ordering`] argument which describes the memory ordering of this operation.\n Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].\n\n# Panics\n\nPanics if `order` is [`Acquire`] or [`AcqRel`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`AcqRel`]: enum.Ordering.html#variant.AcqRel\n[`SeqCst`]: enum.Ordering.html#variant.SeqCst\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\n\nsome_var.store(10, Ordering::Relaxed);\nassert_eq!(some_var.load(Ordering::Relaxed), 10);\n```\"),\n                #[inline]\n                #[$stable]\n                pub fn store(&self, val: $int_type, order: Ordering) {\n                    unsafe { atomic_store(self.v.get(), val, order); }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Stores a value into the atomic integer, returning the previous value.\n\n`swap` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\n\nassert_eq!(some_var.swap(10, Ordering::Relaxed), 5);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn swap(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_swap(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Stores a value into the atomic integer if the current value is the same as\nthe `current` value.\n\nThe return value is always the previous value. If it is equal to `current`, then the\nvalue was updated.\n\n`compare_and_swap` also takes an [`Ordering`] argument which describes the memory\nordering of this operation. Notice that even when using [`AcqRel`], the operation\nmight fail and hence just perform an `Acquire` load, but not have `Release` semantics.\nUsing [`Acquire`] makes the store part of this operation [`Relaxed`] if it\nhappens, and using [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`AcqRel`]: enum.Ordering.html#variant.AcqRel\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\n\nassert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);\nassert_eq!(some_var.load(Ordering::Relaxed), 10);\n\nassert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);\nassert_eq!(some_var.load(Ordering::Relaxed), 10);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn compare_and_swap(&self,\n                                        current: $int_type,\n                                        new: $int_type,\n                                        order: Ordering) -> $int_type {\n                    match self.compare_exchange(current,\n                                                new,\n                                                order,\n                                                strongest_failure_ordering(order)) {\n                        Ok(x) => x,\n                        Err(x) => x,\n                    }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Stores a value into the atomic integer if the current value is the same as\nthe `current` value.\n\nThe return value is a result indicating whether the new value was written and\ncontaining the previous value. On success this value is guaranteed to be equal to\n`current`.\n\n`compare_exchange` takes two [`Ordering`] arguments to describe the memory\nordering of this operation. The first describes the required ordering if the\noperation succeeds while the second describes the required ordering when the\noperation fails. Using [`Acquire`] as success ordering makes the store part\nof this operation [`Relaxed`], and using [`Release`] makes the successful load\n[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\nand must be equivalent to or weaker than the success ordering.\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`SeqCst`]: enum.Ordering.html#variant.SeqCst\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet some_var = \", stringify!($atomic_type), \"::new(5);\n\nassert_eq!(some_var.compare_exchange(5, 10,\n                                     Ordering::Acquire,\n                                     Ordering::Relaxed),\n           Ok(5));\nassert_eq!(some_var.load(Ordering::Relaxed), 10);\n\nassert_eq!(some_var.compare_exchange(6, 12,\n                                     Ordering::SeqCst,\n                                     Ordering::Acquire),\n           Err(10));\nassert_eq!(some_var.load(Ordering::Relaxed), 10);\n```\"),\n                #[inline]\n                #[$stable_cxchg]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn compare_exchange(&self,\n                                        current: $int_type,\n                                        new: $int_type,\n                                        success: Ordering,\n                                        failure: Ordering) -> Result<$int_type, $int_type> {\n                    unsafe { atomic_compare_exchange(self.v.get(), current, new, success, failure) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Stores a value into the atomic integer if the current value is the same as\nthe `current` value.\n\nUnlike [`compare_exchange`], this function is allowed to spuriously fail even\nwhen the comparison succeeds, which can result in more efficient code on some\nplatforms. The return value is a result indicating whether the new value was\nwritten and containing the previous value.\n\n`compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory\nordering of this operation. The first describes the required ordering if the\noperation succeeds while the second describes the required ordering when the\noperation fails. Using [`Acquire`] as success ordering makes the store part\nof this operation [`Relaxed`], and using [`Release`] makes the successful load\n[`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\nand must be equivalent to or weaker than the success ordering.\n\n[`compare_exchange`]: #method.compare_exchange\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`SeqCst`]: enum.Ordering.html#variant.SeqCst\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet val = \", stringify!($atomic_type), \"::new(4);\n\nlet mut old = val.load(Ordering::Relaxed);\nloop {\n    let new = old * 2;\n    match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {\n        Ok(_) => break,\n        Err(x) => old = x,\n    }\n}\n```\"),\n                #[inline]\n                #[$stable_cxchg]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn compare_exchange_weak(&self,\n                                             current: $int_type,\n                                             new: $int_type,\n                                             success: Ordering,\n                                             failure: Ordering) -> Result<$int_type, $int_type> {\n                    unsafe {\n                        atomic_compare_exchange_weak(self.v.get(), current, new, success, failure)\n                    }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Adds to the current value, returning the previous value.\n\nThis operation wraps around on overflow.\n\n`fetch_add` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(0);\nassert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);\nassert_eq!(foo.load(Ordering::SeqCst), 10);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_add(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_add(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Subtracts from the current value, returning the previous value.\n\nThis operation wraps around on overflow.\n\n`fetch_sub` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(20);\nassert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);\nassert_eq!(foo.load(Ordering::SeqCst), 10);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_sub(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_sub(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Bitwise \\\"and\\\" with the current value.\n\nPerforms a bitwise \\\"and\\\" operation on the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_and` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(0b101101);\nassert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);\nassert_eq!(foo.load(Ordering::SeqCst), 0b100001);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_and(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_and(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Bitwise \\\"nand\\\" with the current value.\n\nPerforms a bitwise \\\"nand\\\" operation on the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_nand` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"\nuse std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(0x13);\nassert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);\nassert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));\n```\"),\n                #[inline]\n                #[$stable_nand]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_nand(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_nand(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Bitwise \\\"or\\\" with the current value.\n\nPerforms a bitwise \\\"or\\\" operation on the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_or` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(0b101101);\nassert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);\nassert_eq!(foo.load(Ordering::SeqCst), 0b111111);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_or(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_or(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Bitwise \\\"xor\\\" with the current value.\n\nPerforms a bitwise \\\"xor\\\" operation on the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_xor` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(0b101101);\nassert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);\nassert_eq!(foo.load(Ordering::SeqCst), 0b011110);\n```\"),\n                #[inline]\n                #[$stable]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_xor(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { atomic_xor(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Fetches the value, and applies a function to it that returns an optional\nnew value. Returns a `Result` of `Ok(previous_value)` if the function returned `Some(_)`, else\n`Err(previous_value)`.\n\nNote: This may call the function multiple times if the value has been changed from other threads in\nthe meantime, as long as the function returns `Some(_)`, but the function will have been applied\nbut once to the stored value.\n\n`fetch_update` takes two [`Ordering`] arguments to describe the memory\nordering of this operation. The first describes the required ordering for loads\nand failed updates while the second describes the required ordering when the\noperation finally succeeds. Beware that this is different from the two\nmodes in [`compare_exchange`]!\n\nUsing [`Acquire`] as success ordering makes the store part\nof this operation [`Relaxed`], and using [`Release`] makes the final successful load\n[`Relaxed`]. The (failed) load ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]\nand must be equivalent to or weaker than the success ordering.\n\n[`bool`]: ../../../std/primitive.bool.html\n[`compare_exchange`]: #method.compare_exchange\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n[`SeqCst`]: enum.Ordering.html#variant.SeqCst\n\n# Examples\n\n```rust\n#![feature(no_more_cas)]\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet x = \", stringify!($atomic_type), \"::new(7);\nassert_eq!(x.fetch_update(|_| None, Ordering::SeqCst, Ordering::SeqCst), Err(7));\nassert_eq!(x.fetch_update(|x| Some(x + 1), Ordering::SeqCst, Ordering::SeqCst), Ok(7));\nassert_eq!(x.fetch_update(|x| Some(x + 1), Ordering::SeqCst, Ordering::SeqCst), Ok(8));\nassert_eq!(x.load(Ordering::SeqCst), 9);\n```\"),\n                #[inline]\n                #[unstable(feature = \"no_more_cas\",\n                       reason = \"no more CAS loops in user code\",\n                       issue = \"48655\")]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_update<F>(&self,\n                                       mut f: F,\n                                       fetch_order: Ordering,\n                                       set_order: Ordering) -> Result<$int_type, $int_type>\n                where F: FnMut($int_type) -> Option<$int_type> {\n                    let mut prev = self.load(fetch_order);\n                    while let Some(next) = f(prev) {\n                        match self.compare_exchange_weak(prev, next, set_order, fetch_order) {\n                            x @ Ok(_) => return x,\n                            Err(next_prev) => prev = next_prev\n                        }\n                    }\n                    Err(prev)\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Maximum with the current value.\n\nFinds the maximum of the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_max` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n#![feature(atomic_min_max)]\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(23);\nassert_eq!(foo.fetch_max(42, Ordering::SeqCst), 23);\nassert_eq!(foo.load(Ordering::SeqCst), 42);\n```\n\nIf you want to obtain the maximum value in one step, you can use the following:\n\n```\n#![feature(atomic_min_max)]\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(23);\nlet bar = 42;\nlet max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);\nassert!(max_foo == 42);\n```\"),\n                #[inline]\n                #[unstable(feature = \"atomic_min_max\",\n                       reason = \"easier and faster min/max than writing manual CAS loop\",\n                       issue = \"48655\")]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_max(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { $max_fn(self.v.get(), val, order) }\n                }\n            }\n\n            doc_comment! {\n                concat!(\"Minimum with the current value.\n\nFinds the minimum of the current value and the argument `val`, and\nsets the new value to the result.\n\nReturns the previous value.\n\n`fetch_min` takes an [`Ordering`] argument which describes the memory ordering\nof this operation. All ordering modes are possible. Note that using\n[`Acquire`] makes the store part of this operation [`Relaxed`], and\nusing [`Release`] makes the load part [`Relaxed`].\n\n[`Ordering`]: enum.Ordering.html\n[`Relaxed`]: enum.Ordering.html#variant.Relaxed\n[`Release`]: enum.Ordering.html#variant.Release\n[`Acquire`]: enum.Ordering.html#variant.Acquire\n\n# Examples\n\n```\n#![feature(atomic_min_max)]\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(23);\nassert_eq!(foo.fetch_min(42, Ordering::Relaxed), 23);\nassert_eq!(foo.load(Ordering::Relaxed), 23);\nassert_eq!(foo.fetch_min(22, Ordering::Relaxed), 23);\nassert_eq!(foo.load(Ordering::Relaxed), 22);\n```\n\nIf you want to obtain the minimum value in one step, you can use the following:\n\n```\n#![feature(atomic_min_max)]\n\", $extra_feature, \"use std::sync::atomic::{\", stringify!($atomic_type), \", Ordering};\n\nlet foo = \", stringify!($atomic_type), \"::new(23);\nlet bar = 12;\nlet min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);\nassert_eq!(min_foo, 12);\n```\"),\n                #[inline]\n                #[unstable(feature = \"atomic_min_max\",\n                       reason = \"easier and faster min/max than writing manual CAS loop\",\n                       issue = \"48655\")]\n                #[cfg(target_has_atomic = \"cas\")]\n                pub fn fetch_min(&self, val: $int_type, order: Ordering) -> $int_type {\n                    unsafe { $min_fn(self.v.get(), val, order) }\n                }\n            }\n\n        }\n    }\n}\n\n#[cfg(target_has_atomic = \"8\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"i8\", \"../../../std/primitive.i8.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_min, atomic_max,\n    1,\n    i8 AtomicI8 ATOMIC_I8_INIT\n}\n#[cfg(target_has_atomic = \"8\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"u8\", \"../../../std/primitive.u8.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_umin, atomic_umax,\n    1,\n    u8 AtomicU8 ATOMIC_U8_INIT\n}\n#[cfg(target_has_atomic = \"16\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"i16\", \"../../../std/primitive.i16.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_min, atomic_max,\n    2,\n    i16 AtomicI16 ATOMIC_I16_INIT\n}\n#[cfg(target_has_atomic = \"16\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"u16\", \"../../../std/primitive.u16.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_umin, atomic_umax,\n    2,\n    u16 AtomicU16 ATOMIC_U16_INIT\n}\n#[cfg(target_has_atomic = \"32\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"i32\", \"../../../std/primitive.i32.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_min, atomic_max,\n    4,\n    i32 AtomicI32 ATOMIC_I32_INIT\n}\n#[cfg(target_has_atomic = \"32\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"u32\", \"../../../std/primitive.u32.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_umin, atomic_umax,\n    4,\n    u32 AtomicU32 ATOMIC_U32_INIT\n}\n#[cfg(target_has_atomic = \"64\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"i64\", \"../../../std/primitive.i64.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_min, atomic_max,\n    8,\n    i64 AtomicI64 ATOMIC_I64_INIT\n}\n#[cfg(target_has_atomic = \"64\")]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"u64\", \"../../../std/primitive.u64.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_umin, atomic_umax,\n    8,\n    u64 AtomicU64 ATOMIC_U64_INIT\n}\n#[cfg(all(not(stage0), target_has_atomic = \"128\"))]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"i128\", \"../../../std/primitive.i128.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_min, atomic_max,\n    16,\n    i128 AtomicI128 ATOMIC_I128_INIT\n}\n#[cfg(all(not(stage0), target_has_atomic = \"128\"))]\natomic_int! {\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    unstable(feature = \"integer_atomics\", issue = \"32976\"),\n    \"u128\", \"../../../std/primitive.u128.html\",\n    \"#![feature(integer_atomics)]\\n\\n\",\n    atomic_umin, atomic_umax,\n    16,\n    u128 AtomicU128 ATOMIC_U128_INIT\n}\n#[cfg(target_pointer_width = \"16\")]\nmacro_rules! ptr_width {\n    () => { 2 }\n}\n#[cfg(target_pointer_width = \"32\")]\nmacro_rules! ptr_width {\n    () => { 4 }\n}\n#[cfg(target_pointer_width = \"64\")]\nmacro_rules! ptr_width {\n    () => { 8 }\n}\n#[cfg(target_has_atomic = \"ptr\")]\natomic_int!{\n    stable(feature = \"rust1\", since = \"1.0.0\"),\n    stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\"),\n    stable(feature = \"atomic_debug\", since = \"1.3.0\"),\n    stable(feature = \"atomic_access\", since = \"1.15.0\"),\n    stable(feature = \"atomic_from\", since = \"1.23.0\"),\n    stable(feature = \"atomic_nand\", since = \"1.27.0\"),\n    \"isize\", \"../../../std/primitive.isize.html\",\n    \"\",\n    atomic_min, atomic_max,\n    ptr_width!(),\n    isize AtomicIsize ATOMIC_ISIZE_INIT\n}\n#[cfg(target_has_atomic = \"ptr\")]\natomic_int!{\n    stable(feature = \"rust1\", since = \"1.0.0\"),\n    stable(feature = \"extended_compare_and_swap\", since = \"1.10.0\"),\n    stable(feature = \"atomic_debug\", since = \"1.3.0\"),\n    stable(feature = \"atomic_access\", since = \"1.15.0\"),\n    stable(feature = \"atomic_from\", since = \"1.23.0\"),\n    stable(feature = \"atomic_nand\", since = \"1.27.0\"),\n    \"usize\", \"../../../std/primitive.usize.html\",\n    \"\",\n    atomic_umin, atomic_umax,\n    ptr_width!(),\n    usize AtomicUsize ATOMIC_USIZE_INIT\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nfn strongest_failure_ordering(order: Ordering) -> Ordering {\n    match order {\n        Release => Relaxed,\n        Relaxed => Relaxed,\n        SeqCst => SeqCst,\n        Acquire => Acquire,\n        AcqRel => Acquire,\n    }\n}\n\n#[inline]\nunsafe fn atomic_store<T>(dst: *mut T, val: T, order: Ordering) {\n    match order {\n        Release => intrinsics::atomic_store_rel(dst, val),\n        Relaxed => intrinsics::atomic_store_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_store(dst, val),\n        Acquire => panic!(\"there is no such thing as an acquire store\"),\n        AcqRel => panic!(\"there is no such thing as an acquire/release store\"),\n    }\n}\n\n#[inline]\nunsafe fn atomic_load<T>(dst: *const T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_load_acq(dst),\n        Relaxed => intrinsics::atomic_load_relaxed(dst),\n        SeqCst => intrinsics::atomic_load(dst),\n        Release => panic!(\"there is no such thing as a release load\"),\n        AcqRel => panic!(\"there is no such thing as an acquire/release load\"),\n    }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_swap<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_xchg_acq(dst, val),\n        Release => intrinsics::atomic_xchg_rel(dst, val),\n        AcqRel => intrinsics::atomic_xchg_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_xchg_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_xchg(dst, val),\n    }\n}\n\n/// Returns the previous value (like __sync_fetch_and_add).\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_add<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_xadd_acq(dst, val),\n        Release => intrinsics::atomic_xadd_rel(dst, val),\n        AcqRel => intrinsics::atomic_xadd_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_xadd_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_xadd(dst, val),\n    }\n}\n\n/// Returns the previous value (like __sync_fetch_and_sub).\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_sub<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_xsub_acq(dst, val),\n        Release => intrinsics::atomic_xsub_rel(dst, val),\n        AcqRel => intrinsics::atomic_xsub_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_xsub_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_xsub(dst, val),\n    }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_compare_exchange<T>(dst: *mut T,\n                                     old: T,\n                                     new: T,\n                                     success: Ordering,\n                                     failure: Ordering)\n                                     -> Result<T, T> {\n    let (val, ok) = match (success, failure) {\n        (Acquire, Acquire) => intrinsics::atomic_cxchg_acq(dst, old, new),\n        (Release, Relaxed) => intrinsics::atomic_cxchg_rel(dst, old, new),\n        (AcqRel, Acquire) => intrinsics::atomic_cxchg_acqrel(dst, old, new),\n        (Relaxed, Relaxed) => intrinsics::atomic_cxchg_relaxed(dst, old, new),\n        (SeqCst, SeqCst) => intrinsics::atomic_cxchg(dst, old, new),\n        (Acquire, Relaxed) => intrinsics::atomic_cxchg_acq_failrelaxed(dst, old, new),\n        (AcqRel, Relaxed) => intrinsics::atomic_cxchg_acqrel_failrelaxed(dst, old, new),\n        (SeqCst, Relaxed) => intrinsics::atomic_cxchg_failrelaxed(dst, old, new),\n        (SeqCst, Acquire) => intrinsics::atomic_cxchg_failacq(dst, old, new),\n        (_, AcqRel) => panic!(\"there is no such thing as an acquire/release failure ordering\"),\n        (_, Release) => panic!(\"there is no such thing as a release failure ordering\"),\n        _ => panic!(\"a failure ordering can't be stronger than a success ordering\"),\n    };\n    if ok { Ok(val) } else { Err(val) }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_compare_exchange_weak<T>(dst: *mut T,\n                                          old: T,\n                                          new: T,\n                                          success: Ordering,\n                                          failure: Ordering)\n                                          -> Result<T, T> {\n    let (val, ok) = match (success, failure) {\n        (Acquire, Acquire) => intrinsics::atomic_cxchgweak_acq(dst, old, new),\n        (Release, Relaxed) => intrinsics::atomic_cxchgweak_rel(dst, old, new),\n        (AcqRel, Acquire) => intrinsics::atomic_cxchgweak_acqrel(dst, old, new),\n        (Relaxed, Relaxed) => intrinsics::atomic_cxchgweak_relaxed(dst, old, new),\n        (SeqCst, SeqCst) => intrinsics::atomic_cxchgweak(dst, old, new),\n        (Acquire, Relaxed) => intrinsics::atomic_cxchgweak_acq_failrelaxed(dst, old, new),\n        (AcqRel, Relaxed) => intrinsics::atomic_cxchgweak_acqrel_failrelaxed(dst, old, new),\n        (SeqCst, Relaxed) => intrinsics::atomic_cxchgweak_failrelaxed(dst, old, new),\n        (SeqCst, Acquire) => intrinsics::atomic_cxchgweak_failacq(dst, old, new),\n        (_, AcqRel) => panic!(\"there is no such thing as an acquire/release failure ordering\"),\n        (_, Release) => panic!(\"there is no such thing as a release failure ordering\"),\n        _ => panic!(\"a failure ordering can't be stronger than a success ordering\"),\n    };\n    if ok { Ok(val) } else { Err(val) }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_and<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_and_acq(dst, val),\n        Release => intrinsics::atomic_and_rel(dst, val),\n        AcqRel => intrinsics::atomic_and_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_and_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_and(dst, val),\n    }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_nand<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_nand_acq(dst, val),\n        Release => intrinsics::atomic_nand_rel(dst, val),\n        AcqRel => intrinsics::atomic_nand_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_nand_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_nand(dst, val),\n    }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_or<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_or_acq(dst, val),\n        Release => intrinsics::atomic_or_rel(dst, val),\n        AcqRel => intrinsics::atomic_or_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_or_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_or(dst, val),\n    }\n}\n\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_xor<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_xor_acq(dst, val),\n        Release => intrinsics::atomic_xor_rel(dst, val),\n        AcqRel => intrinsics::atomic_xor_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_xor_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_xor(dst, val),\n    }\n}\n\n/// returns the max value (signed comparison)\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_max<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_max_acq(dst, val),\n        Release => intrinsics::atomic_max_rel(dst, val),\n        AcqRel => intrinsics::atomic_max_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_max_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_max(dst, val),\n    }\n}\n\n/// returns the min value (signed comparison)\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_min<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_min_acq(dst, val),\n        Release => intrinsics::atomic_min_rel(dst, val),\n        AcqRel => intrinsics::atomic_min_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_min_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_min(dst, val),\n    }\n}\n\n/// returns the max value (signed comparison)\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_umax<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_umax_acq(dst, val),\n        Release => intrinsics::atomic_umax_rel(dst, val),\n        AcqRel => intrinsics::atomic_umax_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_umax_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_umax(dst, val),\n    }\n}\n\n/// returns the min value (signed comparison)\n#[inline]\n#[cfg(target_has_atomic = \"cas\")]\nunsafe fn atomic_umin<T>(dst: *mut T, val: T, order: Ordering) -> T {\n    match order {\n        Acquire => intrinsics::atomic_umin_acq(dst, val),\n        Release => intrinsics::atomic_umin_rel(dst, val),\n        AcqRel => intrinsics::atomic_umin_acqrel(dst, val),\n        Relaxed => intrinsics::atomic_umin_relaxed(dst, val),\n        SeqCst => intrinsics::atomic_umin(dst, val),\n    }\n}\n\n/// An atomic fence.\n///\n/// Depending on the specified order, a fence prevents the compiler and CPU from\n/// reordering certain types of memory operations around it.\n/// That creates synchronizes-with relationships between it and atomic operations\n/// or fences in other threads.\n///\n/// A fence 'A' which has (at least) [`Release`] ordering semantics, synchronizes\n/// with a fence 'B' with (at least) [`Acquire`] semantics, if and only if there\n/// exist operations X and Y, both operating on some atomic object 'M' such\n/// that A is sequenced before X, Y is synchronized before B and Y observes\n/// the change to M. This provides a happens-before dependence between A and B.\n///\n/// ```text\n///     Thread 1                                          Thread 2\n///\n/// fence(Release);      A --------------\n/// x.store(3, Relaxed); X ---------    |\n///                                |    |\n///                                |    |\n///                                -------------> Y  if x.load(Relaxed) == 3 {\n///                                     |-------> B      fence(Acquire);\n///                                                      ...\n///                                                  }\n/// ```\n///\n/// Atomic operations with [`Release`] or [`Acquire`] semantics can also synchronize\n/// with a fence.\n///\n/// A fence which has [`SeqCst`] ordering, in addition to having both [`Acquire`]\n/// and [`Release`] semantics, participates in the global program order of the\n/// other [`SeqCst`] operations and/or fences.\n///\n/// Accepts [`Acquire`], [`Release`], [`AcqRel`] and [`SeqCst`] orderings.\n///\n/// # Panics\n///\n/// Panics if `order` is [`Relaxed`].\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::atomic::AtomicBool;\n/// use std::sync::atomic::fence;\n/// use std::sync::atomic::Ordering;\n///\n/// // A mutual exclusion primitive based on spinlock.\n/// pub struct Mutex {\n///     flag: AtomicBool,\n/// }\n///\n/// impl Mutex {\n///     pub fn new() -> Mutex {\n///         Mutex {\n///             flag: AtomicBool::new(false),\n///         }\n///     }\n///\n///     pub fn lock(&self) {\n///         while !self.flag.compare_and_swap(false, true, Ordering::Relaxed) {}\n///         // This fence synchronizes-with store in `unlock`.\n///         fence(Ordering::Acquire);\n///     }\n///\n///     pub fn unlock(&self) {\n///         self.flag.store(false, Ordering::Release);\n///     }\n/// }\n/// ```\n///\n/// [`Ordering`]: enum.Ordering.html\n/// [`Acquire`]: enum.Ordering.html#variant.Acquire\n/// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n/// [`Release`]: enum.Ordering.html#variant.Release\n/// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n/// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[cfg_attr(target_arch = \"wasm32\", allow(unused_variables))]\npub fn fence(order: Ordering) {\n    // On wasm32 it looks like fences aren't implemented in LLVM yet in that\n    // they will cause LLVM to abort. The wasm instruction set doesn't have\n    // fences right now. There's discussion online about the best way for tools\n    // to conventionally implement fences at\n    // https://github.com/WebAssembly/tool-conventions/issues/59. We should\n    // follow that discussion and implement a solution when one comes about!\n    #[cfg(not(target_arch = \"wasm32\"))]\n    unsafe {\n        match order {\n            Acquire => intrinsics::atomic_fence_acq(),\n            Release => intrinsics::atomic_fence_rel(),\n            AcqRel => intrinsics::atomic_fence_acqrel(),\n            SeqCst => intrinsics::atomic_fence(),\n            Relaxed => panic!(\"there is no such thing as a relaxed fence\"),\n        }\n    }\n}\n\n\n/// A compiler memory fence.\n///\n/// `compiler_fence` does not emit any machine code, but restricts the kinds\n/// of memory re-ordering the compiler is allowed to do. Specifically, depending on\n/// the given [`Ordering`] semantics, the compiler may be disallowed from moving reads\n/// or writes from before or after the call to the other side of the call to\n/// `compiler_fence`. Note that it does **not** prevent the *hardware*\n/// from doing such re-ordering. This is not a problem in a single-threaded,\n/// execution context, but when other threads may modify memory at the same\n/// time, stronger synchronization primitives such as [`fence`] are required.\n///\n/// The re-ordering prevented by the different ordering semantics are:\n///\n///  - with [`SeqCst`], no re-ordering of reads and writes across this point is allowed.\n///  - with [`Release`], preceding reads and writes cannot be moved past subsequent writes.\n///  - with [`Acquire`], subsequent reads and writes cannot be moved ahead of preceding reads.\n///  - with [`AcqRel`], both of the above rules are enforced.\n///\n/// `compiler_fence` is generally only useful for preventing a thread from\n/// racing *with itself*. That is, if a given thread is executing one piece\n/// of code, and is then interrupted, and starts executing code elsewhere\n/// (while still in the same thread, and conceptually still on the same\n/// core). In traditional programs, this can only occur when a signal\n/// handler is registered. In more low-level code, such situations can also\n/// arise when handling interrupts, when implementing green threads with\n/// pre-emption, etc. Curious readers are encouraged to read the Linux kernel's\n/// discussion of [memory barriers].\n///\n/// # Panics\n///\n/// Panics if `order` is [`Relaxed`].\n///\n/// # Examples\n///\n/// Without `compiler_fence`, the `assert_eq!` in following code\n/// is *not* guaranteed to succeed, despite everything happening in a single thread.\n/// To see why, remember that the compiler is free to swap the stores to\n/// `IMPORTANT_VARIABLE` and `IS_READ` since they are both\n/// `Ordering::Relaxed`. If it does, and the signal handler is invoked right\n/// after `IS_READY` is updated, then the signal handler will see\n/// `IS_READY=1`, but `IMPORTANT_VARIABLE=0`.\n/// Using a `compiler_fence` remedies this situation.\n///\n/// ```\n/// use std::sync::atomic::{AtomicBool, AtomicUsize};\n/// use std::sync::atomic::{ATOMIC_BOOL_INIT, ATOMIC_USIZE_INIT};\n/// use std::sync::atomic::Ordering;\n/// use std::sync::atomic::compiler_fence;\n///\n/// static IMPORTANT_VARIABLE: AtomicUsize = ATOMIC_USIZE_INIT;\n/// static IS_READY: AtomicBool = ATOMIC_BOOL_INIT;\n///\n/// fn main() {\n///     IMPORTANT_VARIABLE.store(42, Ordering::Relaxed);\n///     // prevent earlier writes from being moved beyond this point\n///     compiler_fence(Ordering::Release);\n///     IS_READY.store(true, Ordering::Relaxed);\n/// }\n///\n/// fn signal_handler() {\n///     if IS_READY.load(Ordering::Relaxed) {\n///         assert_eq!(IMPORTANT_VARIABLE.load(Ordering::Relaxed), 42);\n///     }\n/// }\n/// ```\n///\n/// [`fence`]: fn.fence.html\n/// [`Ordering`]: enum.Ordering.html\n/// [`Acquire`]: enum.Ordering.html#variant.Acquire\n/// [`SeqCst`]: enum.Ordering.html#variant.SeqCst\n/// [`Release`]: enum.Ordering.html#variant.Release\n/// [`AcqRel`]: enum.Ordering.html#variant.AcqRel\n/// [`Relaxed`]: enum.Ordering.html#variant.Relaxed\n/// [memory barriers]: https://www.kernel.org/doc/Documentation/memory-barriers.txt\n#[inline]\n#[stable(feature = \"compiler_fences\", since = \"1.21.0\")]\npub fn compiler_fence(order: Ordering) {\n    unsafe {\n        match order {\n            Acquire => intrinsics::atomic_singlethreadfence_acq(),\n            Release => intrinsics::atomic_singlethreadfence_rel(),\n            AcqRel => intrinsics::atomic_singlethreadfence_acqrel(),\n            SeqCst => intrinsics::atomic_singlethreadfence(),\n            Relaxed => panic!(\"there is no such thing as a relaxed compiler fence\"),\n        }\n    }\n}\n\n\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"atomic_debug\", since = \"1.3.0\")]\nimpl fmt::Debug for AtomicBool {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)\n    }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"atomic_debug\", since = \"1.3.0\")]\nimpl<T> fmt::Debug for AtomicPtr<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.load(Ordering::SeqCst), f)\n    }\n}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"atomic_pointer\", since = \"1.24.0\")]\nimpl<T> fmt::Pointer for AtomicPtr<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&self.load(Ordering::SeqCst), f)\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! System bindings for the wasm/web platform\n//!\n//! This module contains the facade (aka platform-specific) implementations of\n//! OS level functionality for wasm. Note that this wasm is *not* the emscripten\n//! wasm, so we have no runtime here.\n//!\n//! This is all super highly experimental and not actually intended for\n//! wide/production use yet, it's still all in the experimental category. This\n//! will likely change over time.\n//!\n//! Currently all functions here are basically stubs that immediately return\n//! errors. The hope is that with a portability lint we can turn actually just\n//! remove all this and just omit parts of the standard library if we're\n//! compiling for wasm. That way it's a compile time error for something that's\n//! guaranteed to be a runtime error!\n\nuse io;\nuse os::raw::c_char;\nuse ptr;\nuse sys::os_str::Buf;\nuse sys_common::{AsInner, FromInner};\nuse ffi::{OsString, OsStr};\nuse time::Duration;\n\npub mod args;\n#[cfg(feature = \"backtrace\")]\npub mod backtrace;\npub mod cmath;\npub mod env;\npub mod fs;\npub mod memchr;\npub mod net;\npub mod os;\npub mod os_str;\npub mod path;\npub mod pipe;\npub mod process;\npub mod stack_overflow;\npub mod thread;\npub mod time;\npub mod stdio;\n\ncfg_if! {\n    if #[cfg(target_feature = \"atomics\")] {\n        #[path = \"condvar_atomics.rs\"]\n        pub mod condvar;\n        #[path = \"mutex_atomics.rs\"]\n        pub mod mutex;\n        #[path = \"rwlock_atomics.rs\"]\n        pub mod rwlock;\n        #[path = \"thread_local_atomics.rs\"]\n        pub mod thread_local;\n    } else {\n        pub mod condvar;\n        pub mod mutex;\n        pub mod rwlock;\n        pub mod thread_local;\n    }\n}\n\n#[cfg(not(test))]\npub fn init() {\n}\n\npub fn unsupported<T>() -> io::Result<T> {\n    Err(unsupported_err())\n}\n\npub fn unsupported_err() -> io::Error {\n    io::Error::new(io::ErrorKind::Other,\n                   \"operation not supported on wasm yet\")\n}\n\npub fn decode_error_kind(_code: i32) -> io::ErrorKind {\n    io::ErrorKind::Other\n}\n\n// This enum is used as the storage for a bunch of types which can't actually\n// exist.\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]\npub enum Void {}\n\npub unsafe fn strlen(mut s: *const c_char) -> usize {\n    let mut n = 0;\n    while *s != 0 {\n        n += 1;\n        s = s.offset(1);\n    }\n    return n\n}\n\npub unsafe fn abort_internal() -> ! {\n    ExitSysCall::perform(1)\n}\n\n// We don't have randomness yet, but I totally used a random number generator to\n// generate these numbers.\n//\n// More seriously though this is just for DOS protection in hash maps. It's ok\n// if we don't do that on wasm just yet.\npub fn hashmap_random_keys() -> (u64, u64) {\n    (1, 2)\n}\n\n// Implement a minimal set of system calls to enable basic IO\npub enum SysCallIndex {\n    Read = 0,\n    Write = 1,\n    Exit = 2,\n    Args = 3,\n    GetEnv = 4,\n    SetEnv = 5,\n    Time = 6,\n}\n\n#[repr(C)]\npub struct ReadSysCall {\n    fd: usize,\n    ptr: *mut u8,\n    len: usize,\n    result: usize,\n}\n\nimpl ReadSysCall {\n    pub fn perform(fd: usize, buffer: &mut [u8]) -> usize {\n        let mut call_record = ReadSysCall {\n            fd,\n            len: buffer.len(),\n            ptr: buffer.as_mut_ptr(),\n            result: 0\n        };\n        if unsafe { syscall(SysCallIndex::Read, &mut call_record) } {\n            call_record.result\n        } else {\n            0\n        }\n    }\n}\n\n#[repr(C)]\npub struct WriteSysCall {\n    fd: usize,\n    ptr: *const u8,\n    len: usize,\n}\n\nimpl WriteSysCall {\n    pub fn perform(fd: usize, buffer: &[u8]) {\n        let mut call_record = WriteSysCall {\n            fd,\n            len: buffer.len(),\n            ptr: buffer.as_ptr()\n        };\n        unsafe { syscall(SysCallIndex::Write, &mut call_record); }\n    }\n}\n\n#[repr(C)]\npub struct ExitSysCall {\n    code: usize,\n}\n\nimpl ExitSysCall {\n    pub fn perform(code: usize) -> ! {\n        let mut call_record = ExitSysCall {\n            code\n        };\n        unsafe {\n            syscall(SysCallIndex::Exit, &mut call_record);\n            ::intrinsics::abort();\n        }\n    }\n}\n\nfn receive_buffer<E, F: FnMut(&mut [u8]) -> Result<usize, E>>(estimate: usize, mut f: F)\n    -> Result<Vec<u8>, E>\n{\n    let mut buffer = vec![0; estimate];\n    loop {\n        let result = f(&mut buffer)?;\n        if result <= buffer.len() {\n            buffer.truncate(result);\n            break;\n        }\n        buffer.resize(result, 0);\n    }\n    Ok(buffer)\n}\n\n#[repr(C)]\npub struct ArgsSysCall {\n    ptr: *mut u8,\n    len: usize,\n    result: usize\n}\n\nimpl ArgsSysCall {\n    pub fn perform() -> Vec<OsString> {\n        receive_buffer(1024, |buffer| -> Result<usize, !> {\n            let mut call_record = ArgsSysCall {\n                len: buffer.len(),\n                ptr: buffer.as_mut_ptr(),\n                result: 0\n            };\n            if unsafe { syscall(SysCallIndex::Args, &mut call_record) } {\n                Ok(call_record.result)\n            } else {\n                Ok(0)\n            }\n        })\n            .unwrap()\n            .split(|b| *b == 0)\n            .map(|s| FromInner::from_inner(Buf { inner: s.to_owned() }))\n            .collect()\n    }\n}\n\n#[repr(C)]\npub struct GetEnvSysCall {\n    key_ptr: *const u8,\n    key_len: usize,\n    value_ptr: *mut u8,\n    value_len: usize,\n    result: usize\n}\n\nimpl GetEnvSysCall {\n    pub fn perform(key: &OsStr) -> Option<OsString> {\n        let key_buf = &AsInner::as_inner(key).inner;\n        receive_buffer(64, |buffer| {\n            let mut call_record = GetEnvSysCall {\n                key_len: key_buf.len(),\n                key_ptr: key_buf.as_ptr(),\n                value_len: buffer.len(),\n                value_ptr: buffer.as_mut_ptr(),\n                result: !0usize\n            };\n            if unsafe { syscall(SysCallIndex::GetEnv, &mut call_record) } {\n                if call_record.result == !0usize {\n                    Err(())\n                } else {\n                    Ok(call_record.result)\n                }\n            } else {\n                Err(())\n            }\n        }).ok().map(|s| {\n            FromInner::from_inner(Buf { inner: s })\n        })\n    }\n}\n\n#[repr(C)]\npub struct SetEnvSysCall {\n    key_ptr: *const u8,\n    key_len: usize,\n    value_ptr: *const u8,\n    value_len: usize\n}\n\nimpl SetEnvSysCall {\n    pub fn perform(key: &OsStr, value: Option<&OsStr>) {\n        let key_buf = &AsInner::as_inner(key).inner;\n        let value_buf = value.map(|v| &AsInner::as_inner(v).inner);\n        let mut call_record = SetEnvSysCall {\n            key_len: key_buf.len(),\n            key_ptr: key_buf.as_ptr(),\n            value_len: value_buf.map(|v| v.len()).unwrap_or(!0usize),\n            value_ptr: value_buf.map(|v| v.as_ptr()).unwrap_or(ptr::null())\n        };\n        unsafe { syscall(SysCallIndex::SetEnv, &mut call_record); }\n    }\n}\n\npub enum TimeClock {\n    Monotonic = 0,\n    System = 1,\n}\n\n#[repr(C)]\npub struct TimeSysCall {\n    clock: usize,\n    secs_hi: usize,\n    secs_lo: usize,\n    nanos: usize\n}\n\nimpl TimeSysCall {\n    pub fn perform(clock: TimeClock) -> Duration {\n        let mut call_record = TimeSysCall {\n            clock: clock as usize,\n            secs_hi: 0,\n            secs_lo: 0,\n            nanos: 0\n        };\n        if unsafe { syscall(SysCallIndex::Time, &mut call_record) } {\n            Duration::new(\n                ((call_record.secs_hi as u64) << 32) | (call_record.secs_lo as u64),\n                call_record.nanos as u32\n            )\n        } else {\n            panic!(\"Time system call is not implemented by WebAssembly host\");\n        }\n    }\n}\n\nunsafe fn syscall<T>(index: SysCallIndex, data: &mut T) -> bool {\n    #[cfg(feature = \"wasm_syscall\")]\n    extern {\n        #[no_mangle]\n        fn rust_wasm_syscall(index: usize, data: *mut Void) -> usize;\n    }\n\n    #[cfg(not(feature = \"wasm_syscall\"))]\n    unsafe fn rust_wasm_syscall(_index: usize, _data: *mut Void) -> usize { 0 }\n\n    rust_wasm_syscall(index as usize, data as *mut T as *mut Void) != 0\n}\n","#![cfg_attr(feature = \"allocator-api\", feature(allocator_api, alloc))]\n#![cfg_attr(target_arch = \"wasm32\", feature(link_llvm_intrinsics))]\n#![cfg_attr(not(feature = \"allocator-api\"), allow(dead_code))]\n#![no_std]\n\n#[cfg(feature = \"allocator-api\")]\nextern crate alloc;\n\n#[cfg(feature = \"allocator-api\")]\nuse alloc::heap::{Alloc, Layout, AllocErr};\nuse core::cmp;\nuse core::ptr;\n\n#[cfg(feature = \"allocator-api\")]\npub use self::global::GlobalDlmalloc;\n\n#[cfg(feature = \"allocator-api\")]\nmod global;\nmod dlmalloc;\n\npub struct Dlmalloc(dlmalloc::Dlmalloc);\n\npub const DLMALLOC_INIT: Dlmalloc = Dlmalloc(dlmalloc::DLMALLOC_INIT);\n\n#[cfg(target_arch = \"wasm32\")]\n#[path = \"wasm.rs\"]\nmod sys;\n\n#[cfg(target_os = \"macos\")]\n#[path = \"macos.rs\"]\nmod sys;\n\n#[cfg(target_os = \"linux\")]\n#[path = \"linux.rs\"]\nmod sys;\n\nimpl Dlmalloc {\n    pub fn new() -> Dlmalloc {\n        Dlmalloc(dlmalloc::Dlmalloc::new())\n    }\n\n    #[inline]\n    pub unsafe fn malloc(&mut self, size: usize, align: usize) -> *mut u8 {\n        if align <= self.0.malloc_alignment() {\n            self.0.malloc(size)\n        } else {\n            self.0.memalign(align, size)\n        }\n    }\n\n    #[inline]\n    pub unsafe fn calloc(&mut self, size: usize, align: usize) -> *mut u8 {\n        let ptr = self.malloc(size, align);\n        if !ptr.is_null() && self.0.calloc_must_clear(ptr) {\n            ptr::write_bytes(ptr, 0, size);\n        }\n        ptr\n    }\n\n    #[inline]\n    pub unsafe fn free(&mut self, ptr: *mut u8, size: usize, align: usize) {\n        drop((size, align));\n        self.0.free(ptr)\n    }\n\n    #[inline]\n    pub unsafe fn realloc(&mut self,\n                          ptr: *mut u8,\n                          old_size: usize,\n                          old_align: usize,\n                          new_size: usize) -> *mut u8 {\n        if old_align <= self.0.malloc_alignment() {\n            self.0.realloc(ptr, new_size)\n        } else {\n            let res = self.malloc(new_size, old_align);\n            if !res.is_null() {\n                let size = cmp::min(old_size, new_size);\n                ptr::copy_nonoverlapping(ptr, res, size);\n                self.free(ptr, old_size, old_align);\n            }\n            res\n        }\n    }\n}\n\n#[cfg(feature = \"allocator-api\")]\nunsafe impl Alloc for Dlmalloc {\n    #[inline]\n    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {\n        let ptr = <Dlmalloc>::malloc(self, layout.size(), layout.align());\n        if ptr.is_null() {\n            Err(AllocErr::Exhausted { request: layout })\n        } else {\n            Ok(ptr)\n        }\n    }\n\n    #[inline]\n    unsafe fn alloc_zeroed(&mut self, layout: Layout)\n        -> Result<*mut u8, AllocErr>\n    {\n        let ptr = <Dlmalloc>::calloc(self, layout.size(), layout.align());\n        if ptr.is_null() {\n            Err(AllocErr::Exhausted { request: layout })\n        } else {\n            Ok(ptr)\n        }\n    }\n\n    #[inline]\n    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {\n        <Dlmalloc>::free(self, ptr, layout.size(), layout.align())\n    }\n\n    #[inline]\n    unsafe fn realloc(&mut self,\n                      ptr: *mut u8,\n                      old_layout: Layout,\n                      new_layout: Layout) -> Result<*mut u8, AllocErr> {\n        if old_layout.align() != new_layout.align() {\n            return Err(AllocErr::Unsupported {\n                details: \"cannot change alignment on `realloc`\",\n            })\n        }\n        let ptr = <Dlmalloc>::realloc(\n            self,\n            ptr,\n            old_layout.size(),\n            old_layout.align(),\n            new_layout.size(),\n        );\n\n\n        if ptr.is_null() {\n            Err(AllocErr::Exhausted { request: new_layout })\n        } else {\n            Ok(ptr)\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Implementation of various bits and pieces of the `panic!` macro and\n//! associated runtime pieces.\n//!\n//! Specifically, this module contains the implementation of:\n//!\n//! * Panic hooks\n//! * Executing a panic up to doing the actual implementation\n//! * Shims around \"try\"\n\nuse core::panic::BoxMeUp;\n\nuse io::prelude::*;\n\nuse any::Any;\nuse cell::RefCell;\nuse core::panic::{PanicInfo, Location};\nuse fmt;\nuse intrinsics;\nuse mem;\nuse ptr;\nuse raw;\nuse sys::stdio::{Stderr, stderr_prints_nothing};\nuse sys_common::rwlock::RWLock;\nuse sys_common::thread_info;\nuse sys_common::util;\nuse thread;\n\nthread_local! {\n    pub static LOCAL_STDERR: RefCell<Option<Box<dyn Write + Send>>> = {\n        RefCell::new(None)\n    }\n}\n\n// Binary interface to the panic runtime that the standard library depends on.\n//\n// The standard library is tagged with `#![needs_panic_runtime]` (introduced in\n// RFC 1513) to indicate that it requires some other crate tagged with\n// `#![panic_runtime]` to exist somewhere. Each panic runtime is intended to\n// implement these symbols (with the same signatures) so we can get matched up\n// to them.\n//\n// One day this may look a little less ad-hoc with the compiler helping out to\n// hook up these functions, but it is not this day!\n#[allow(improper_ctypes)]\nextern {\n    fn __rust_maybe_catch_panic(f: fn(*mut u8),\n                                data: *mut u8,\n                                data_ptr: *mut usize,\n                                vtable_ptr: *mut usize) -> u32;\n    #[unwind(allowed)]\n    fn __rust_start_panic(payload: usize) -> u32;\n}\n\n#[derive(Copy, Clone)]\nenum Hook {\n    Default,\n    Custom(*mut (dyn Fn(&PanicInfo) + 'static + Sync + Send)),\n}\n\nstatic HOOK_LOCK: RWLock = RWLock::new();\nstatic mut HOOK: Hook = Hook::Default;\n\n/// Registers a custom panic hook, replacing any that was previously registered.\n///\n/// The panic hook is invoked when a thread panics, but before the panic runtime\n/// is invoked. As such, the hook will run with both the aborting and unwinding\n/// runtimes. The default hook prints a message to standard error and generates\n/// a backtrace if requested, but this behavior can be customized with the\n/// `set_hook` and [`take_hook`] functions.\n///\n/// [`take_hook`]: ./fn.take_hook.html\n///\n/// The hook is provided with a `PanicInfo` struct which contains information\n/// about the origin of the panic, including the payload passed to `panic!` and\n/// the source code location from which the panic originated.\n///\n/// The panic hook is a global resource.\n///\n/// # Panics\n///\n/// Panics if called from a panicking thread.\n///\n/// # Examples\n///\n/// The following will print \"Custom panic hook\":\n///\n/// ```should_panic\n/// use std::panic;\n///\n/// panic::set_hook(Box::new(|_| {\n///     println!(\"Custom panic hook\");\n/// }));\n///\n/// panic!(\"Normal panic\");\n/// ```\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\npub fn set_hook(hook: Box<dyn Fn(&PanicInfo) + 'static + Sync + Send>) {\n    if thread::panicking() {\n        panic!(\"cannot modify the panic hook from a panicking thread\");\n    }\n\n    unsafe {\n        HOOK_LOCK.write();\n        let old_hook = HOOK;\n        HOOK = Hook::Custom(Box::into_raw(hook));\n        HOOK_LOCK.write_unlock();\n\n        if let Hook::Custom(ptr) = old_hook {\n            Box::from_raw(ptr);\n        }\n    }\n}\n\n/// Unregisters the current panic hook, returning it.\n///\n/// *See also the function [`set_hook`].*\n///\n/// [`set_hook`]: ./fn.set_hook.html\n///\n/// If no custom hook is registered, the default hook will be returned.\n///\n/// # Panics\n///\n/// Panics if called from a panicking thread.\n///\n/// # Examples\n///\n/// The following will print \"Normal panic\":\n///\n/// ```should_panic\n/// use std::panic;\n///\n/// panic::set_hook(Box::new(|_| {\n///     println!(\"Custom panic hook\");\n/// }));\n///\n/// let _ = panic::take_hook();\n///\n/// panic!(\"Normal panic\");\n/// ```\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\npub fn take_hook() -> Box<dyn Fn(&PanicInfo) + 'static + Sync + Send> {\n    if thread::panicking() {\n        panic!(\"cannot modify the panic hook from a panicking thread\");\n    }\n\n    unsafe {\n        HOOK_LOCK.write();\n        let hook = HOOK;\n        HOOK = Hook::Default;\n        HOOK_LOCK.write_unlock();\n\n        match hook {\n            Hook::Default => Box::new(default_hook),\n            Hook::Custom(ptr) => Box::from_raw(ptr),\n        }\n    }\n}\n\nfn default_hook(info: &PanicInfo) {\n    #[cfg(feature = \"backtrace\")]\n    use sys_common::backtrace;\n\n    // If this is a double panic, make sure that we print a backtrace\n    // for this panic. Otherwise only print it if logging is enabled.\n    #[cfg(feature = \"backtrace\")]\n    let log_backtrace = {\n        let panics = update_panic_count(0);\n\n        if panics >= 2 {\n            Some(backtrace::PrintFormat::Full)\n        } else {\n            backtrace::log_enabled()\n        }\n    };\n\n    let location = info.location().unwrap();  // The current implementation always returns Some\n\n    let msg = match info.payload().downcast_ref::<&'static str>() {\n        Some(s) => *s,\n        None => match info.payload().downcast_ref::<String>() {\n            Some(s) => &s[..],\n            None => \"Box<Any>\",\n        }\n    };\n    let mut err = Stderr::new().ok();\n    let thread = thread_info::current_thread();\n    let name = thread.as_ref().and_then(|t| t.name()).unwrap_or(\"<unnamed>\");\n\n    let write = |err: &mut dyn (::io::Write)| {\n        let _ = writeln!(err, \"thread '{}' panicked at '{}', {}\",\n                         name, msg, location);\n\n        #[cfg(feature = \"backtrace\")]\n        {\n            use sync::atomic::{AtomicBool, Ordering};\n\n            static FIRST_PANIC: AtomicBool = AtomicBool::new(true);\n\n            if let Some(format) = log_backtrace {\n                let _ = backtrace::print(err, format);\n            } else if FIRST_PANIC.compare_and_swap(true, false, Ordering::SeqCst) {\n                let _ = writeln!(err, \"note: Run with `RUST_BACKTRACE=1` for a backtrace.\");\n            }\n        }\n    };\n\n    let prev = LOCAL_STDERR.with(|s| s.borrow_mut().take());\n    match (prev, err.as_mut()) {\n       (Some(mut stderr), _) => {\n           write(&mut *stderr);\n           let mut s = Some(stderr);\n           LOCAL_STDERR.with(|slot| {\n               *slot.borrow_mut() = s.take();\n           });\n       }\n       (None, Some(ref mut err)) => { write(err) }\n       _ => {}\n    }\n}\n\n\n#[cfg(not(test))]\n#[doc(hidden)]\n#[unstable(feature = \"update_panic_count\", issue = \"0\")]\npub fn update_panic_count(amt: isize) -> usize {\n    use cell::Cell;\n    thread_local! { static PANIC_COUNT: Cell<usize> = Cell::new(0) }\n\n    PANIC_COUNT.with(|c| {\n        let next = (c.get() as isize + amt) as usize;\n        c.set(next);\n        return next\n    })\n}\n\n#[cfg(test)]\npub use realstd::rt::update_panic_count;\n\n/// Invoke a closure, capturing the cause of an unwinding panic if one occurs.\npub unsafe fn try<R, F: FnOnce() -> R>(f: F) -> Result<R, Box<dyn Any + Send>> {\n    #[allow(unions_with_drop_fields)]\n    union Data<F, R> {\n        f: F,\n        r: R,\n    }\n\n    // We do some sketchy operations with ownership here for the sake of\n    // performance. We can only  pass pointers down to\n    // `__rust_maybe_catch_panic` (can't pass objects by value), so we do all\n    // the ownership tracking here manually using a union.\n    //\n    // We go through a transition where:\n    //\n    // * First, we set the data to be the closure that we're going to call.\n    // * When we make the function call, the `do_call` function below, we take\n    //   ownership of the function pointer. At this point the `Data` union is\n    //   entirely uninitialized.\n    // * If the closure successfully returns, we write the return value into the\n    //   data's return slot. Note that `ptr::write` is used as it's overwriting\n    //   uninitialized data.\n    // * Finally, when we come back out of the `__rust_maybe_catch_panic` we're\n    //   in one of two states:\n    //\n    //      1. The closure didn't panic, in which case the return value was\n    //         filled in. We move it out of `data` and return it.\n    //      2. The closure panicked, in which case the return value wasn't\n    //         filled in. In this case the entire `data` union is invalid, so\n    //         there is no need to drop anything.\n    //\n    // Once we stack all that together we should have the \"most efficient'\n    // method of calling a catch panic whilst juggling ownership.\n    let mut any_data = 0;\n    let mut any_vtable = 0;\n    let mut data = Data {\n        f,\n    };\n\n    let r = __rust_maybe_catch_panic(do_call::<F, R>,\n                                     &mut data as *mut _ as *mut u8,\n                                     &mut any_data,\n                                     &mut any_vtable);\n\n    return if r == 0 {\n        debug_assert!(update_panic_count(0) == 0);\n        Ok(data.r)\n    } else {\n        update_panic_count(-1);\n        debug_assert!(update_panic_count(0) == 0);\n        Err(mem::transmute(raw::TraitObject {\n            data: any_data as *mut _,\n            vtable: any_vtable as *mut _,\n        }))\n    };\n\n    fn do_call<F: FnOnce() -> R, R>(data: *mut u8) {\n        unsafe {\n            let data = data as *mut Data<F, R>;\n            let f = ptr::read(&mut (*data).f);\n            ptr::write(&mut (*data).r, f());\n        }\n    }\n}\n\n/// Determines whether the current thread is unwinding because of panic.\npub fn panicking() -> bool {\n    update_panic_count(0) != 0\n}\n\n/// Entry point of panic from the libcore crate.\n#[cfg(not(test))]\n#[panic_handler]\n#[unwind(allowed)]\npub fn rust_begin_panic(info: &PanicInfo) -> ! {\n    continue_panic_fmt(&info)\n}\n\n/// The entry point for panicking with a formatted message.\n///\n/// This is designed to reduce the amount of code required at the call\n/// site as much as possible (so that `panic!()` has as low an impact\n/// on (e.g.) the inlining of other functions as possible), by moving\n/// the actual formatting into this shared place.\n#[unstable(feature = \"libstd_sys_internals\",\n           reason = \"used by the panic! macro\",\n           issue = \"0\")]\n#[inline(never)] #[cold]\npub fn begin_panic_fmt(msg: &fmt::Arguments,\n                       file_line_col: &(&'static str, u32, u32)) -> ! {\n    let (file, line, col) = *file_line_col;\n    let info = PanicInfo::internal_constructor(\n        Some(msg),\n        Location::internal_constructor(file, line, col),\n    );\n    continue_panic_fmt(&info)\n}\n\nfn continue_panic_fmt(info: &PanicInfo) -> ! {\n    struct PanicPayload<'a> {\n        inner: &'a fmt::Arguments<'a>,\n        string: Option<String>,\n    }\n\n    impl<'a> PanicPayload<'a> {\n        fn new(inner: &'a fmt::Arguments<'a>) -> PanicPayload<'a> {\n            PanicPayload { inner, string: None }\n        }\n\n        fn fill(&mut self) -> &mut String {\n            use fmt::Write;\n\n            let inner = self.inner;\n            self.string.get_or_insert_with(|| {\n                let mut s = String::new();\n                drop(s.write_fmt(*inner));\n                s\n            })\n        }\n    }\n\n    unsafe impl<'a> BoxMeUp for PanicPayload<'a> {\n        fn box_me_up(&mut self) -> *mut (dyn Any + Send) {\n            let contents = mem::replace(self.fill(), String::new());\n            Box::into_raw(Box::new(contents))\n        }\n\n        fn get(&mut self) -> &(dyn Any + Send) {\n            self.fill()\n        }\n    }\n\n    // We do two allocations here, unfortunately. But (a) they're\n    // required with the current scheme, and (b) we don't handle\n    // panic + OOM properly anyway (see comment in begin_panic\n    // below).\n\n    let loc = info.location().unwrap(); // The current implementation always returns Some\n    let msg = info.message().unwrap(); // The current implementation always returns Some\n    let file_line_col = (loc.file(), loc.line(), loc.column());\n    rust_panic_with_hook(\n        &mut PanicPayload::new(msg),\n        info.message(),\n        &file_line_col);\n}\n\n/// This is the entry point of panicking for panic!() and assert!().\n#[unstable(feature = \"libstd_sys_internals\",\n           reason = \"used by the panic! macro\",\n           issue = \"0\")]\n#[cfg_attr(not(test), lang = \"begin_panic\")]\n#[inline(never)] #[cold] // avoid code bloat at the call sites as much as possible\npub fn begin_panic<M: Any + Send>(msg: M, file_line_col: &(&'static str, u32, u32)) -> ! {\n    // Note that this should be the only allocation performed in this code path.\n    // Currently this means that panic!() on OOM will invoke this code path,\n    // but then again we're not really ready for panic on OOM anyway. If\n    // we do start doing this, then we should propagate this allocation to\n    // be performed in the parent of this thread instead of the thread that's\n    // panicking.\n\n    rust_panic_with_hook(&mut PanicPayload::new(msg), None, file_line_col);\n\n    struct PanicPayload<A> {\n        inner: Option<A>,\n    }\n\n    impl<A: Send + 'static> PanicPayload<A> {\n        fn new(inner: A) -> PanicPayload<A> {\n            PanicPayload { inner: Some(inner) }\n        }\n    }\n\n    unsafe impl<A: Send + 'static> BoxMeUp for PanicPayload<A> {\n        fn box_me_up(&mut self) -> *mut (dyn Any + Send) {\n            let data = match self.inner.take() {\n                Some(a) => Box::new(a) as Box<dyn Any + Send>,\n                None => Box::new(()),\n            };\n            Box::into_raw(data)\n        }\n\n        fn get(&mut self) -> &(dyn Any + Send) {\n            match self.inner {\n                Some(ref a) => a,\n                None => &(),\n            }\n        }\n    }\n}\n\n/// Central point for dispatching panics.\n///\n/// Executes the primary logic for a panic, including checking for recursive\n/// panics, panic hooks, and finally dispatching to the panic runtime to either\n/// abort or unwind.\nfn rust_panic_with_hook(payload: &mut dyn BoxMeUp,\n                        message: Option<&fmt::Arguments>,\n                        file_line_col: &(&str, u32, u32)) -> ! {\n    let (file, line, col) = *file_line_col;\n\n    let panics = update_panic_count(1);\n\n    // If this is the third nested call (e.g. panics == 2, this is 0-indexed),\n    // the panic hook probably triggered the last panic, otherwise the\n    // double-panic check would have aborted the process. In this case abort the\n    // process real quickly as we don't want to try calling it again as it'll\n    // probably just panic again.\n    if panics > 2 {\n        util::dumb_print(format_args!(\"thread panicked while processing \\\n                                       panic. aborting.\\n\"));\n        unsafe { intrinsics::abort() }\n    }\n\n    unsafe {\n        let mut info = PanicInfo::internal_constructor(\n            message,\n            Location::internal_constructor(file, line, col),\n        );\n        HOOK_LOCK.read();\n        match HOOK {\n            // Some platforms know that printing to stderr won't ever actually\n            // print anything, and if that's the case we can skip the default\n            // hook.\n            Hook::Default if stderr_prints_nothing() => {}\n            Hook::Default => {\n                info.set_payload(payload.get());\n                default_hook(&info);\n            }\n            Hook::Custom(ptr) => {\n                info.set_payload(payload.get());\n                (*ptr)(&info);\n            }\n        }\n        HOOK_LOCK.read_unlock();\n    }\n\n    if panics > 1 {\n        // If a thread panics while it's already unwinding then we\n        // have limited options. Currently our preference is to\n        // just abort. In the future we may consider resuming\n        // unwinding or otherwise exiting the thread cleanly.\n        util::dumb_print(format_args!(\"thread panicked while panicking. \\\n                                       aborting.\\n\"));\n        unsafe { intrinsics::abort() }\n    }\n\n    rust_panic(payload)\n}\n\n/// Shim around rust_panic. Called by resume_unwind.\npub fn update_count_then_panic(msg: Box<dyn Any + Send>) -> ! {\n    update_panic_count(1);\n\n    struct RewrapBox(Box<dyn Any + Send>);\n\n    unsafe impl BoxMeUp for RewrapBox {\n        fn box_me_up(&mut self) -> *mut (dyn Any + Send) {\n            Box::into_raw(mem::replace(&mut self.0, Box::new(())))\n        }\n\n        fn get(&mut self) -> &(dyn Any + Send) {\n            &*self.0\n        }\n    }\n\n    rust_panic(&mut RewrapBox(msg))\n}\n\n/// An unmangled function (through `rustc_std_internal_symbol`) on which to slap\n/// yer breakpoints.\n#[inline(never)]\n#[cfg_attr(not(test), rustc_std_internal_symbol)]\nfn rust_panic(mut msg: &mut dyn BoxMeUp) -> ! {\n    let code = unsafe {\n        let obj = &mut msg as *mut &mut dyn BoxMeUp;\n        __rust_start_panic(obj as usize)\n    };\n    rtabort!(\"failed to initiate panic, error {}\", code)\n}\n","// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Thread local storage\n\n#![unstable(feature = \"thread_local_internals\", issue = \"0\")]\n\nuse cell::UnsafeCell;\nuse fmt;\nuse hint;\nuse mem;\n\n/// A thread local storage key which owns its contents.\n///\n/// This key uses the fastest possible implementation available to it for the\n/// target platform. It is instantiated with the [`thread_local!`] macro and the\n/// primary method is the [`with`] method.\n///\n/// The [`with`] method yields a reference to the contained value which cannot be\n/// sent across threads or escape the given closure.\n///\n/// # Initialization and Destruction\n///\n/// Initialization is dynamically performed on the first call to [`with`]\n/// within a thread, and values that implement [`Drop`] get destructed when a\n/// thread exits. Some caveats apply, which are explained below.\n///\n/// A `LocalKey`'s initializer cannot recursively depend on itself, and using\n/// a `LocalKey` in this way will cause the initializer to infinitely recurse\n/// on the first call to `with`.\n///\n/// # Examples\n///\n/// ```\n/// use std::cell::RefCell;\n/// use std::thread;\n///\n/// thread_local!(static FOO: RefCell<u32> = RefCell::new(1));\n///\n/// FOO.with(|f| {\n///     assert_eq!(*f.borrow(), 1);\n///     *f.borrow_mut() = 2;\n/// });\n///\n/// // each thread starts out with the initial value of 1\n/// thread::spawn(move|| {\n///     FOO.with(|f| {\n///         assert_eq!(*f.borrow(), 1);\n///         *f.borrow_mut() = 3;\n///     });\n/// });\n///\n/// // we retain our original value of 2 despite the child thread\n/// FOO.with(|f| {\n///     assert_eq!(*f.borrow(), 2);\n/// });\n/// ```\n///\n/// # Platform-specific behavior\n///\n/// Note that a \"best effort\" is made to ensure that destructors for types\n/// stored in thread local storage are run, but not all platforms can guarantee\n/// that destructors will be run for all types in thread local storage. For\n/// example, there are a number of known caveats where destructors are not run:\n///\n/// 1. On Unix systems when pthread-based TLS is being used, destructors will\n///    not be run for TLS values on the main thread when it exits. Note that the\n///    application will exit immediately after the main thread exits as well.\n/// 2. On all platforms it's possible for TLS to re-initialize other TLS slots\n///    during destruction. Some platforms ensure that this cannot happen\n///    infinitely by preventing re-initialization of any slot that has been\n///    destroyed, but not all platforms have this guard. Those platforms that do\n///    not guard typically have a synthetic limit after which point no more\n///    destructors are run.\n/// 3. On macOS, initializing TLS during destruction of other TLS slots can\n///    sometimes cancel *all* destructors for the current thread, whether or not\n///    the slots have already had their destructors run or not.\n///\n/// [`with`]: ../../std/thread/struct.LocalKey.html#method.with\n/// [`thread_local!`]: ../../std/macro.thread_local.html\n/// [`Drop`]: ../../std/ops/trait.Drop.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct LocalKey<T: 'static> {\n    // This outer `LocalKey<T>` type is what's going to be stored in statics,\n    // but actual data inside will sometimes be tagged with #[thread_local].\n    // It's not valid for a true static to reference a #[thread_local] static,\n    // so we get around that by exposing an accessor through a layer of function\n    // indirection (this thunk).\n    //\n    // Note that the thunk is itself unsafe because the returned lifetime of the\n    // slot where data lives, `'static`, is not actually valid. The lifetime\n    // here is actually slightly shorter than the currently running thread!\n    //\n    // Although this is an extra layer of indirection, it should in theory be\n    // trivially devirtualizable by LLVM because the value of `inner` never\n    // changes and the constant should be readonly within a crate. This mainly\n    // only runs into problems when TLS statics are exported across crates.\n    inner: unsafe fn() -> Option<&'static UnsafeCell<Option<T>>>,\n\n    // initialization routine to invoke to create a value\n    init: fn() -> T,\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<T: 'static> fmt::Debug for LocalKey<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"LocalKey { .. }\")\n    }\n}\n\n/// Declare a new thread local storage key of type [`std::thread::LocalKey`].\n///\n/// # Syntax\n///\n/// The macro wraps any number of static declarations and makes them thread local.\n/// Publicity and attributes for each static are allowed. Example:\n///\n/// ```\n/// use std::cell::RefCell;\n/// thread_local! {\n///     pub static FOO: RefCell<u32> = RefCell::new(1);\n///\n///     #[allow(unused)]\n///     static BAR: RefCell<f32> = RefCell::new(1.0);\n/// }\n/// # fn main() {}\n/// ```\n///\n/// See [LocalKey documentation][`std::thread::LocalKey`] for more\n/// information.\n///\n/// [`std::thread::LocalKey`]: ../std/thread/struct.LocalKey.html\n#[macro_export]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow_internal_unstable]\nmacro_rules! thread_local {\n    // empty (base case for the recursion)\n    () => {};\n\n    // process multiple declarations\n    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr; $($rest:tt)*) => (\n        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);\n        $crate::thread_local!($($rest)*);\n    );\n\n    // handle a single declaration\n    ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty = $init:expr) => (\n        $crate::__thread_local_inner!($(#[$attr])* $vis $name, $t, $init);\n    );\n}\n\n#[doc(hidden)]\n#[unstable(feature = \"thread_local_internals\",\n           reason = \"should not be necessary\",\n           issue = \"0\")]\n#[macro_export]\n#[allow_internal_unstable]\n#[allow_internal_unsafe]\nmacro_rules! __thread_local_inner {\n    (@key $(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {\n        {\n            #[inline]\n            fn __init() -> $t { $init }\n\n            unsafe fn __getit() -> $crate::option::Option<\n                &'static $crate::cell::UnsafeCell<\n                    $crate::option::Option<$t>>>\n            {\n                #[cfg(all(target_arch = \"wasm32\", not(target_feature = \"atomics\")))]\n                static __KEY: $crate::thread::__StaticLocalKeyInner<$t> =\n                    $crate::thread::__StaticLocalKeyInner::new();\n\n                #[thread_local]\n                #[cfg(all(\n                    target_thread_local,\n                    not(all(target_arch = \"wasm32\", not(target_feature = \"atomics\"))),\n                ))]\n                static __KEY: $crate::thread::__FastLocalKeyInner<$t> =\n                    $crate::thread::__FastLocalKeyInner::new();\n\n                #[cfg(all(\n                    not(target_thread_local),\n                    not(all(target_arch = \"wasm32\", not(target_feature = \"atomics\"))),\n                ))]\n                static __KEY: $crate::thread::__OsLocalKeyInner<$t> =\n                    $crate::thread::__OsLocalKeyInner::new();\n\n                __KEY.get()\n            }\n\n            unsafe {\n                $crate::thread::LocalKey::new(__getit, __init)\n            }\n        }\n    };\n    ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $init:expr) => {\n        $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =\n            $crate::__thread_local_inner!(@key $(#[$attr])* $vis $name, $t, $init);\n    }\n}\n\n/// An error returned by [`LocalKey::try_with`](struct.LocalKey.html#method.try_with).\n#[stable(feature = \"thread_local_try_with\", since = \"1.26.0\")]\npub struct AccessError {\n    _private: (),\n}\n\n#[stable(feature = \"thread_local_try_with\", since = \"1.26.0\")]\nimpl fmt::Debug for AccessError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"AccessError\").finish()\n    }\n}\n\n#[stable(feature = \"thread_local_try_with\", since = \"1.26.0\")]\nimpl fmt::Display for AccessError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(\"already destroyed\", f)\n    }\n}\n\nimpl<T: 'static> LocalKey<T> {\n    #[doc(hidden)]\n    #[unstable(feature = \"thread_local_internals\",\n               reason = \"recently added to create a key\",\n               issue = \"0\")]\n    pub const unsafe fn new(inner: unsafe fn() -> Option<&'static UnsafeCell<Option<T>>>,\n                            init: fn() -> T) -> LocalKey<T> {\n        LocalKey {\n            inner,\n            init,\n        }\n    }\n\n    /// Acquires a reference to the value in this TLS key.\n    ///\n    /// This will lazily initialize the value if this thread has not referenced\n    /// this key yet.\n    ///\n    /// # Panics\n    ///\n    /// This function will `panic!()` if the key currently has its\n    /// destructor running, and it **may** panic if the destructor has\n    /// previously been run for this thread.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with<F, R>(&'static self, f: F) -> R\n                      where F: FnOnce(&T) -> R {\n        self.try_with(f).expect(\"cannot access a TLS value during or \\\n                                 after it is destroyed\")\n    }\n\n    unsafe fn init(&self, slot: &UnsafeCell<Option<T>>) -> &T {\n        // Execute the initialization up front, *then* move it into our slot,\n        // just in case initialization fails.\n        let value = (self.init)();\n        let ptr = slot.get();\n\n        // note that this can in theory just be `*ptr = Some(value)`, but due to\n        // the compiler will currently codegen that pattern with something like:\n        //\n        //      ptr::drop_in_place(ptr)\n        //      ptr::write(ptr, Some(value))\n        //\n        // Due to this pattern it's possible for the destructor of the value in\n        // `ptr` (e.g. if this is being recursively initialized) to re-access\n        // TLS, in which case there will be a `&` and `&mut` pointer to the same\n        // value (an aliasing violation). To avoid setting the \"I'm running a\n        // destructor\" flag we just use `mem::replace` which should sequence the\n        // operations a little differently and make this safe to call.\n        mem::replace(&mut *ptr, Some(value));\n\n        // After storing `Some` we want to get a reference to the contents of\n        // what we just stored. While we could use `unwrap` here and it should\n        // always work it empirically doesn't seem to always get optimized away,\n        // which means that using something like `try_with` can pull in\n        // panicking code and cause a large size bloat.\n        match *ptr {\n            Some(ref x) => x,\n            None => hint::unreachable_unchecked(),\n        }\n    }\n\n    /// Acquires a reference to the value in this TLS key.\n    ///\n    /// This will lazily initialize the value if this thread has not referenced\n    /// this key yet. If the key has been destroyed (which may happen if this is called\n    /// in a destructor), this function will return an [`AccessError`](struct.AccessError.html).\n    ///\n    /// # Panics\n    ///\n    /// This function will still `panic!()` if the key is uninitialized and the\n    /// key's initializer panics.\n    #[stable(feature = \"thread_local_try_with\", since = \"1.26.0\")]\n    pub fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError>\n    where\n        F: FnOnce(&T) -> R,\n    {\n        unsafe {\n            let slot = (self.inner)().ok_or(AccessError {\n                _private: (),\n            })?;\n            Ok(f(match *slot.get() {\n                Some(ref inner) => inner,\n                None => self.init(slot),\n            }))\n        }\n    }\n}\n\n/// On some platforms like wasm32 there's no threads, so no need to generate\n/// thread locals and we can instead just use plain statics!\n#[doc(hidden)]\n#[cfg(all(target_arch = \"wasm32\", not(target_feature = \"atomics\")))]\npub mod statik {\n    use cell::UnsafeCell;\n    use fmt;\n\n    pub struct Key<T> {\n        inner: UnsafeCell<Option<T>>,\n    }\n\n    unsafe impl<T> ::marker::Sync for Key<T> { }\n\n    impl<T> fmt::Debug for Key<T> {\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            f.pad(\"Key { .. }\")\n        }\n    }\n\n    impl<T> Key<T> {\n        pub const fn new() -> Key<T> {\n            Key {\n                inner: UnsafeCell::new(None),\n            }\n        }\n\n        pub unsafe fn get(&self) -> Option<&'static UnsafeCell<Option<T>>> {\n            Some(&*(&self.inner as *const _))\n        }\n    }\n}\n\n#[doc(hidden)]\n#[cfg(target_thread_local)]\npub mod fast {\n    use cell::{Cell, UnsafeCell};\n    use fmt;\n    use mem;\n    use ptr;\n    use sys::fast_thread_local::{register_dtor, requires_move_before_drop};\n\n    pub struct Key<T> {\n        inner: UnsafeCell<Option<T>>,\n\n        // Metadata to keep track of the state of the destructor. Remember that\n        // these variables are thread-local, not global.\n        dtor_registered: Cell<bool>,\n        dtor_running: Cell<bool>,\n    }\n\n    impl<T> fmt::Debug for Key<T> {\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            f.pad(\"Key { .. }\")\n        }\n    }\n\n    impl<T> Key<T> {\n        pub const fn new() -> Key<T> {\n            Key {\n                inner: UnsafeCell::new(None),\n                dtor_registered: Cell::new(false),\n                dtor_running: Cell::new(false)\n            }\n        }\n\n        pub unsafe fn get(&self) -> Option<&'static UnsafeCell<Option<T>>> {\n            if mem::needs_drop::<T>() && self.dtor_running.get() {\n                return None\n            }\n            self.register_dtor();\n            Some(&*(&self.inner as *const _))\n        }\n\n        unsafe fn register_dtor(&self) {\n            if !mem::needs_drop::<T>() || self.dtor_registered.get() {\n                return\n            }\n\n            register_dtor(self as *const _ as *mut u8,\n                          destroy_value::<T>);\n            self.dtor_registered.set(true);\n        }\n    }\n\n    unsafe extern fn destroy_value<T>(ptr: *mut u8) {\n        let ptr = ptr as *mut Key<T>;\n        // Right before we run the user destructor be sure to flag the\n        // destructor as running for this thread so calls to `get` will return\n        // `None`.\n        (*ptr).dtor_running.set(true);\n\n        // Some implementations may require us to move the value before we drop\n        // it as it could get re-initialized in-place during destruction.\n        //\n        // Hence, we use `ptr::read` on those platforms (to move to a \"safe\"\n        // location) instead of drop_in_place.\n        if requires_move_before_drop() {\n            ptr::read((*ptr).inner.get());\n        } else {\n            ptr::drop_in_place((*ptr).inner.get());\n        }\n    }\n}\n\n#[doc(hidden)]\npub mod os {\n    use cell::{Cell, UnsafeCell};\n    use fmt;\n    use marker;\n    use ptr;\n    use sys_common::thread_local::StaticKey as OsStaticKey;\n\n    pub struct Key<T> {\n        // OS-TLS key that we'll use to key off.\n        os: OsStaticKey,\n        marker: marker::PhantomData<Cell<T>>,\n    }\n\n    impl<T> fmt::Debug for Key<T> {\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            f.pad(\"Key { .. }\")\n        }\n    }\n\n    unsafe impl<T> ::marker::Sync for Key<T> { }\n\n    struct Value<T: 'static> {\n        key: &'static Key<T>,\n        value: UnsafeCell<Option<T>>,\n    }\n\n    impl<T: 'static> Key<T> {\n        pub const fn new() -> Key<T> {\n            Key {\n                os: OsStaticKey::new(Some(destroy_value::<T>)),\n                marker: marker::PhantomData\n            }\n        }\n\n        pub unsafe fn get(&'static self) -> Option<&'static UnsafeCell<Option<T>>> {\n            let ptr = self.os.get() as *mut Value<T>;\n            if !ptr.is_null() {\n                if ptr as usize == 1 {\n                    return None\n                }\n                return Some(&(*ptr).value);\n            }\n\n            // If the lookup returned null, we haven't initialized our own\n            // local copy, so do that now.\n            let ptr: Box<Value<T>> = box Value {\n                key: self,\n                value: UnsafeCell::new(None),\n            };\n            let ptr = Box::into_raw(ptr);\n            self.os.set(ptr as *mut u8);\n            Some(&(*ptr).value)\n        }\n    }\n\n    unsafe extern fn destroy_value<T: 'static>(ptr: *mut u8) {\n        // The OS TLS ensures that this key contains a NULL value when this\n        // destructor starts to run. We set it back to a sentinel value of 1 to\n        // ensure that any future calls to `get` for this thread will return\n        // `None`.\n        //\n        // Note that to prevent an infinite loop we reset it back to null right\n        // before we return from the destructor ourselves.\n        let ptr = Box::from_raw(ptr as *mut Value<T>);\n        let key = ptr.key;\n        key.os.set(1 as *mut u8);\n        drop(ptr);\n        key.os.set(ptr::null_mut());\n    }\n}\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use sync::mpsc::{channel, Sender};\n    use cell::{Cell, UnsafeCell};\n    use thread;\n\n    struct Foo(Sender<()>);\n\n    impl Drop for Foo {\n        fn drop(&mut self) {\n            let Foo(ref s) = *self;\n            s.send(()).unwrap();\n        }\n    }\n\n    #[test]\n    fn smoke_no_dtor() {\n        thread_local!(static FOO: Cell<i32> = Cell::new(1));\n\n        FOO.with(|f| {\n            assert_eq!(f.get(), 1);\n            f.set(2);\n        });\n        let (tx, rx) = channel();\n        let _t = thread::spawn(move|| {\n            FOO.with(|f| {\n                assert_eq!(f.get(), 1);\n            });\n            tx.send(()).unwrap();\n        });\n        rx.recv().unwrap();\n\n        FOO.with(|f| {\n            assert_eq!(f.get(), 2);\n        });\n    }\n\n    #[test]\n    fn states() {\n        struct Foo;\n        impl Drop for Foo {\n            fn drop(&mut self) {\n                assert!(FOO.try_with(|_| ()).is_err());\n            }\n        }\n        thread_local!(static FOO: Foo = Foo);\n\n        thread::spawn(|| {\n            assert!(FOO.try_with(|_| ()).is_ok());\n        }).join().ok().unwrap();\n    }\n\n    #[test]\n    fn smoke_dtor() {\n        thread_local!(static FOO: UnsafeCell<Option<Foo>> = UnsafeCell::new(None));\n\n        let (tx, rx) = channel();\n        let _t = thread::spawn(move|| unsafe {\n            let mut tx = Some(tx);\n            FOO.with(|f| {\n                *f.get() = Some(Foo(tx.take().unwrap()));\n            });\n        });\n        rx.recv().unwrap();\n    }\n\n    #[test]\n    fn circular() {\n        struct S1;\n        struct S2;\n        thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));\n        thread_local!(static K2: UnsafeCell<Option<S2>> = UnsafeCell::new(None));\n        static mut HITS: u32 = 0;\n\n        impl Drop for S1 {\n            fn drop(&mut self) {\n                unsafe {\n                    HITS += 1;\n                    if K2.try_with(|_| ()).is_err() {\n                        assert_eq!(HITS, 3);\n                    } else {\n                        if HITS == 1 {\n                            K2.with(|s| *s.get() = Some(S2));\n                        } else {\n                            assert_eq!(HITS, 3);\n                        }\n                    }\n                }\n            }\n        }\n        impl Drop for S2 {\n            fn drop(&mut self) {\n                unsafe {\n                    HITS += 1;\n                    assert!(K1.try_with(|_| ()).is_ok());\n                    assert_eq!(HITS, 2);\n                    K1.with(|s| *s.get() = Some(S1));\n                }\n            }\n        }\n\n        thread::spawn(move|| {\n            drop(S1);\n        }).join().ok().unwrap();\n    }\n\n    #[test]\n    fn self_referential() {\n        struct S1;\n        thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));\n\n        impl Drop for S1 {\n            fn drop(&mut self) {\n                assert!(K1.try_with(|_| ()).is_err());\n            }\n        }\n\n        thread::spawn(move|| unsafe {\n            K1.with(|s| *s.get() = Some(S1));\n        }).join().ok().unwrap();\n    }\n\n    // Note that this test will deadlock if TLS destructors aren't run (this\n    // requires the destructor to be run to pass the test). macOS has a known bug\n    // where dtors-in-dtors may cancel other destructors, so we just ignore this\n    // test on macOS.\n    #[test]\n    #[cfg_attr(target_os = \"macos\", ignore)]\n    fn dtors_in_dtors_in_dtors() {\n        struct S1(Sender<()>);\n        thread_local!(static K1: UnsafeCell<Option<S1>> = UnsafeCell::new(None));\n        thread_local!(static K2: UnsafeCell<Option<Foo>> = UnsafeCell::new(None));\n\n        impl Drop for S1 {\n            fn drop(&mut self) {\n                let S1(ref tx) = *self;\n                unsafe {\n                    let _ = K2.try_with(|s| *s.get() = Some(Foo(tx.clone())));\n                }\n            }\n        }\n\n        let (tx, rx) = channel();\n        let _t = thread::spawn(move|| unsafe {\n            let mut tx = Some(tx);\n            K1.with(|s| *s.get() = Some(S1(tx.take().unwrap())));\n        });\n        rx.recv().unwrap();\n    }\n}\n\n#[cfg(test)]\nmod dynamic_tests {\n    use cell::RefCell;\n    use collections::HashMap;\n\n    #[test]\n    fn smoke() {\n        fn square(i: i32) -> i32 { i * i }\n        thread_local!(static FOO: i32 = square(3));\n\n        FOO.with(|f| {\n            assert_eq!(*f, 9);\n        });\n    }\n\n    #[test]\n    fn hashmap() {\n        fn map() -> RefCell<HashMap<i32, i32>> {\n            let mut m = HashMap::new();\n            m.insert(1, 2);\n            RefCell::new(m)\n        }\n        thread_local!(static FOO: RefCell<HashMap<i32, i32>> = map());\n\n        FOO.with(|map| {\n            assert_eq!(map.borrow()[&1], 2);\n        });\n    }\n\n    #[test]\n    fn refcell_vec() {\n        thread_local!(static FOO: RefCell<Vec<u32>> = RefCell::new(vec![1, 2, 3]));\n\n        FOO.with(|vec| {\n            assert_eq!(vec.borrow().len(), 3);\n            vec.borrow_mut().push(4);\n            assert_eq!(vec.borrow()[3], 4);\n        });\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Shareable mutable containers.\n//!\n//! Rust memory safety is based on this rule: Given an object `T`, it is only possible to\n//! have one of the following:\n//!\n//! - Having several immutable references (`&T`) to the object (also known as **aliasing**).\n//! - Having one mutable reference (`&mut T`) to the object (also known as **mutability**).\n//!\n//! This is enforced by the Rust compiler. However, there are situations where this rule is not\n//! flexible enough. Sometimes it is required to have multiple references to an object and yet\n//! mutate it.\n//!\n//! Shareable mutable containers exist to permit mutability in a controlled manner, even in the\n//! presence of aliasing. Both `Cell<T>` and `RefCell<T>` allows to do this in a single threaded\n//! way. However, neither `Cell<T>` nor `RefCell<T>` are thread safe (they do not implement\n//! `Sync`). If you need to do aliasing and mutation between multiple threads it is possible to\n//! use [`Mutex`](../../std/sync/struct.Mutex.html),\n//! [`RwLock`](../../std/sync/struct.RwLock.html) or\n//! [`atomic`](../../core/sync/atomic/index.html) types.\n//!\n//! Values of the `Cell<T>` and `RefCell<T>` types may be mutated through shared references (i.e.\n//! the common `&T` type), whereas most Rust types can only be mutated through unique (`&mut T`)\n//! references. We say that `Cell<T>` and `RefCell<T>` provide 'interior mutability', in contrast\n//! with typical Rust types that exhibit 'inherited mutability'.\n//!\n//! Cell types come in two flavors: `Cell<T>` and `RefCell<T>`. `Cell<T>` implements interior\n//! mutability by moving values in and out of the `Cell<T>`. To use references instead of values,\n//! one must use the `RefCell<T>` type, acquiring a write lock before mutating. `Cell<T>` provides\n//! methods to retrieve and change the current interior value:\n//!\n//!  - For types that implement `Copy`, the `get` method retrieves the current interior value.\n//!  - For types that implement `Default`, the `take` method replaces the current interior value\n//!    with `Default::default()` and returns the replaced value.\n//!  - For all types, the `replace` method replaces the current interior value and returns the\n//!    replaced value and the `into_inner` method consumes the `Cell<T>` and returns the interior\n//!    value. Additionally, the `set` method replaces the interior value, dropping the replaced\n//!    value.\n//!\n//! `RefCell<T>` uses Rust's lifetimes to implement 'dynamic borrowing', a process whereby one can\n//! claim temporary, exclusive, mutable access to the inner value. Borrows for `RefCell<T>`s are\n//! tracked 'at runtime', unlike Rust's native reference types which are entirely tracked\n//! statically, at compile time. Because `RefCell<T>` borrows are dynamic it is possible to attempt\n//! to borrow a value that is already mutably borrowed; when this happens it results in thread\n//! panic.\n//!\n//! # When to choose interior mutability\n//!\n//! The more common inherited mutability, where one must have unique access to mutate a value, is\n//! one of the key language elements that enables Rust to reason strongly about pointer aliasing,\n//! statically preventing crash bugs. Because of that, inherited mutability is preferred, and\n//! interior mutability is something of a last resort. Since cell types enable mutation where it\n//! would otherwise be disallowed though, there are occasions when interior mutability might be\n//! appropriate, or even *must* be used, e.g.\n//!\n//! * Introducing mutability 'inside' of something immutable\n//! * Implementation details of logically-immutable methods.\n//! * Mutating implementations of `Clone`.\n//!\n//! ## Introducing mutability 'inside' of something immutable\n//!\n//! Many shared smart pointer types, including `Rc<T>` and `Arc<T>`, provide containers that can be\n//! cloned and shared between multiple parties. Because the contained values may be\n//! multiply-aliased, they can only be borrowed with `&`, not `&mut`. Without cells it would be\n//! impossible to mutate data inside of these smart pointers at all.\n//!\n//! It's very common then to put a `RefCell<T>` inside shared pointer types to reintroduce\n//! mutability:\n//!\n//! ```\n//! use std::collections::HashMap;\n//! use std::cell::RefCell;\n//! use std::rc::Rc;\n//!\n//! fn main() {\n//!     let shared_map: Rc<RefCell<_>> = Rc::new(RefCell::new(HashMap::new()));\n//!     shared_map.borrow_mut().insert(\"africa\", 92388);\n//!     shared_map.borrow_mut().insert(\"kyoto\", 11837);\n//!     shared_map.borrow_mut().insert(\"piccadilly\", 11826);\n//!     shared_map.borrow_mut().insert(\"marbles\", 38);\n//! }\n//! ```\n//!\n//! Note that this example uses `Rc<T>` and not `Arc<T>`. `RefCell<T>`s are for single-threaded\n//! scenarios. Consider using `RwLock<T>` or `Mutex<T>` if you need shared mutability in a\n//! multi-threaded situation.\n//!\n//! ## Implementation details of logically-immutable methods\n//!\n//! Occasionally it may be desirable not to expose in an API that there is mutation happening\n//! \"under the hood\". This may be because logically the operation is immutable, but e.g. caching\n//! forces the implementation to perform mutation; or because you must employ mutation to implement\n//! a trait method that was originally defined to take `&self`.\n//!\n//! ```\n//! # #![allow(dead_code)]\n//! use std::cell::RefCell;\n//!\n//! struct Graph {\n//!     edges: Vec<(i32, i32)>,\n//!     span_tree_cache: RefCell<Option<Vec<(i32, i32)>>>\n//! }\n//!\n//! impl Graph {\n//!     fn minimum_spanning_tree(&self) -> Vec<(i32, i32)> {\n//!         // Create a new scope to contain the lifetime of the\n//!         // dynamic borrow\n//!         {\n//!             // Take a reference to the inside of cache cell\n//!             let mut cache = self.span_tree_cache.borrow_mut();\n//!             if cache.is_some() {\n//!                 return cache.as_ref().unwrap().clone();\n//!             }\n//!\n//!             let span_tree = self.calc_span_tree();\n//!             *cache = Some(span_tree);\n//!         }\n//!\n//!         // Recursive call to return the just-cached value.\n//!         // Note that if we had not let the previous borrow\n//!         // of the cache fall out of scope then the subsequent\n//!         // recursive borrow would cause a dynamic thread panic.\n//!         // This is the major hazard of using `RefCell`.\n//!         self.minimum_spanning_tree()\n//!     }\n//! #   fn calc_span_tree(&self) -> Vec<(i32, i32)> { vec![] }\n//! }\n//! ```\n//!\n//! ## Mutating implementations of `Clone`\n//!\n//! This is simply a special - but common - case of the previous: hiding mutability for operations\n//! that appear to be immutable. The `clone` method is expected to not change the source value, and\n//! is declared to take `&self`, not `&mut self`. Therefore any mutation that happens in the\n//! `clone` method must use cell types. For example, `Rc<T>` maintains its reference counts within a\n//! `Cell<T>`.\n//!\n//! ```\n//! #![feature(core_intrinsics)]\n//! use std::cell::Cell;\n//! use std::ptr::NonNull;\n//! use std::intrinsics::abort;\n//!\n//! struct Rc<T: ?Sized> {\n//!     ptr: NonNull<RcBox<T>>\n//! }\n//!\n//! struct RcBox<T: ?Sized> {\n//!     strong: Cell<usize>,\n//!     refcount: Cell<usize>,\n//!     value: T,\n//! }\n//!\n//! impl<T: ?Sized> Clone for Rc<T> {\n//!     fn clone(&self) -> Rc<T> {\n//!         self.inc_strong();\n//!         Rc { ptr: self.ptr }\n//!     }\n//! }\n//!\n//! trait RcBoxPtr<T: ?Sized> {\n//!\n//!     fn inner(&self) -> &RcBox<T>;\n//!\n//!     fn strong(&self) -> usize {\n//!         self.inner().strong.get()\n//!     }\n//!\n//!     fn inc_strong(&self) {\n//!         self.inner()\n//!             .strong\n//!             .set(self.strong()\n//!                      .checked_add(1)\n//!                      .unwrap_or_else(|| unsafe { abort() }));\n//!     }\n//! }\n//!\n//! impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {\n//!    fn inner(&self) -> &RcBox<T> {\n//!        unsafe {\n//!            self.ptr.as_ref()\n//!        }\n//!    }\n//! }\n//! ```\n//!\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse cmp::Ordering;\nuse fmt::{self, Debug, Display};\nuse marker::Unsize;\nuse mem;\nuse ops::{Deref, DerefMut, CoerceUnsized};\nuse ptr;\n\n/// A mutable memory location.\n///\n/// # Examples\n///\n/// In this example, you can see that `Cell<T>` enables mutation inside an\n/// immutable struct. In other words, it enables \"interior mutability\".\n///\n/// ```\n/// use std::cell::Cell;\n///\n/// struct SomeStruct {\n///     regular_field: u8,\n///     special_field: Cell<u8>,\n/// }\n///\n/// let my_struct = SomeStruct {\n///     regular_field: 0,\n///     special_field: Cell::new(1),\n/// };\n///\n/// let new_value = 100;\n///\n/// // ERROR: `my_struct` is immutable\n/// // my_struct.regular_field = new_value;\n///\n/// // WORKS: although `my_struct` is immutable, `special_field` is a `Cell`,\n/// // which can always be mutated\n/// my_struct.special_field.set(new_value);\n/// assert_eq!(my_struct.special_field.get(), new_value);\n/// ```\n///\n/// See the [module-level documentation](index.html) for more.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[repr(transparent)]\npub struct Cell<T: ?Sized> {\n    value: UnsafeCell<T>,\n}\n\nimpl<T:Copy> Cell<T> {\n    /// Returns a copy of the contained value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    ///\n    /// let five = c.get();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get(&self) -> T {\n        unsafe{ *self.value.get() }\n    }\n\n    /// Updates the contained value using a function and returns the new value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(cell_update)]\n    ///\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    /// let new = c.update(|x| x + 1);\n    ///\n    /// assert_eq!(new, 6);\n    /// assert_eq!(c.get(), 6);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"cell_update\", issue = \"50186\")]\n    pub fn update<F>(&self, f: F) -> T\n    where\n        F: FnOnce(T) -> T,\n    {\n        let old = self.get();\n        let new = f(old);\n        self.set(new);\n        new\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized> Send for Cell<T> where T: Send {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> !Sync for Cell<T> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T:Copy> Clone for Cell<T> {\n    #[inline]\n    fn clone(&self) -> Cell<T> {\n        Cell::new(self.get())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T:Default> Default for Cell<T> {\n    /// Creates a `Cell<T>`, with the `Default` value for T.\n    #[inline]\n    fn default() -> Cell<T> {\n        Cell::new(Default::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T:PartialEq + Copy> PartialEq for Cell<T> {\n    #[inline]\n    fn eq(&self, other: &Cell<T>) -> bool {\n        self.get() == other.get()\n    }\n}\n\n#[stable(feature = \"cell_eq\", since = \"1.2.0\")]\nimpl<T:Eq + Copy> Eq for Cell<T> {}\n\n#[stable(feature = \"cell_ord\", since = \"1.10.0\")]\nimpl<T:PartialOrd + Copy> PartialOrd for Cell<T> {\n    #[inline]\n    fn partial_cmp(&self, other: &Cell<T>) -> Option<Ordering> {\n        self.get().partial_cmp(&other.get())\n    }\n\n    #[inline]\n    fn lt(&self, other: &Cell<T>) -> bool {\n        self.get() < other.get()\n    }\n\n    #[inline]\n    fn le(&self, other: &Cell<T>) -> bool {\n        self.get() <= other.get()\n    }\n\n    #[inline]\n    fn gt(&self, other: &Cell<T>) -> bool {\n        self.get() > other.get()\n    }\n\n    #[inline]\n    fn ge(&self, other: &Cell<T>) -> bool {\n        self.get() >= other.get()\n    }\n}\n\n#[stable(feature = \"cell_ord\", since = \"1.10.0\")]\nimpl<T:Ord + Copy> Ord for Cell<T> {\n    #[inline]\n    fn cmp(&self, other: &Cell<T>) -> Ordering {\n        self.get().cmp(&other.get())\n    }\n}\n\n#[stable(feature = \"cell_from\", since = \"1.12.0\")]\nimpl<T> From<T> for Cell<T> {\n    fn from(t: T) -> Cell<T> {\n        Cell::new(t)\n    }\n}\n\nimpl<T> Cell<T> {\n    /// Creates a new `Cell` containing the given value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub const fn new(value: T) -> Cell<T> {\n        Cell {\n            value: UnsafeCell::new(value),\n        }\n    }\n\n    /// Sets the contained value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    ///\n    /// c.set(10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set(&self, val: T) {\n        let old = self.replace(val);\n        drop(old);\n    }\n\n    /// Swaps the values of two Cells.\n    /// Difference with `std::mem::swap` is that this function doesn't require `&mut` reference.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c1 = Cell::new(5i32);\n    /// let c2 = Cell::new(10i32);\n    /// c1.swap(&c2);\n    /// assert_eq!(10, c1.get());\n    /// assert_eq!(5, c2.get());\n    /// ```\n    #[inline]\n    #[stable(feature = \"move_cell\", since = \"1.17.0\")]\n    pub fn swap(&self, other: &Self) {\n        if ptr::eq(self, other) {\n            return;\n        }\n        unsafe {\n            ptr::swap(self.value.get(), other.value.get());\n        }\n    }\n\n    /// Replaces the contained value, and returns it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let cell = Cell::new(5);\n    /// assert_eq!(cell.get(), 5);\n    /// assert_eq!(cell.replace(10), 5);\n    /// assert_eq!(cell.get(), 10);\n    /// ```\n    #[stable(feature = \"move_cell\", since = \"1.17.0\")]\n    pub fn replace(&self, val: T) -> T {\n        mem::replace(unsafe { &mut *self.value.get() }, val)\n    }\n\n    /// Unwraps the value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    /// let five = c.into_inner();\n    ///\n    /// assert_eq!(five, 5);\n    /// ```\n    #[stable(feature = \"move_cell\", since = \"1.17.0\")]\n    pub fn into_inner(self) -> T {\n        self.value.into_inner()\n    }\n}\n\nimpl<T: ?Sized> Cell<T> {\n    /// Returns a raw pointer to the underlying data in this cell.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    ///\n    /// let ptr = c.as_ptr();\n    /// ```\n    #[inline]\n    #[stable(feature = \"cell_as_ptr\", since = \"1.12.0\")]\n    pub fn as_ptr(&self) -> *mut T {\n        self.value.get()\n    }\n\n    /// Returns a mutable reference to the underlying data.\n    ///\n    /// This call borrows `Cell` mutably (at compile-time) which guarantees\n    /// that we possess the only reference.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let mut c = Cell::new(5);\n    /// *c.get_mut() += 1;\n    ///\n    /// assert_eq!(c.get(), 6);\n    /// ```\n    #[inline]\n    #[stable(feature = \"cell_get_mut\", since = \"1.11.0\")]\n    pub fn get_mut(&mut self) -> &mut T {\n        unsafe {\n            &mut *self.value.get()\n        }\n    }\n\n    /// Returns a `&Cell<T>` from a `&mut T`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(as_cell)]\n    /// use std::cell::Cell;\n    ///\n    /// let slice: &mut [i32] = &mut [1, 2, 3];\n    /// let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);\n    /// let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();\n    ///\n    /// assert_eq!(slice_cell.len(), 3);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"as_cell\", issue=\"43038\")]\n    pub fn from_mut(t: &mut T) -> &Cell<T> {\n        unsafe {\n            &*(t as *mut T as *const Cell<T>)\n        }\n    }\n}\n\nimpl<T: Default> Cell<T> {\n    /// Takes the value of the cell, leaving `Default::default()` in its place.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::Cell;\n    ///\n    /// let c = Cell::new(5);\n    /// let five = c.take();\n    ///\n    /// assert_eq!(five, 5);\n    /// assert_eq!(c.into_inner(), 0);\n    /// ```\n    #[stable(feature = \"move_cell\", since = \"1.17.0\")]\n    pub fn take(&self) -> T {\n        self.replace(Default::default())\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: CoerceUnsized<U>, U> CoerceUnsized<Cell<U>> for Cell<T> {}\n\nimpl<T> Cell<[T]> {\n    /// Returns a `&[Cell<T>]` from a `&Cell<[T]>`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(as_cell)]\n    /// use std::cell::Cell;\n    ///\n    /// let slice: &mut [i32] = &mut [1, 2, 3];\n    /// let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);\n    /// let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();\n    ///\n    /// assert_eq!(slice_cell.len(), 3);\n    /// ```\n    #[unstable(feature = \"as_cell\", issue=\"43038\")]\n    pub fn as_slice_of_cells(&self) -> &[Cell<T>] {\n        unsafe {\n            &*(self as *const Cell<[T]> as *const [Cell<T>])\n        }\n    }\n}\n\n/// A mutable memory location with dynamically checked borrow rules\n///\n/// See the [module-level documentation](index.html) for more.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RefCell<T: ?Sized> {\n    borrow: Cell<BorrowFlag>,\n    value: UnsafeCell<T>,\n}\n\n/// An error returned by [`RefCell::try_borrow`](struct.RefCell.html#method.try_borrow).\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\npub struct BorrowError {\n    _private: (),\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Debug for BorrowError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"BorrowError\").finish()\n    }\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Display for BorrowError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        Display::fmt(\"already mutably borrowed\", f)\n    }\n}\n\n/// An error returned by [`RefCell::try_borrow_mut`](struct.RefCell.html#method.try_borrow_mut).\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\npub struct BorrowMutError {\n    _private: (),\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Debug for BorrowMutError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"BorrowMutError\").finish()\n    }\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Display for BorrowMutError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        Display::fmt(\"already borrowed\", f)\n    }\n}\n\n// Positive values represent the number of `Ref` active. Negative values\n// represent the number of `RefMut` active. Multiple `RefMut`s can only be\n// active at a time if they refer to distinct, nonoverlapping components of a\n// `RefCell` (e.g., different ranges of a slice).\n//\n// `Ref` and `RefMut` are both two words in size, and so there will likely never\n// be enough `Ref`s or `RefMut`s in existence to overflow half of the `usize`\n// range. Thus, a `BorrowFlag` will probably never overflow or underflow.\n// However, this is not a guarantee, as a pathological program could repeatedly\n// create and then mem::forget `Ref`s or `RefMut`s. Thus, all code must\n// explicitly check for overflow and underflow in order to avoid unsafety, or at\n// least behave correctly in the event that overflow or underflow happens (e.g.,\n// see BorrowRef::new).\ntype BorrowFlag = isize;\nconst UNUSED: BorrowFlag = 0;\n\n#[inline(always)]\nfn is_writing(x: BorrowFlag) -> bool {\n    x < UNUSED\n}\n\n#[inline(always)]\nfn is_reading(x: BorrowFlag) -> bool {\n    x > UNUSED\n}\n\nimpl<T> RefCell<T> {\n    /// Creates a new `RefCell` containing `value`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub const fn new(value: T) -> RefCell<T> {\n        RefCell {\n            value: UnsafeCell::new(value),\n            borrow: Cell::new(UNUSED),\n        }\n    }\n\n    /// Consumes the `RefCell`, returning the wrapped value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// let five = c.into_inner();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn into_inner(self) -> T {\n        // Since this function takes `self` (the `RefCell`) by value, the\n        // compiler statically verifies that it is not currently borrowed.\n        // Therefore the following assertion is just a `debug_assert!`.\n        debug_assert!(self.borrow.get() == UNUSED);\n        self.value.into_inner()\n    }\n\n    /// Replaces the wrapped value with a new one, returning the old value,\n    /// without deinitializing either one.\n    ///\n    /// This function corresponds to [`std::mem::replace`](../mem/fn.replace.html).\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is currently borrowed.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    /// let cell = RefCell::new(5);\n    /// let old_value = cell.replace(6);\n    /// assert_eq!(old_value, 5);\n    /// assert_eq!(cell, RefCell::new(6));\n    /// ```\n    #[inline]\n    #[stable(feature = \"refcell_replace\", since=\"1.24.0\")]\n    pub fn replace(&self, t: T) -> T {\n        mem::replace(&mut *self.borrow_mut(), t)\n    }\n\n    /// Replaces the wrapped value with a new one computed from `f`, returning\n    /// the old value, without deinitializing either one.\n    ///\n    /// This function corresponds to [`std::mem::replace`](../mem/fn.replace.html).\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is currently borrowed.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(refcell_replace_swap)]\n    /// use std::cell::RefCell;\n    /// let cell = RefCell::new(5);\n    /// let old_value = cell.replace_with(|&mut old| old + 1);\n    /// assert_eq!(old_value, 5);\n    /// assert_eq!(cell, RefCell::new(6));\n    /// ```\n    #[inline]\n    #[unstable(feature = \"refcell_replace_swap\", issue=\"43570\")]\n    pub fn replace_with<F: FnOnce(&mut T) -> T>(&self, f: F) -> T {\n        let mut_borrow = &mut *self.borrow_mut();\n        let replacement = f(mut_borrow);\n        mem::replace(mut_borrow, replacement)\n    }\n\n    /// Swaps the wrapped value of `self` with the wrapped value of `other`,\n    /// without deinitializing either one.\n    ///\n    /// This function corresponds to [`std::mem::swap`](../mem/fn.swap.html).\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    /// let c = RefCell::new(5);\n    /// let d = RefCell::new(6);\n    /// c.swap(&d);\n    /// assert_eq!(c, RefCell::new(6));\n    /// assert_eq!(d, RefCell::new(5));\n    /// ```\n    #[inline]\n    #[stable(feature = \"refcell_swap\", since=\"1.24.0\")]\n    pub fn swap(&self, other: &Self) {\n        mem::swap(&mut *self.borrow_mut(), &mut *other.borrow_mut())\n    }\n}\n\nimpl<T: ?Sized> RefCell<T> {\n    /// Immutably borrows the wrapped value.\n    ///\n    /// The borrow lasts until the returned `Ref` exits scope. Multiple\n    /// immutable borrows can be taken out at the same time.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is currently mutably borrowed. For a non-panicking variant, use\n    /// [`try_borrow`](#method.try_borrow).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// let borrowed_five = c.borrow();\n    /// let borrowed_five2 = c.borrow();\n    /// ```\n    ///\n    /// An example of panic:\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(move || {\n    ///    let c = RefCell::new(5);\n    ///    let m = c.borrow_mut();\n    ///\n    ///    let b = c.borrow(); // this causes a panic\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn borrow(&self) -> Ref<T> {\n        self.try_borrow().expect(\"already mutably borrowed\")\n    }\n\n    /// Immutably borrows the wrapped value, returning an error if the value is currently mutably\n    /// borrowed.\n    ///\n    /// The borrow lasts until the returned `Ref` exits scope. Multiple immutable borrows can be\n    /// taken out at the same time.\n    ///\n    /// This is the non-panicking variant of [`borrow`](#method.borrow).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// {\n    ///     let m = c.borrow_mut();\n    ///     assert!(c.try_borrow().is_err());\n    /// }\n    ///\n    /// {\n    ///     let m = c.borrow();\n    ///     assert!(c.try_borrow().is_ok());\n    /// }\n    /// ```\n    #[stable(feature = \"try_borrow\", since = \"1.13.0\")]\n    #[inline]\n    pub fn try_borrow(&self) -> Result<Ref<T>, BorrowError> {\n        match BorrowRef::new(&self.borrow) {\n            Some(b) => Ok(Ref {\n                value: unsafe { &*self.value.get() },\n                borrow: b,\n            }),\n            None => Err(BorrowError { _private: () }),\n        }\n    }\n\n    /// Mutably borrows the wrapped value.\n    ///\n    /// The borrow lasts until the returned `RefMut` or all `RefMut`s derived\n    /// from it exit scope. The value cannot be borrowed while this borrow is\n    /// active.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the value is currently borrowed. For a non-panicking variant, use\n    /// [`try_borrow_mut`](#method.try_borrow_mut).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// *c.borrow_mut() = 7;\n    ///\n    /// assert_eq!(*c.borrow(), 7);\n    /// ```\n    ///\n    /// An example of panic:\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    /// use std::thread;\n    ///\n    /// let result = thread::spawn(move || {\n    ///    let c = RefCell::new(5);\n    ///    let m = c.borrow();\n    ///\n    ///    let b = c.borrow_mut(); // this causes a panic\n    /// }).join();\n    ///\n    /// assert!(result.is_err());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn borrow_mut(&self) -> RefMut<T> {\n        self.try_borrow_mut().expect(\"already borrowed\")\n    }\n\n    /// Mutably borrows the wrapped value, returning an error if the value is currently borrowed.\n    ///\n    /// The borrow lasts until the returned `RefMut` or all `RefMut`s derived\n    /// from it exit scope. The value cannot be borrowed while this borrow is\n    /// active.\n    ///\n    /// This is the non-panicking variant of [`borrow_mut`](#method.borrow_mut).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// {\n    ///     let m = c.borrow();\n    ///     assert!(c.try_borrow_mut().is_err());\n    /// }\n    ///\n    /// assert!(c.try_borrow_mut().is_ok());\n    /// ```\n    #[stable(feature = \"try_borrow\", since = \"1.13.0\")]\n    #[inline]\n    pub fn try_borrow_mut(&self) -> Result<RefMut<T>, BorrowMutError> {\n        match BorrowRefMut::new(&self.borrow) {\n            Some(b) => Ok(RefMut {\n                value: unsafe { &mut *self.value.get() },\n                borrow: b,\n            }),\n            None => Err(BorrowMutError { _private: () }),\n        }\n    }\n\n    /// Returns a raw pointer to the underlying data in this cell.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let c = RefCell::new(5);\n    ///\n    /// let ptr = c.as_ptr();\n    /// ```\n    #[inline]\n    #[stable(feature = \"cell_as_ptr\", since = \"1.12.0\")]\n    pub fn as_ptr(&self) -> *mut T {\n        self.value.get()\n    }\n\n    /// Returns a mutable reference to the underlying data.\n    ///\n    /// This call borrows `RefCell` mutably (at compile-time) so there is no\n    /// need for dynamic checks.\n    ///\n    /// However be cautious: this method expects `self` to be mutable, which is\n    /// generally not the case when using a `RefCell`. Take a look at the\n    /// [`borrow_mut`] method instead if `self` isn't mutable.\n    ///\n    /// Also, please be aware that this method is only for special circumstances and is usually\n    /// not what you want. In case of doubt, use [`borrow_mut`] instead.\n    ///\n    /// [`borrow_mut`]: #method.borrow_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::RefCell;\n    ///\n    /// let mut c = RefCell::new(5);\n    /// *c.get_mut() += 1;\n    ///\n    /// assert_eq!(c, RefCell::new(6));\n    /// ```\n    #[inline]\n    #[stable(feature = \"cell_get_mut\", since = \"1.11.0\")]\n    pub fn get_mut(&mut self) -> &mut T {\n        unsafe {\n            &mut *self.value.get()\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized> Send for RefCell<T> where T: Send {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> !Sync for RefCell<T> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Clone> Clone for RefCell<T> {\n    /// # Panics\n    ///\n    /// Panics if the value is currently mutably borrowed.\n    #[inline]\n    fn clone(&self) -> RefCell<T> {\n        RefCell::new(self.borrow().clone())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T:Default> Default for RefCell<T> {\n    /// Creates a `RefCell<T>`, with the `Default` value for T.\n    #[inline]\n    fn default() -> RefCell<T> {\n        RefCell::new(Default::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + PartialEq> PartialEq for RefCell<T> {\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn eq(&self, other: &RefCell<T>) -> bool {\n        *self.borrow() == *other.borrow()\n    }\n}\n\n#[stable(feature = \"cell_eq\", since = \"1.2.0\")]\nimpl<T: ?Sized + Eq> Eq for RefCell<T> {}\n\n#[stable(feature = \"cell_ord\", since = \"1.10.0\")]\nimpl<T: ?Sized + PartialOrd> PartialOrd for RefCell<T> {\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering> {\n        self.borrow().partial_cmp(&*other.borrow())\n    }\n\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn lt(&self, other: &RefCell<T>) -> bool {\n        *self.borrow() < *other.borrow()\n    }\n\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn le(&self, other: &RefCell<T>) -> bool {\n        *self.borrow() <= *other.borrow()\n    }\n\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn gt(&self, other: &RefCell<T>) -> bool {\n        *self.borrow() > *other.borrow()\n    }\n\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn ge(&self, other: &RefCell<T>) -> bool {\n        *self.borrow() >= *other.borrow()\n    }\n}\n\n#[stable(feature = \"cell_ord\", since = \"1.10.0\")]\nimpl<T: ?Sized + Ord> Ord for RefCell<T> {\n    /// # Panics\n    ///\n    /// Panics if the value in either `RefCell` is currently borrowed.\n    #[inline]\n    fn cmp(&self, other: &RefCell<T>) -> Ordering {\n        self.borrow().cmp(&*other.borrow())\n    }\n}\n\n#[stable(feature = \"cell_from\", since = \"1.12.0\")]\nimpl<T> From<T> for RefCell<T> {\n    fn from(t: T) -> RefCell<T> {\n        RefCell::new(t)\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: CoerceUnsized<U>, U> CoerceUnsized<RefCell<U>> for RefCell<T> {}\n\nstruct BorrowRef<'b> {\n    borrow: &'b Cell<BorrowFlag>,\n}\n\nimpl<'b> BorrowRef<'b> {\n    #[inline]\n    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRef<'b>> {\n        let b = borrow.get();\n        if is_writing(b) || b == isize::max_value() {\n            // If there's currently a writing borrow, or if incrementing the\n            // refcount would overflow into a writing borrow.\n            None\n        } else {\n            borrow.set(b + 1);\n            Some(BorrowRef { borrow })\n        }\n    }\n}\n\nimpl Drop for BorrowRef<'_> {\n    #[inline]\n    fn drop(&mut self) {\n        let borrow = self.borrow.get();\n        debug_assert!(is_reading(borrow));\n        self.borrow.set(borrow - 1);\n    }\n}\n\nimpl Clone for BorrowRef<'_> {\n    #[inline]\n    fn clone(&self) -> Self {\n        // Since this Ref exists, we know the borrow flag\n        // is a reading borrow.\n        let borrow = self.borrow.get();\n        debug_assert!(is_reading(borrow));\n        // Prevent the borrow counter from overflowing into\n        // a writing borrow.\n        assert!(borrow != isize::max_value());\n        self.borrow.set(borrow + 1);\n        BorrowRef { borrow: self.borrow }\n    }\n}\n\n/// Wraps a borrowed reference to a value in a `RefCell` box.\n/// A wrapper type for an immutably borrowed value from a `RefCell<T>`.\n///\n/// See the [module-level documentation](index.html) for more.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Ref<'b, T: ?Sized + 'b> {\n    value: &'b T,\n    borrow: BorrowRef<'b>,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Deref for Ref<'_, T> {\n    type Target = T;\n\n    #[inline]\n    fn deref(&self) -> &T {\n        self.value\n    }\n}\n\nimpl<'b, T: ?Sized> Ref<'b, T> {\n    /// Copies a `Ref`.\n    ///\n    /// The `RefCell` is already immutably borrowed, so this cannot fail.\n    ///\n    /// This is an associated function that needs to be used as\n    /// `Ref::clone(...)`.  A `Clone` implementation or a method would interfere\n    /// with the widespread use of `r.borrow().clone()` to clone the contents of\n    /// a `RefCell`.\n    #[stable(feature = \"cell_extras\", since = \"1.15.0\")]\n    #[inline]\n    pub fn clone(orig: &Ref<'b, T>) -> Ref<'b, T> {\n        Ref {\n            value: orig.value,\n            borrow: orig.borrow.clone(),\n        }\n    }\n\n    /// Make a new `Ref` for a component of the borrowed data.\n    ///\n    /// The `RefCell` is already immutably borrowed, so this cannot fail.\n    ///\n    /// This is an associated function that needs to be used as `Ref::map(...)`.\n    /// A method would interfere with methods of the same name on the contents\n    /// of a `RefCell` used through `Deref`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::{RefCell, Ref};\n    ///\n    /// let c = RefCell::new((5, 'b'));\n    /// let b1: Ref<(u32, char)> = c.borrow();\n    /// let b2: Ref<u32> = Ref::map(b1, |t| &t.0);\n    /// assert_eq!(*b2, 5)\n    /// ```\n    #[stable(feature = \"cell_map\", since = \"1.8.0\")]\n    #[inline]\n    pub fn map<U: ?Sized, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>\n        where F: FnOnce(&T) -> &U\n    {\n        Ref {\n            value: f(orig.value),\n            borrow: orig.borrow,\n        }\n    }\n\n    /// Split a `Ref` into multiple `Ref`s for different components of the\n    /// borrowed data.\n    ///\n    /// The `RefCell` is already immutably borrowed, so this cannot fail.\n    ///\n    /// This is an associated function that needs to be used as\n    /// `Ref::map_split(...)`. A method would interfere with methods of the same\n    /// name on the contents of a `RefCell` used through `Deref`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(refcell_map_split)]\n    /// use std::cell::{Ref, RefCell};\n    ///\n    /// let cell = RefCell::new([1, 2, 3, 4]);\n    /// let borrow = cell.borrow();\n    /// let (begin, end) = Ref::map_split(borrow, |slice| slice.split_at(2));\n    /// assert_eq!(*begin, [1, 2]);\n    /// assert_eq!(*end, [3, 4]);\n    /// ```\n    #[unstable(feature = \"refcell_map_split\", issue = \"51476\")]\n    #[inline]\n    pub fn map_split<U: ?Sized, V: ?Sized, F>(orig: Ref<'b, T>, f: F) -> (Ref<'b, U>, Ref<'b, V>)\n        where F: FnOnce(&T) -> (&U, &V)\n    {\n        let (a, b) = f(orig.value);\n        let borrow = orig.borrow.clone();\n        (Ref { value: a, borrow }, Ref { value: b, borrow: orig.borrow })\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Ref<'b, U>> for Ref<'b, T> {}\n\n#[stable(feature = \"std_guard_impls\", since = \"1.20.0\")]\nimpl<T: ?Sized + fmt::Display> fmt::Display for Ref<'_, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.value.fmt(f)\n    }\n}\n\nimpl<'b, T: ?Sized> RefMut<'b, T> {\n    /// Make a new `RefMut` for a component of the borrowed data, e.g. an enum\n    /// variant.\n    ///\n    /// The `RefCell` is already mutably borrowed, so this cannot fail.\n    ///\n    /// This is an associated function that needs to be used as\n    /// `RefMut::map(...)`.  A method would interfere with methods of the same\n    /// name on the contents of a `RefCell` used through `Deref`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::{RefCell, RefMut};\n    ///\n    /// let c = RefCell::new((5, 'b'));\n    /// {\n    ///     let b1: RefMut<(u32, char)> = c.borrow_mut();\n    ///     let mut b2: RefMut<u32> = RefMut::map(b1, |t| &mut t.0);\n    ///     assert_eq!(*b2, 5);\n    ///     *b2 = 42;\n    /// }\n    /// assert_eq!(*c.borrow(), (42, 'b'));\n    /// ```\n    #[stable(feature = \"cell_map\", since = \"1.8.0\")]\n    #[inline]\n    pub fn map<U: ?Sized, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U>\n        where F: FnOnce(&mut T) -> &mut U\n    {\n        // FIXME(nll-rfc#40): fix borrow-check\n        let RefMut { value, borrow } = orig;\n        RefMut {\n            value: f(value),\n            borrow,\n        }\n    }\n\n    /// Split a `RefMut` into multiple `RefMut`s for different components of the\n    /// borrowed data.\n    ///\n    /// The underlying `RefCell` will remain mutably borrowed until both\n    /// returned `RefMut`s go out of scope.\n    ///\n    /// The `RefCell` is already mutably borrowed, so this cannot fail.\n    ///\n    /// This is an associated function that needs to be used as\n    /// `RefMut::map_split(...)`. A method would interfere with methods of the\n    /// same name on the contents of a `RefCell` used through `Deref`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(refcell_map_split)]\n    /// use std::cell::{RefCell, RefMut};\n    ///\n    /// let cell = RefCell::new([1, 2, 3, 4]);\n    /// let borrow = cell.borrow_mut();\n    /// let (mut begin, mut end) = RefMut::map_split(borrow, |slice| slice.split_at_mut(2));\n    /// assert_eq!(*begin, [1, 2]);\n    /// assert_eq!(*end, [3, 4]);\n    /// begin.copy_from_slice(&[4, 3]);\n    /// end.copy_from_slice(&[2, 1]);\n    /// ```\n    #[unstable(feature = \"refcell_map_split\", issue = \"51476\")]\n    #[inline]\n    pub fn map_split<U: ?Sized, V: ?Sized, F>(\n        orig: RefMut<'b, T>, f: F\n    ) -> (RefMut<'b, U>, RefMut<'b, V>)\n        where F: FnOnce(&mut T) -> (&mut U, &mut V)\n    {\n        let (a, b) = f(orig.value);\n        let borrow = orig.borrow.clone();\n        (RefMut { value: a, borrow }, RefMut { value: b, borrow: orig.borrow })\n    }\n}\n\nstruct BorrowRefMut<'b> {\n    borrow: &'b Cell<BorrowFlag>,\n}\n\nimpl Drop for BorrowRefMut<'_> {\n    #[inline]\n    fn drop(&mut self) {\n        let borrow = self.borrow.get();\n        debug_assert!(is_writing(borrow));\n        self.borrow.set(borrow + 1);\n    }\n}\n\nimpl<'b> BorrowRefMut<'b> {\n    #[inline]\n    fn new(borrow: &'b Cell<BorrowFlag>) -> Option<BorrowRefMut<'b>> {\n        // NOTE: Unlike BorrowRefMut::clone, new is called to create the initial\n        // mutable reference, and so there must currently be no existing\n        // references. Thus, while clone increments the mutable refcount, here\n        // we explicitly only allow going from UNUSED to UNUSED - 1.\n        match borrow.get() {\n            UNUSED => {\n                borrow.set(UNUSED - 1);\n                Some(BorrowRefMut { borrow })\n            },\n            _ => None,\n        }\n    }\n\n    // Clone a `BorrowRefMut`.\n    //\n    // This is only valid if each `BorrowRefMut` is used to track a mutable\n    // reference to a distinct, nonoverlapping range of the original object.\n    // This isn't in a Clone impl so that code doesn't call this implicitly.\n    #[inline]\n    fn clone(&self) -> BorrowRefMut<'b> {\n        let borrow = self.borrow.get();\n        debug_assert!(is_writing(borrow));\n        // Prevent the borrow counter from underflowing.\n        assert!(borrow != isize::min_value());\n        self.borrow.set(borrow - 1);\n        BorrowRefMut { borrow: self.borrow }\n    }\n}\n\n/// A wrapper type for a mutably borrowed value from a `RefCell<T>`.\n///\n/// See the [module-level documentation](index.html) for more.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RefMut<'b, T: ?Sized + 'b> {\n    value: &'b mut T,\n    borrow: BorrowRefMut<'b>,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Deref for RefMut<'_, T> {\n    type Target = T;\n\n    #[inline]\n    fn deref(&self) -> &T {\n        self.value\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> DerefMut for RefMut<'_, T> {\n    #[inline]\n    fn deref_mut(&mut self) -> &mut T {\n        self.value\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<'b, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<RefMut<'b, U>> for RefMut<'b, T> {}\n\n#[stable(feature = \"std_guard_impls\", since = \"1.20.0\")]\nimpl<T: ?Sized + fmt::Display> fmt::Display for RefMut<'_, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.value.fmt(f)\n    }\n}\n\n/// The core primitive for interior mutability in Rust.\n///\n/// `UnsafeCell<T>` is a type that wraps some `T` and indicates unsafe interior operations on the\n/// wrapped type. Types with an `UnsafeCell<T>` field are considered to have an 'unsafe interior'.\n/// The `UnsafeCell<T>` type is the only legal way to obtain aliasable data that is considered\n/// mutable. In general, transmuting an `&T` type into an `&mut T` is considered undefined behavior.\n///\n/// If you have a reference `&SomeStruct`, then normally in Rust all fields of `SomeStruct` are\n/// immutable. The compiler makes optimizations based on the knowledge that `&T` is not mutably\n/// aliased or mutated, and that `&mut T` is unique. `UnsafeCell<T>` is the only core language\n/// feature to work around this restriction. All other types that allow internal mutability, such as\n/// `Cell<T>` and `RefCell<T>`, use `UnsafeCell` to wrap their internal data.\n///\n/// The `UnsafeCell` API itself is technically very simple: it gives you a raw pointer `*mut T` to\n/// its contents. It is up to _you_ as the abstraction designer to use that raw pointer correctly.\n///\n/// The precise Rust aliasing rules are somewhat in flux, but the main points are not contentious:\n///\n/// - If you create a safe reference with lifetime `'a` (either a `&T` or `&mut T`\n/// reference) that is accessible by safe code (for example, because you returned it),\n/// then you must not access the data in any way that contradicts that reference for the\n/// remainder of `'a`. For example, this means that if you take the `*mut T` from an\n/// `UnsafeCell<T>` and cast it to an `&T`, then the data in `T` must remain immutable\n/// (modulo any `UnsafeCell` data found within `T`, of course) until that reference's\n/// lifetime expires. Similarly, if you create a `&mut T` reference that is released to\n/// safe code, then you must not access the data within the `UnsafeCell` until that\n/// reference expires.\n///\n/// - At all times, you must avoid data races. If multiple threads have access to\n/// the same `UnsafeCell`, then any writes must have a proper happens-before relation to all other\n/// accesses (or use atomics).\n///\n/// To assist with proper design, the following scenarios are explicitly declared legal\n/// for single-threaded code:\n///\n/// 1. A `&T` reference can be released to safe code and there it can co-exist with other `&T`\n/// references, but not with a `&mut T`\n///\n/// 2. A `&mut T` reference may be released to safe code provided neither other `&mut T` nor `&T`\n/// co-exist with it. A `&mut T` must always be unique.\n///\n/// Note that while mutating or mutably aliasing the contents of an `&UnsafeCell<T>` is\n/// okay (provided you enforce the invariants some other way), it is still undefined behavior\n/// to have multiple `&mut UnsafeCell<T>` aliases.\n///\n/// # Examples\n///\n/// ```\n/// use std::cell::UnsafeCell;\n/// use std::marker::Sync;\n///\n/// # #[allow(dead_code)]\n/// struct NotThreadSafe<T> {\n///     value: UnsafeCell<T>,\n/// }\n///\n/// unsafe impl<T> Sync for NotThreadSafe<T> {}\n/// ```\n#[lang = \"unsafe_cell\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[repr(transparent)]\npub struct UnsafeCell<T: ?Sized> {\n    value: T,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> !Sync for UnsafeCell<T> {}\n\nimpl<T> UnsafeCell<T> {\n    /// Constructs a new instance of `UnsafeCell` which will wrap the specified\n    /// value.\n    ///\n    /// All access to the inner value through methods is `unsafe`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::UnsafeCell;\n    ///\n    /// let uc = UnsafeCell::new(5);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub const fn new(value: T) -> UnsafeCell<T> {\n        UnsafeCell { value }\n    }\n\n    /// Unwraps the value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::UnsafeCell;\n    ///\n    /// let uc = UnsafeCell::new(5);\n    ///\n    /// let five = uc.into_inner();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(self) -> T {\n        self.value\n    }\n}\n\nimpl<T: ?Sized> UnsafeCell<T> {\n    /// Gets a mutable pointer to the wrapped value.\n    ///\n    /// This can be cast to a pointer of any kind.\n    /// Ensure that the access is unique (no active references, mutable or not)\n    /// when casting to `&mut T`, and ensure that there are no mutations\n    /// or mutable aliases going on when casting to `&T`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::cell::UnsafeCell;\n    ///\n    /// let uc = UnsafeCell::new(5);\n    ///\n    /// let five = uc.get();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get(&self) -> *mut T {\n        &self.value as *const T as *mut T\n    }\n}\n\n#[stable(feature = \"unsafe_cell_default\", since = \"1.10.0\")]\nimpl<T: Default> Default for UnsafeCell<T> {\n    /// Creates an `UnsafeCell`, with the `Default` value for T.\n    fn default() -> UnsafeCell<T> {\n        UnsafeCell::new(Default::default())\n    }\n}\n\n#[stable(feature = \"cell_from\", since = \"1.12.0\")]\nimpl<T> From<T> for UnsafeCell<T> {\n    fn from(t: T) -> UnsafeCell<T> {\n        UnsafeCell::new(t)\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: CoerceUnsized<U>, U> CoerceUnsized<UnsafeCell<U>> for UnsafeCell<T> {}\n\n#[allow(unused)]\nfn assert_coerce_unsized(a: UnsafeCell<&i32>, b: Cell<&i32>, c: RefCell<&i32>) {\n    let _: UnsafeCell<&dyn Send> = a;\n    let _: Cell<&dyn Send> = b;\n    let _: RefCell<&dyn Send> = c;\n}\n","// Copyright 2018 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Panic support in the standard library.\n\n#![unstable(feature = \"core_panic_info\",\n            reason = \"newly available in libcore\",\n            issue = \"44489\")]\n\nuse any::Any;\nuse fmt;\n\n/// A struct providing information about a panic.\n///\n/// `PanicInfo` structure is passed to a panic hook set by the [`set_hook`]\n/// function.\n///\n/// [`set_hook`]: ../../std/panic/fn.set_hook.html\n///\n/// # Examples\n///\n/// ```should_panic\n/// use std::panic;\n///\n/// panic::set_hook(Box::new(|panic_info| {\n///     if let Some(s) = panic_info.payload().downcast_ref::<&str>() {\n///         println!(\"panic occurred: {:?}\", s);\n///     } else {\n///         println!(\"panic occurred\");\n///     }\n/// }));\n///\n/// panic!(\"Normal panic\");\n/// ```\n#[lang = \"panic_info\"]\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\n#[derive(Debug)]\npub struct PanicInfo<'a> {\n    payload: &'a (dyn Any + Send),\n    message: Option<&'a fmt::Arguments<'a>>,\n    location: Location<'a>,\n}\n\nimpl<'a> PanicInfo<'a> {\n    #![unstable(feature = \"panic_internals\",\n                reason = \"internal details of the implementation of the `panic!` \\\n                          and related macros\",\n                issue = \"0\")]\n    #[doc(hidden)]\n    #[inline]\n    pub fn internal_constructor(message: Option<&'a fmt::Arguments<'a>>,\n                                location: Location<'a>)\n                                -> Self {\n        struct NoPayload;\n        PanicInfo { payload: &NoPayload, location, message }\n    }\n\n    #[doc(hidden)]\n    #[inline]\n    pub fn set_payload(&mut self, info: &'a (dyn Any + Send)) {\n        self.payload = info;\n    }\n\n    /// Returns the payload associated with the panic.\n    ///\n    /// This will commonly, but not always, be a `&'static str` or [`String`].\n    ///\n    /// [`String`]: ../../std/string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// ```should_panic\n    /// use std::panic;\n    ///\n    /// panic::set_hook(Box::new(|panic_info| {\n    ///     println!(\"panic occurred: {:?}\", panic_info.payload().downcast_ref::<&str>().unwrap());\n    /// }));\n    ///\n    /// panic!(\"Normal panic\");\n    /// ```\n    #[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\n    pub fn payload(&self) -> &(dyn Any + Send) {\n        self.payload\n    }\n\n    /// If the `panic!` macro from the `core` crate (not from `std`)\n    /// was used with a formatting string and some additional arguments,\n    /// returns that message ready to be used for example with [`fmt::write`]\n    ///\n    /// [`fmt::write`]: ../fmt/fn.write.html\n    #[unstable(feature = \"panic_info_message\", issue = \"44489\")]\n    pub fn message(&self) -> Option<&fmt::Arguments> {\n        self.message\n    }\n\n    /// Returns information about the location from which the panic originated,\n    /// if available.\n    ///\n    /// This method will currently always return [`Some`], but this may change\n    /// in future versions.\n    ///\n    /// [`Some`]: ../../std/option/enum.Option.html#variant.Some\n    ///\n    /// # Examples\n    ///\n    /// ```should_panic\n    /// use std::panic;\n    ///\n    /// panic::set_hook(Box::new(|panic_info| {\n    ///     if let Some(location) = panic_info.location() {\n    ///         println!(\"panic occurred in file '{}' at line {}\", location.file(),\n    ///             location.line());\n    ///     } else {\n    ///         println!(\"panic occurred but can't get location information...\");\n    ///     }\n    /// }));\n    ///\n    /// panic!(\"Normal panic\");\n    /// ```\n    #[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\n    pub fn location(&self) -> Option<&Location> {\n        // NOTE: If this is changed to sometimes return None,\n        // deal with that case in std::panicking::default_hook and std::panicking::begin_panic_fmt.\n        Some(&self.location)\n    }\n}\n\n#[stable(feature = \"panic_hook_display\", since = \"1.26.0\")]\nimpl fmt::Display for PanicInfo<'_> {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        formatter.write_str(\"panicked at \")?;\n        if let Some(message) = self.message {\n            write!(formatter, \"'{}', \", message)?\n        } else if let Some(payload) = self.payload.downcast_ref::<&'static str>() {\n            write!(formatter, \"'{}', \", payload)?\n        }\n        // NOTE: we cannot use downcast_ref::<String>() here\n        // since String is not available in libcore!\n        // The payload is a String when `std::panic!` is called with multiple arguments,\n        // but in that case the message is also available.\n\n        self.location.fmt(formatter)\n    }\n}\n\n/// A struct containing information about the location of a panic.\n///\n/// This structure is created by the [`location`] method of [`PanicInfo`].\n///\n/// [`location`]: ../../std/panic/struct.PanicInfo.html#method.location\n/// [`PanicInfo`]: ../../std/panic/struct.PanicInfo.html\n///\n/// # Examples\n///\n/// ```should_panic\n/// use std::panic;\n///\n/// panic::set_hook(Box::new(|panic_info| {\n///     if let Some(location) = panic_info.location() {\n///         println!(\"panic occurred in file '{}' at line {}\", location.file(), location.line());\n///     } else {\n///         println!(\"panic occurred but can't get location information...\");\n///     }\n/// }));\n///\n/// panic!(\"Normal panic\");\n/// ```\n#[derive(Debug)]\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\npub struct Location<'a> {\n    file: &'a str,\n    line: u32,\n    col: u32,\n}\n\nimpl<'a> Location<'a> {\n    #![unstable(feature = \"panic_internals\",\n                reason = \"internal details of the implementation of the `panic!` \\\n                          and related macros\",\n                issue = \"0\")]\n    #[doc(hidden)]\n    pub fn internal_constructor(file: &'a str, line: u32, col: u32) -> Self {\n        Location { file, line, col }\n    }\n\n    /// Returns the name of the source file from which the panic originated.\n    ///\n    /// # Examples\n    ///\n    /// ```should_panic\n    /// use std::panic;\n    ///\n    /// panic::set_hook(Box::new(|panic_info| {\n    ///     if let Some(location) = panic_info.location() {\n    ///         println!(\"panic occurred in file '{}'\", location.file());\n    ///     } else {\n    ///         println!(\"panic occurred but can't get location information...\");\n    ///     }\n    /// }));\n    ///\n    /// panic!(\"Normal panic\");\n    /// ```\n    #[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\n    pub fn file(&self) -> &str {\n        self.file\n    }\n\n    /// Returns the line number from which the panic originated.\n    ///\n    /// # Examples\n    ///\n    /// ```should_panic\n    /// use std::panic;\n    ///\n    /// panic::set_hook(Box::new(|panic_info| {\n    ///     if let Some(location) = panic_info.location() {\n    ///         println!(\"panic occurred at line {}\", location.line());\n    ///     } else {\n    ///         println!(\"panic occurred but can't get location information...\");\n    ///     }\n    /// }));\n    ///\n    /// panic!(\"Normal panic\");\n    /// ```\n    #[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\n    pub fn line(&self) -> u32 {\n        self.line\n    }\n\n    /// Returns the column from which the panic originated.\n    ///\n    /// # Examples\n    ///\n    /// ```should_panic\n    /// use std::panic;\n    ///\n    /// panic::set_hook(Box::new(|panic_info| {\n    ///     if let Some(location) = panic_info.location() {\n    ///         println!(\"panic occurred at column {}\", location.column());\n    ///     } else {\n    ///         println!(\"panic occurred but can't get location information...\");\n    ///     }\n    /// }));\n    ///\n    /// panic!(\"Normal panic\");\n    /// ```\n    #[stable(feature = \"panic_col\", since = \"1.25.0\")]\n    pub fn column(&self) -> u32 {\n        self.col\n    }\n}\n\n#[stable(feature = \"panic_hook_display\", since = \"1.26.0\")]\nimpl fmt::Display for Location<'_> {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        write!(formatter, \"{}:{}:{}\", self.file, self.line, self.col)\n    }\n}\n\n/// An internal trait used by libstd to pass data from libstd to `panic_unwind`\n/// and other panic runtimes. Not intended to be stabilized any time soon, do\n/// not use.\n#[unstable(feature = \"std_internals\", issue = \"0\")]\n#[doc(hidden)]\npub unsafe trait BoxMeUp {\n    fn box_me_up(&mut self) -> *mut (dyn Any + Send);\n    fn get(&mut self) -> &(dyn Any + Send);\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cell::UnsafeCell;\n\npub struct RWLock {\n    mode: UnsafeCell<isize>,\n}\n\nunsafe impl Send for RWLock {}\nunsafe impl Sync for RWLock {} // no threads on wasm\n\nimpl RWLock {\n    pub const fn new() -> RWLock {\n        RWLock {\n            mode: UnsafeCell::new(0),\n        }\n    }\n\n    #[inline]\n    pub unsafe fn read(&self) {\n        let mode = self.mode.get();\n        if *mode >= 0 {\n            *mode += 1;\n        } else {\n            rtabort!(\"rwlock locked for writing\");\n        }\n    }\n\n    #[inline]\n    pub unsafe fn try_read(&self) -> bool {\n        let mode = self.mode.get();\n        if *mode >= 0 {\n            *mode += 1;\n            true\n        } else {\n            false\n        }\n    }\n\n    #[inline]\n    pub unsafe fn write(&self) {\n        let mode = self.mode.get();\n        if *mode == 0 {\n            *mode = -1;\n        } else {\n            rtabort!(\"rwlock locked for reading\")\n        }\n    }\n\n    #[inline]\n    pub unsafe fn try_write(&self) -> bool {\n        let mode = self.mode.get();\n        if *mode == 0 {\n            *mode = -1;\n            true\n        } else {\n            false\n        }\n    }\n\n    #[inline]\n    pub unsafe fn read_unlock(&self) {\n        *self.mode.get() -= 1;\n    }\n\n    #[inline]\n    pub unsafe fn write_unlock(&self) {\n        *self.mode.get() += 1;\n    }\n\n    #[inline]\n    pub unsafe fn destroy(&self) {\n    }\n}\n","// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A pointer type for heap allocation.\n//!\n//! `Box<T>`, casually referred to as a 'box', provides the simplest form of\n//! heap allocation in Rust. Boxes provide ownership for this allocation, and\n//! drop their contents when they go out of scope.\n//!\n//! # Examples\n//!\n//! Move a value from the stack to the heap by creating a [`Box`]:\n//!\n//! ```\n//! let val: u8 = 5;\n//! let boxed: Box<u8> = Box::new(val);\n//! ```\n//!\n//! Move a value from a [`Box`] back to the stack by [dereferencing]:\n//!\n//! ```\n//! let boxed: Box<u8> = Box::new(5);\n//! let val: u8 = *boxed;\n//! ```\n//!\n//! Creating a recursive data structure:\n//!\n//! ```\n//! #[derive(Debug)]\n//! enum List<T> {\n//!     Cons(T, Box<List<T>>),\n//!     Nil,\n//! }\n//!\n//! fn main() {\n//!     let list: List<i32> = List::Cons(1, Box::new(List::Cons(2, Box::new(List::Nil))));\n//!     println!(\"{:?}\", list);\n//! }\n//! ```\n//!\n//! This will print `Cons(1, Cons(2, Nil))`.\n//!\n//! Recursive structures must be boxed, because if the definition of `Cons`\n//! looked like this:\n//!\n//! ```compile_fail,E0072\n//! # enum List<T> {\n//! Cons(T, List<T>),\n//! # }\n//! ```\n//!\n//! It wouldn't work. This is because the size of a `List` depends on how many\n//! elements are in the list, and so we don't know how much memory to allocate\n//! for a `Cons`. By introducing a `Box`, which has a defined size, we know how\n//! big `Cons` needs to be.\n//!\n//! [dereferencing]: ../../std/ops/trait.Deref.html\n//! [`Box`]: struct.Box.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse core::any::Any;\nuse core::borrow;\nuse core::cmp::Ordering;\nuse core::convert::From;\nuse core::fmt;\nuse core::future::Future;\nuse core::hash::{Hash, Hasher};\nuse core::iter::FusedIterator;\nuse core::marker::{Unpin, Unsize};\nuse core::mem;\nuse core::pin::Pin;\nuse core::ops::{CoerceUnsized, DispatchFromDyn, Deref, DerefMut, Generator, GeneratorState};\nuse core::ptr::{self, NonNull, Unique};\nuse core::task::{LocalWaker, Poll};\n\nuse raw_vec::RawVec;\nuse str::from_boxed_utf8_unchecked;\n\n/// A pointer type for heap allocation.\n///\n/// See the [module-level documentation](../../std/boxed/index.html) for more.\n#[lang = \"owned_box\"]\n#[fundamental]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Box<T: ?Sized>(Unique<T>);\n\nimpl<T> Box<T> {\n    /// Allocates memory on the heap and then places `x` into it.\n    ///\n    /// This doesn't actually allocate if `T` is zero-sized.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let five = Box::new(5);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline(always)]\n    pub fn new(x: T) -> Box<T> {\n        box x\n    }\n\n    #[unstable(feature = \"pin\", issue = \"49150\")]\n    #[inline(always)]\n    pub fn pinned(x: T) -> Pin<Box<T>> {\n        (box x).into()\n    }\n}\n\nimpl<T: ?Sized> Box<T> {\n    /// Constructs a box from a raw pointer.\n    ///\n    /// After calling this function, the raw pointer is owned by the\n    /// resulting `Box`. Specifically, the `Box` destructor will call\n    /// the destructor of `T` and free the allocated memory. Since the\n    /// way `Box` allocates and releases memory is unspecified, the\n    /// only valid pointer to pass to this function is the one taken\n    /// from another `Box` via the [`Box::into_raw`] function.\n    ///\n    /// This function is unsafe because improper use may lead to\n    /// memory problems. For example, a double-free may occur if the\n    /// function is called twice on the same raw pointer.\n    ///\n    /// [`Box::into_raw`]: struct.Box.html#method.into_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Box::new(5);\n    /// let ptr = Box::into_raw(x);\n    /// let x = unsafe { Box::from_raw(ptr) };\n    /// ```\n    #[stable(feature = \"box_raw\", since = \"1.4.0\")]\n    #[inline]\n    pub unsafe fn from_raw(raw: *mut T) -> Self {\n        Box(Unique::new_unchecked(raw))\n    }\n\n    /// Consumes the `Box`, returning a wrapped raw pointer.\n    ///\n    /// The pointer will be properly aligned and non-null.\n    ///\n    /// After calling this function, the caller is responsible for the\n    /// memory previously managed by the `Box`. In particular, the\n    /// caller should properly destroy `T` and release the memory. The\n    /// proper way to do so is to convert the raw pointer back into a\n    /// `Box` with the [`Box::from_raw`] function.\n    ///\n    /// Note: this is an associated function, which means that you have\n    /// to call it as `Box::into_raw(b)` instead of `b.into_raw()`. This\n    /// is so that there is no conflict with a method on the inner type.\n    ///\n    /// [`Box::from_raw`]: struct.Box.html#method.from_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Box::new(5);\n    /// let ptr = Box::into_raw(x);\n    /// ```\n    #[stable(feature = \"box_raw\", since = \"1.4.0\")]\n    #[inline]\n    pub fn into_raw(b: Box<T>) -> *mut T {\n        Box::into_raw_non_null(b).as_ptr()\n    }\n\n    /// Consumes the `Box`, returning the wrapped pointer as `NonNull<T>`.\n    ///\n    /// After calling this function, the caller is responsible for the\n    /// memory previously managed by the `Box`. In particular, the\n    /// caller should properly destroy `T` and release the memory. The\n    /// proper way to do so is to convert the `NonNull<T>` pointer\n    /// into a raw pointer and back into a `Box` with the [`Box::from_raw`]\n    /// function.\n    ///\n    /// Note: this is an associated function, which means that you have\n    /// to call it as `Box::into_raw_non_null(b)`\n    /// instead of `b.into_raw_non_null()`. This\n    /// is so that there is no conflict with a method on the inner type.\n    ///\n    /// [`Box::from_raw`]: struct.Box.html#method.from_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(box_into_raw_non_null)]\n    ///\n    /// fn main() {\n    ///     let x = Box::new(5);\n    ///     let ptr = Box::into_raw_non_null(x);\n    /// }\n    /// ```\n    #[unstable(feature = \"box_into_raw_non_null\", issue = \"47336\")]\n    #[inline]\n    pub fn into_raw_non_null(b: Box<T>) -> NonNull<T> {\n        Box::into_unique(b).into()\n    }\n\n    #[unstable(feature = \"ptr_internals\", issue = \"0\", reason = \"use into_raw_non_null instead\")]\n    #[inline]\n    #[doc(hidden)]\n    pub fn into_unique(b: Box<T>) -> Unique<T> {\n        let unique = b.0;\n        mem::forget(b);\n        unique\n    }\n\n    /// Consumes and leaks the `Box`, returning a mutable reference,\n    /// `&'a mut T`. Note that the type `T` must outlive the chosen lifetime\n    /// `'a`. If the type has only static references, or none at all, then this\n    /// may be chosen to be `'static`.\n    ///\n    /// This function is mainly useful for data that lives for the remainder of\n    /// the program's life. Dropping the returned reference will cause a memory\n    /// leak. If this is not acceptable, the reference should first be wrapped\n    /// with the [`Box::from_raw`] function producing a `Box`. This `Box` can\n    /// then be dropped which will properly destroy `T` and release the\n    /// allocated memory.\n    ///\n    /// Note: this is an associated function, which means that you have\n    /// to call it as `Box::leak(b)` instead of `b.leak()`. This\n    /// is so that there is no conflict with a method on the inner type.\n    ///\n    /// [`Box::from_raw`]: struct.Box.html#method.from_raw\n    ///\n    /// # Examples\n    ///\n    /// Simple usage:\n    ///\n    /// ```\n    /// fn main() {\n    ///     let x = Box::new(41);\n    ///     let static_ref: &'static mut usize = Box::leak(x);\n    ///     *static_ref += 1;\n    ///     assert_eq!(*static_ref, 42);\n    /// }\n    /// ```\n    ///\n    /// Unsized data:\n    ///\n    /// ```\n    /// fn main() {\n    ///     let x = vec![1, 2, 3].into_boxed_slice();\n    ///     let static_ref = Box::leak(x);\n    ///     static_ref[0] = 4;\n    ///     assert_eq!(*static_ref, [4, 2, 3]);\n    /// }\n    /// ```\n    #[stable(feature = \"box_leak\", since = \"1.26.0\")]\n    #[inline]\n    pub fn leak<'a>(b: Box<T>) -> &'a mut T\n    where\n        T: 'a // Technically not needed, but kept to be explicit.\n    {\n        unsafe { &mut *Box::into_raw(b) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<#[may_dangle] T: ?Sized> Drop for Box<T> {\n    fn drop(&mut self) {\n        // FIXME: Do nothing, drop is currently performed by compiler.\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Default> Default for Box<T> {\n    /// Creates a `Box<T>`, with the `Default` value for T.\n    fn default() -> Box<T> {\n        box Default::default()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Default for Box<[T]> {\n    fn default() -> Box<[T]> {\n        Box::<[T; 0]>::new([])\n    }\n}\n\n#[stable(feature = \"default_box_extra\", since = \"1.17.0\")]\nimpl Default for Box<str> {\n    fn default() -> Box<str> {\n        unsafe { from_boxed_utf8_unchecked(Default::default()) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Clone> Clone for Box<T> {\n    /// Returns a new box with a `clone()` of this box's contents.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Box::new(5);\n    /// let y = x.clone();\n    /// ```\n    #[rustfmt_skip]\n    #[inline]\n    fn clone(&self) -> Box<T> {\n        box { (**self).clone() }\n    }\n    /// Copies `source`'s contents into `self` without creating a new allocation.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let x = Box::new(5);\n    /// let mut y = Box::new(10);\n    ///\n    /// y.clone_from(&x);\n    ///\n    /// assert_eq!(*y, 5);\n    /// ```\n    #[inline]\n    fn clone_from(&mut self, source: &Box<T>) {\n        (**self).clone_from(&(**source));\n    }\n}\n\n\n#[stable(feature = \"box_slice_clone\", since = \"1.3.0\")]\nimpl Clone for Box<str> {\n    fn clone(&self) -> Self {\n        let len = self.len();\n        let buf = RawVec::with_capacity(len);\n        unsafe {\n            ptr::copy_nonoverlapping(self.as_ptr(), buf.ptr(), len);\n            from_boxed_utf8_unchecked(buf.into_box())\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + PartialEq> PartialEq for Box<T> {\n    #[inline]\n    fn eq(&self, other: &Box<T>) -> bool {\n        PartialEq::eq(&**self, &**other)\n    }\n    #[inline]\n    fn ne(&self, other: &Box<T>) -> bool {\n        PartialEq::ne(&**self, &**other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + PartialOrd> PartialOrd for Box<T> {\n    #[inline]\n    fn partial_cmp(&self, other: &Box<T>) -> Option<Ordering> {\n        PartialOrd::partial_cmp(&**self, &**other)\n    }\n    #[inline]\n    fn lt(&self, other: &Box<T>) -> bool {\n        PartialOrd::lt(&**self, &**other)\n    }\n    #[inline]\n    fn le(&self, other: &Box<T>) -> bool {\n        PartialOrd::le(&**self, &**other)\n    }\n    #[inline]\n    fn ge(&self, other: &Box<T>) -> bool {\n        PartialOrd::ge(&**self, &**other)\n    }\n    #[inline]\n    fn gt(&self, other: &Box<T>) -> bool {\n        PartialOrd::gt(&**self, &**other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Ord> Ord for Box<T> {\n    #[inline]\n    fn cmp(&self, other: &Box<T>) -> Ordering {\n        Ord::cmp(&**self, &**other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Eq> Eq for Box<T> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Hash> Hash for Box<T> {\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        (**self).hash(state);\n    }\n}\n\n#[stable(feature = \"indirect_hasher_impl\", since = \"1.22.0\")]\nimpl<T: ?Sized + Hasher> Hasher for Box<T> {\n    fn finish(&self) -> u64 {\n        (**self).finish()\n    }\n    fn write(&mut self, bytes: &[u8]) {\n        (**self).write(bytes)\n    }\n    fn write_u8(&mut self, i: u8) {\n        (**self).write_u8(i)\n    }\n    fn write_u16(&mut self, i: u16) {\n        (**self).write_u16(i)\n    }\n    fn write_u32(&mut self, i: u32) {\n        (**self).write_u32(i)\n    }\n    fn write_u64(&mut self, i: u64) {\n        (**self).write_u64(i)\n    }\n    fn write_u128(&mut self, i: u128) {\n        (**self).write_u128(i)\n    }\n    fn write_usize(&mut self, i: usize) {\n        (**self).write_usize(i)\n    }\n    fn write_i8(&mut self, i: i8) {\n        (**self).write_i8(i)\n    }\n    fn write_i16(&mut self, i: i16) {\n        (**self).write_i16(i)\n    }\n    fn write_i32(&mut self, i: i32) {\n        (**self).write_i32(i)\n    }\n    fn write_i64(&mut self, i: i64) {\n        (**self).write_i64(i)\n    }\n    fn write_i128(&mut self, i: i128) {\n        (**self).write_i128(i)\n    }\n    fn write_isize(&mut self, i: isize) {\n        (**self).write_isize(i)\n    }\n}\n\n#[stable(feature = \"from_for_ptrs\", since = \"1.6.0\")]\nimpl<T> From<T> for Box<T> {\n    fn from(t: T) -> Self {\n        Box::new(t)\n    }\n}\n\n#[unstable(feature = \"pin\", issue = \"49150\")]\nimpl<T> From<Box<T>> for Pin<Box<T>> {\n    fn from(boxed: Box<T>) -> Self {\n        // It's not possible to move or replace the insides of a `Pin<Box<T>>`\n        // when `T: !Unpin`,  so it's safe to pin it directly without any\n        // additional requirements.\n        unsafe { Pin::new_unchecked(boxed) }\n    }\n}\n\n#[stable(feature = \"box_from_slice\", since = \"1.17.0\")]\nimpl<'a, T: Copy> From<&'a [T]> for Box<[T]> {\n    fn from(slice: &'a [T]) -> Box<[T]> {\n        let mut boxed = unsafe { RawVec::with_capacity(slice.len()).into_box() };\n        boxed.copy_from_slice(slice);\n        boxed\n    }\n}\n\n#[stable(feature = \"box_from_slice\", since = \"1.17.0\")]\nimpl<'a> From<&'a str> for Box<str> {\n    #[inline]\n    fn from(s: &'a str) -> Box<str> {\n        unsafe { from_boxed_utf8_unchecked(Box::from(s.as_bytes())) }\n    }\n}\n\n#[stable(feature = \"boxed_str_conv\", since = \"1.19.0\")]\nimpl From<Box<str>> for Box<[u8]> {\n    #[inline]\n    fn from(s: Box<str>) -> Self {\n        unsafe { Box::from_raw(Box::into_raw(s) as *mut [u8]) }\n    }\n}\n\nimpl Box<dyn Any> {\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    /// Attempt to downcast the box to a concrete type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn print_if_string(value: Box<Any>) {\n    ///     if let Ok(string) = value.downcast::<String>() {\n    ///         println!(\"String ({}): {}\", string.len(), string);\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let my_string = \"Hello World\".to_string();\n    ///     print_if_string(Box::new(my_string));\n    ///     print_if_string(Box::new(0i8));\n    /// }\n    /// ```\n    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<dyn Any>> {\n        if self.is::<T>() {\n            unsafe {\n                let raw: *mut dyn Any = Box::into_raw(self);\n                Ok(Box::from_raw(raw as *mut T))\n            }\n        } else {\n            Err(self)\n        }\n    }\n}\n\nimpl Box<dyn Any + Send> {\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    /// Attempt to downcast the box to a concrete type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    ///\n    /// fn print_if_string(value: Box<Any + Send>) {\n    ///     if let Ok(string) = value.downcast::<String>() {\n    ///         println!(\"String ({}): {}\", string.len(), string);\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let my_string = \"Hello World\".to_string();\n    ///     print_if_string(Box::new(my_string));\n    ///     print_if_string(Box::new(0i8));\n    /// }\n    /// ```\n    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<dyn Any + Send>> {\n        <Box<dyn Any>>::downcast(self).map_err(|s| unsafe {\n            // reapply the Send marker\n            Box::from_raw(Box::into_raw(s) as *mut (dyn Any + Send))\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: fmt::Display + ?Sized> fmt::Display for Box<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> fmt::Pointer for Box<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // It's not possible to extract the inner Uniq directly from the Box,\n        // instead we cast it to a *const which aliases the Unique\n        let ptr: *const T = &**self;\n        fmt::Pointer::fmt(&ptr, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Deref for Box<T> {\n    type Target = T;\n\n    fn deref(&self) -> &T {\n        &**self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> DerefMut for Box<T> {\n    fn deref_mut(&mut self) -> &mut T {\n        &mut **self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator + ?Sized> Iterator for Box<I> {\n    type Item = I::Item;\n    fn next(&mut self) -> Option<I::Item> {\n        (**self).next()\n    }\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (**self).size_hint()\n    }\n    fn nth(&mut self, n: usize) -> Option<I::Item> {\n        (**self).nth(n)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for Box<I> {\n    fn next_back(&mut self) -> Option<I::Item> {\n        (**self).next_back()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {\n    fn len(&self) -> usize {\n        (**self).len()\n    }\n    fn is_empty(&self) -> bool {\n        (**self).is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I: FusedIterator + ?Sized> FusedIterator for Box<I> {}\n\n\n/// `FnBox` is a version of the `FnOnce` intended for use with boxed\n/// closure objects. The idea is that where one would normally store a\n/// `Box<FnOnce()>` in a data structure, you should use\n/// `Box<FnBox()>`. The two traits behave essentially the same, except\n/// that a `FnBox` closure can only be called if it is boxed. (Note\n/// that `FnBox` may be deprecated in the future if `Box<FnOnce()>`\n/// closures become directly usable.)\n///\n/// # Examples\n///\n/// Here is a snippet of code which creates a hashmap full of boxed\n/// once closures and then removes them one by one, calling each\n/// closure as it is removed. Note that the type of the closures\n/// stored in the map is `Box<FnBox() -> i32>` and not `Box<FnOnce()\n/// -> i32>`.\n///\n/// ```\n/// #![feature(fnbox)]\n///\n/// use std::boxed::FnBox;\n/// use std::collections::HashMap;\n///\n/// fn make_map() -> HashMap<i32, Box<FnBox() -> i32>> {\n///     let mut map: HashMap<i32, Box<FnBox() -> i32>> = HashMap::new();\n///     map.insert(1, Box::new(|| 22));\n///     map.insert(2, Box::new(|| 44));\n///     map\n/// }\n///\n/// fn main() {\n///     let mut map = make_map();\n///     for i in &[1, 2] {\n///         let f = map.remove(&i).unwrap();\n///         assert_eq!(f(), i * 22);\n///     }\n/// }\n/// ```\n#[rustc_paren_sugar]\n#[unstable(feature = \"fnbox\",\n           reason = \"will be deprecated if and when `Box<FnOnce>` becomes usable\", issue = \"28796\")]\npub trait FnBox<A> {\n    type Output;\n\n    fn call_box(self: Box<Self>, args: A) -> Self::Output;\n}\n\n#[unstable(feature = \"fnbox\",\n           reason = \"will be deprecated if and when `Box<FnOnce>` becomes usable\", issue = \"28796\")]\nimpl<A, F> FnBox<A> for F\n    where F: FnOnce<A>\n{\n    type Output = F::Output;\n\n    fn call_box(self: Box<F>, args: A) -> F::Output {\n        self.call_once(args)\n    }\n}\n\n#[unstable(feature = \"fnbox\",\n           reason = \"will be deprecated if and when `Box<FnOnce>` becomes usable\", issue = \"28796\")]\nimpl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + 'a> {\n    type Output = R;\n\n    extern \"rust-call\" fn call_once(self, args: A) -> R {\n        self.call_box(args)\n    }\n}\n\n#[unstable(feature = \"fnbox\",\n           reason = \"will be deprecated if and when `Box<FnOnce>` becomes usable\", issue = \"28796\")]\nimpl<'a, A, R> FnOnce<A> for Box<dyn FnBox<A, Output = R> + Send + 'a> {\n    type Output = R;\n\n    extern \"rust-call\" fn call_once(self, args: A) -> R {\n        self.call_box(args)\n    }\n}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Box<U>> for Box<T> {}\n\n#[unstable(feature = \"dispatch_from_dyn\", issue = \"0\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Box<U>> for Box<T> {}\n\n#[stable(feature = \"box_slice_clone\", since = \"1.3.0\")]\nimpl<T: Clone> Clone for Box<[T]> {\n    fn clone(&self) -> Self {\n        let mut new = BoxBuilder {\n            data: RawVec::with_capacity(self.len()),\n            len: 0,\n        };\n\n        let mut target = new.data.ptr();\n\n        for item in self.iter() {\n            unsafe {\n                ptr::write(target, item.clone());\n                target = target.offset(1);\n            };\n\n            new.len += 1;\n        }\n\n        return unsafe { new.into_box() };\n\n        // Helper type for responding to panics correctly.\n        struct BoxBuilder<T> {\n            data: RawVec<T>,\n            len: usize,\n        }\n\n        impl<T> BoxBuilder<T> {\n            unsafe fn into_box(self) -> Box<[T]> {\n                let raw = ptr::read(&self.data);\n                mem::forget(self);\n                raw.into_box()\n            }\n        }\n\n        impl<T> Drop for BoxBuilder<T> {\n            fn drop(&mut self) {\n                let mut data = self.data.ptr();\n                let max = unsafe { data.add(self.len) };\n\n                while data != max {\n                    unsafe {\n                        ptr::read(data);\n                        data = data.offset(1);\n                    }\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"box_borrow\", since = \"1.1.0\")]\nimpl<T: ?Sized> borrow::Borrow<T> for Box<T> {\n    fn borrow(&self) -> &T {\n        &**self\n    }\n}\n\n#[stable(feature = \"box_borrow\", since = \"1.1.0\")]\nimpl<T: ?Sized> borrow::BorrowMut<T> for Box<T> {\n    fn borrow_mut(&mut self) -> &mut T {\n        &mut **self\n    }\n}\n\n#[stable(since = \"1.5.0\", feature = \"smart_ptr_as_ref\")]\nimpl<T: ?Sized> AsRef<T> for Box<T> {\n    fn as_ref(&self) -> &T {\n        &**self\n    }\n}\n\n#[stable(since = \"1.5.0\", feature = \"smart_ptr_as_ref\")]\nimpl<T: ?Sized> AsMut<T> for Box<T> {\n    fn as_mut(&mut self) -> &mut T {\n        &mut **self\n    }\n}\n\n/* Nota bene\n *\n *  We could have chosen not to add this impl, and instead have written a\n *  function of Pin<Box<T>> to Pin<T>. Such a function would not be sound,\n *  because Box<T> implements Unpin even when T does not, as a result of\n *  this impl.\n *\n *  We chose this API instead of the alternative for a few reasons:\n *      - Logically, it is helpful to understand pinning in regard to the\n *        memory region being pointed to. For this reason none of the\n *        standard library pointer types support projecting through a pin\n *        (Box<T> is the only pointer type in std for which this would be\n *        safe.)\n *      - It is in practice very useful to have Box<T> be unconditionally\n *        Unpin because of trait objects, for which the structural auto\n *        trait functionality does not apply (e.g. Box<dyn Foo> would\n *        otherwise not be Unpin).\n *\n *  Another type with the same semantics as Box but only a conditional\n *  implementation of `Unpin` (where `T: Unpin`) would be valid/safe, and\n *  could have a method to project a Pin<T> from it.\n */\n#[unstable(feature = \"pin\", issue = \"49150\")]\nimpl<T: ?Sized> Unpin for Box<T> { }\n\n#[unstable(feature = \"generator_trait\", issue = \"43122\")]\nimpl<T> Generator for Box<T>\n    where T: Generator + ?Sized\n{\n    type Yield = T::Yield;\n    type Return = T::Return;\n    unsafe fn resume(&mut self) -> GeneratorState<Self::Yield, Self::Return> {\n        (**self).resume()\n    }\n}\n\n#[unstable(feature = \"futures_api\", issue = \"50547\")]\nimpl<F: ?Sized + Future + Unpin> Future for Box<F> {\n    type Output = F::Output;\n\n    fn poll(mut self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {\n        F::poll(Pin::new(&mut *self), lw)\n    }\n}\n","// Copyright 2016 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Implementation of Rust panics via process aborts\n//!\n//! When compared to the implementation via unwinding, this crate is *much*\n//! simpler! That being said, it's not quite as versatile, but here goes!\n\n#![no_std]\n#![unstable(feature = \"panic_abort\", issue = \"32837\")]\n#![doc(html_logo_url = \"https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png\",\n       html_favicon_url = \"https://doc.rust-lang.org/favicon.ico\",\n       html_root_url = \"https://doc.rust-lang.org/nightly/\",\n       issue_tracker_base_url = \"https://github.com/rust-lang/rust/issues/\")]\n#![panic_runtime]\n#![allow(unused_features)]\n\n#![feature(core_intrinsics)]\n#![feature(libc)]\n#![feature(nll)]\n#![feature(panic_runtime)]\n#![feature(staged_api)]\n#![feature(rustc_attrs)]\n\n// Rust's \"try\" function, but if we're aborting on panics we just call the\n// function as there's nothing else we need to do here.\n#[rustc_std_internal_symbol]\npub unsafe extern fn __rust_maybe_catch_panic(f: fn(*mut u8),\n                                              data: *mut u8,\n                                              _data_ptr: *mut usize,\n                                              _vtable_ptr: *mut usize) -> u32 {\n    f(data);\n    0\n}\n\n// \"Leak\" the payload and shim to the relevant abort on the platform in\n// question.\n//\n// For Unix we just use `abort` from libc as it'll trigger debuggers, core\n// dumps, etc, as one might expect. On Windows, however, the best option we have\n// is the `__fastfail` intrinsics, but that's unfortunately not defined in LLVM,\n// and the `RaiseFailFastException` function isn't available until Windows 7\n// which would break compat with XP. For now just use `intrinsics::abort` which\n// will kill us with an illegal instruction, which will do a good enough job for\n// now hopefully.\n#[rustc_std_internal_symbol]\npub unsafe extern fn __rust_start_panic(_payload: usize) -> u32 {\n    abort();\n\n    #[cfg(any(unix, target_os = \"cloudabi\"))]\n    unsafe fn abort() -> ! {\n        extern crate libc;\n        libc::abort();\n    }\n\n    #[cfg(any(target_os = \"redox\",\n              windows,\n              all(target_arch = \"wasm32\", not(target_os = \"emscripten\"))))]\n    unsafe fn abort() -> ! {\n        core::intrinsics::abort();\n    }\n}\n\n// This... is a bit of an oddity. The tl;dr; is that this is required to link\n// correctly, the longer explanation is below.\n//\n// Right now the binaries of libcore/libstd that we ship are all compiled with\n// `-C panic=unwind`. This is done to ensure that the binaries are maximally\n// compatible with as many situations as possible. The compiler, however,\n// requires a \"personality function\" for all functions compiled with `-C\n// panic=unwind`. This personality function is hardcoded to the symbol\n// `rust_eh_personality` and is defined by the `eh_personality` lang item.\n//\n// So... why not just define that lang item here? Good question! The way that\n// panic runtimes are linked in is actually a little subtle in that they're\n// \"sort of\" in the compiler's crate store, but only actually linked if another\n// isn't actually linked. This ends up meaning that both this crate and the\n// panic_unwind crate can appear in the compiler's crate store, and if both\n// define the `eh_personality` lang item then that'll hit an error.\n//\n// To handle this the compiler only requires the `eh_personality` is defined if\n// the panic runtime being linked in is the unwinding runtime, and otherwise\n// it's not required to be defined (rightfully so). In this case, however, this\n// library just defines this symbol so there's at least some personality\n// somewhere.\n//\n// Essentially this symbol is just defined to get wired up to libcore/libstd\n// binaries, but it should never be called as we don't link in an unwinding\n// runtime at all.\npub mod personalities {\n    #[no_mangle]\n    #[cfg(not(any(\n        target_arch = \"wasm32\",\n        all(\n            target_os = \"windows\",\n            target_env = \"gnu\",\n            target_arch = \"x86_64\",\n        ),\n    )))]\n    pub extern fn rust_eh_personality() {}\n\n    // On x86_64-pc-windows-gnu we use our own personality function that needs\n    // to return `ExceptionContinueSearch` as we're passing on all our frames.\n    #[no_mangle]\n    #[cfg(all(target_os = \"windows\",\n              target_env = \"gnu\",\n              target_arch = \"x86_64\"))]\n    pub extern fn rust_eh_personality(_record: usize,\n                                      _frame: usize,\n                                      _context: usize,\n                                      _dispatcher: usize) -> u32 {\n        1 // `ExceptionContinueSearch`\n    }\n\n    // Similar to above, this corresponds to the `eh_unwind_resume` lang item\n    // that's only used on Windows currently.\n    //\n    // Note that we don't execute landing pads, so this is never called, so it's\n    // body is empty.\n    #[no_mangle]\n    #[cfg(all(target_os = \"windows\", target_env = \"gnu\"))]\n    pub extern fn rust_eh_unwind_resume() {}\n\n    // These two are called by our startup objects on i686-pc-windows-gnu, but\n    // they don't need to do anything so the bodies are nops.\n    #[no_mangle]\n    #[cfg(all(target_os = \"windows\", target_env = \"gnu\", target_arch = \"x86\"))]\n    pub extern fn rust_eh_register_frames() {}\n    #[no_mangle]\n    #[cfg(all(target_os = \"windows\", target_env = \"gnu\", target_arch = \"x86\"))]\n    pub extern fn rust_eh_unregister_frames() {}\n}\n","// This is a version of dlmalloc.c ported to Rust. You can find the original\n// source at ftp://g.oswego.edu/pub/misc/malloc.c\n//\n// The original source was written by Doug Lea and released to the public domain\n\nuse core::cmp;\nuse core::mem;\nuse core::ptr;\n\nuse sys;\n\npub struct Dlmalloc {\n    smallmap: u32,\n    treemap: u32,\n    smallbins: [*mut Chunk; (NSMALLBINS + 1) * 2],\n    treebins: [*mut TreeChunk; NTREEBINS],\n    dvsize: usize,\n    topsize: usize,\n    dv: *mut Chunk,\n    top: *mut Chunk,\n    footprint: usize,\n    max_footprint: usize,\n    seg: Segment,\n    trim_check: usize,\n    least_addr: *mut u8,\n    release_checks: usize,\n}\n\npub const DLMALLOC_INIT: Dlmalloc = Dlmalloc {\n    smallmap: 0,\n    treemap: 0,\n    smallbins: [0 as *mut _; (NSMALLBINS + 1) * 2],\n    treebins: [0 as *mut _; NTREEBINS],\n    dvsize: 0,\n    topsize: 0,\n    dv: 0 as *mut _,\n    top: 0 as *mut _,\n    footprint: 0,\n    max_footprint: 0,\n    seg: Segment {\n        base: 0 as *mut _,\n        size: 0,\n        next: 0 as *mut _,\n        flags: 0,\n    },\n    trim_check: 0,\n    least_addr: 0 as *mut _,\n    release_checks: 0,\n};\n\n// TODO: document this\nconst NSMALLBINS: usize = 32;\nconst NTREEBINS: usize = 32;\nconst SMALLBIN_SHIFT: usize = 3;\nconst TREEBIN_SHIFT: usize = 8;\n\n// TODO: runtime configurable? documentation?\nconst DEFAULT_GRANULARITY: usize = 64 * 1024;\nconst DEFAULT_TRIM_THRESHOLD: usize = 2 * 1024 * 1024;\nconst MAX_RELEASE_CHECK_RATE: usize = 4095;\n\n#[repr(C)]\nstruct Chunk {\n    prev_foot: usize,\n    head: usize,\n    prev: *mut Chunk,\n    next: *mut Chunk,\n}\n\n#[repr(C)]\nstruct TreeChunk {\n    chunk: Chunk,\n    child: [*mut TreeChunk; 2],\n    parent: *mut TreeChunk,\n    index: u32,\n}\n\n#[repr(C)]\n#[derive(Clone, Copy)]\nstruct Segment {\n    base: *mut u8,\n    size: usize,\n    next: *mut Segment,\n    flags: u32,\n}\n\nfn align_up(a: usize, alignment: usize) -> usize {\n    debug_assert!(alignment.is_power_of_two());\n    (a + (alignment - 1)) & !(alignment - 1)\n}\n\nfn left_bits(x: u32) -> u32 {\n    (x << 1) | (!(x << 1) + 1)\n}\n\nfn least_bit(x: u32) -> u32 {\n    x & (!x + 1)\n}\n\nfn leftshift_for_tree_index(x: u32) -> u32 {\n    let x = x as usize;\n    if x == NTREEBINS - 1 {\n        0\n    } else {\n        (mem::size_of::<usize>() * 8 - 1 - ((x >> 1) + TREEBIN_SHIFT - 2)) as u32\n    }\n}\n\nimpl Dlmalloc {\n    pub fn new() -> Dlmalloc {\n        DLMALLOC_INIT\n    }\n\n    // TODO: can we get rid of this?\n    pub fn malloc_alignment(&self) -> usize {\n        mem::size_of::<usize>() * 2\n    }\n\n    // TODO: dox\n    fn chunk_overhead(&self) -> usize {\n        mem::size_of::<usize>()\n    }\n\n    fn mmap_chunk_overhead(&self) -> usize {\n        2 * mem::size_of::<usize>()\n    }\n\n    // TODO: dox\n    fn min_large_size(&self) -> usize {\n        1 << TREEBIN_SHIFT\n    }\n\n    // TODO: dox\n    fn max_small_size(&self) -> usize {\n        self.min_large_size() - 1\n    }\n\n    // TODO: dox\n    fn max_small_request(&self) -> usize {\n        self.max_small_size() - (self.malloc_alignment() - 1) - self.chunk_overhead()\n    }\n\n    // TODO: dox\n    fn min_chunk_size(&self) -> usize {\n        align_up(mem::size_of::<Chunk>(), self.malloc_alignment())\n    }\n\n    // TODO: dox\n    fn min_request(&self) -> usize {\n        self.min_chunk_size() - self.chunk_overhead() - 1\n    }\n\n    // TODO: dox\n    fn max_request(&self) -> usize {\n        (!self.min_chunk_size() + 1) << 2\n    }\n\n    fn pad_request(&self, amt: usize) -> usize {\n        align_up(amt + self.chunk_overhead(), self.malloc_alignment())\n    }\n\n    fn small_index(&self, size: usize) -> u32 {\n        (size >> SMALLBIN_SHIFT) as u32\n    }\n\n    fn small_index2size(&self, idx: u32) -> usize {\n        (idx as usize) << SMALLBIN_SHIFT\n    }\n\n    fn is_small(&self, s: usize) -> bool {\n        s >> SMALLBIN_SHIFT < NSMALLBINS\n    }\n\n    fn is_aligned(&self, a: usize) -> bool {\n        a & (self.malloc_alignment() - 1) == 0\n    }\n\n    fn align_offset(&self, addr: *mut u8) -> usize {\n        align_up(addr as usize, self.malloc_alignment()) - (addr as usize)\n    }\n\n    fn top_foot_size(&self) -> usize {\n        self.align_offset(unsafe { Chunk::to_mem(ptr::null_mut()) }) +\n            self.pad_request(mem::size_of::<Segment>()) +\n            self.min_chunk_size()\n    }\n\n    fn mmap_foot_pad(&self) -> usize {\n        4 * mem::size_of::<usize>()\n    }\n\n    fn align_as_chunk(&self, ptr: *mut u8) -> *mut Chunk {\n        unsafe {\n            let chunk = Chunk::to_mem(ptr as *mut Chunk);\n            ptr.offset(self.align_offset(chunk) as isize)\n                as *mut Chunk\n        }\n    }\n\n    fn request2size(&self, req: usize) -> usize {\n        if req < self.min_request() {\n            self.min_chunk_size()\n        } else {\n            self.pad_request(req)\n        }\n    }\n\n    unsafe fn overhead_for(&self, p: *mut Chunk) -> usize {\n        if Chunk::mmapped(p) {\n            self.mmap_chunk_overhead()\n        } else {\n            self.chunk_overhead()\n        }\n    }\n\n    pub unsafe fn calloc_must_clear(&self, ptr: *mut u8) -> bool {\n        !sys::allocates_zeros() || !Chunk::mmapped(Chunk::from_mem(ptr))\n    }\n\n    pub unsafe fn malloc(&mut self, size: usize) -> *mut u8 {\n        self.check_malloc_state();\n\n        let nb;\n        if size <= self.max_small_request() {\n            nb = self.request2size(size);\n            let mut idx = self.small_index(nb);\n            let smallbits = self.smallmap >> idx;\n\n            // Check the bin for `idx` (the lowest bit) but also check the next\n            // bin up to use that to satisfy our request, if needed.\n            if smallbits & 0b11 != 0 {\n                // If our the lowest bit, our `idx`, is unset then bump up the\n                // index as we'll be using the next bucket up.\n                idx += !smallbits & 1;\n\n                let b = self.smallbin_at(idx);\n                let p = (*b).prev;\n                self.unlink_first_small_chunk(b, p, idx);\n                let smallsize = self.small_index2size(idx);\n                Chunk::set_inuse_and_pinuse(p, smallsize);\n                let ret = Chunk::to_mem(p);\n                self.check_malloced_chunk(ret, nb);\n                return ret\n            }\n\n            if nb > self.dvsize {\n                // If there's some other bin with some memory, then we just use\n                // the next smallest bin\n                if smallbits != 0 {\n                    let leftbits = (smallbits << idx) & left_bits(1 << idx);\n                    let leastbit = least_bit(leftbits);\n                    let i = leastbit.trailing_zeros();\n                    let b = self.smallbin_at(i);\n                    let p = (*b).prev;\n                    debug_assert_eq!(Chunk::size(p), self.small_index2size(i));\n                    self.unlink_first_small_chunk(b, p, i);\n                    let smallsize = self.small_index2size(i);\n                    let rsize = smallsize - nb;\n                    if mem::size_of::<usize>() != 4 && rsize < self.min_chunk_size() {\n                        Chunk::set_inuse_and_pinuse(p, smallsize);\n                    } else {\n                        Chunk::set_size_and_pinuse_of_inuse_chunk(p, nb);\n                        let r = Chunk::plus_offset(p, nb);\n                        Chunk::set_size_and_pinuse_of_free_chunk(r, rsize);\n                        self.replace_dv(r, rsize);\n                    }\n                    let ret = Chunk::to_mem(p);\n                    self.check_malloced_chunk(ret, nb);\n                    return ret\n\n                } else if self.treemap != 0 {\n                    let mem = self.tmalloc_small(nb);\n                    if !mem.is_null() {\n                        self.check_malloced_chunk(mem, nb);\n                        self.check_malloc_state();\n                        return mem\n                    }\n                }\n            }\n        } else if size >= self.max_request() {\n            // TODO: translate this to unsupported\n            return ptr::null_mut()\n        } else {\n            nb = self.pad_request(size);\n            if self.treemap != 0 {\n                let mem = self.tmalloc_large(nb);\n                if !mem.is_null() {\n                    self.check_malloced_chunk(mem, nb);\n                    self.check_malloc_state();\n                    return mem\n                }\n            }\n        }\n\n        // use the `dv` node if we can, splitting it if necessary or otherwise\n        // exhausting the entire chunk\n        if nb <= self.dvsize {\n            let rsize = self.dvsize - nb;\n            let p = self.dv;\n            if rsize >= self.min_chunk_size() {\n                self.dv = Chunk::plus_offset(p, nb);\n                self.dvsize = rsize;\n                let r = self.dv;\n                Chunk::set_size_and_pinuse_of_free_chunk(r, rsize);\n                Chunk::set_size_and_pinuse_of_inuse_chunk(p, nb);\n            } else {\n                let dvs = self.dvsize;\n                self.dvsize = 0;\n                self.dv = ptr::null_mut();\n                Chunk::set_inuse_and_pinuse(p, dvs);\n            }\n            let ret = Chunk::to_mem(p);\n            self.check_malloced_chunk(ret, nb);\n            self.check_malloc_state();\n            return ret\n        }\n\n        // Split the top node if we can\n        if nb < self.topsize {\n            self.topsize -= nb;\n            let rsize = self.topsize;\n            let p = self.top;\n            self.top = Chunk::plus_offset(p, nb);\n            let r = self.top;\n            (*r).head = rsize | PINUSE;\n            Chunk::set_size_and_pinuse_of_inuse_chunk(p, nb);\n            self.check_top_chunk(self.top);\n            let ret = Chunk::to_mem(p);\n            self.check_malloced_chunk(ret, nb);\n            self.check_malloc_state();\n            return ret\n        }\n\n        self.sys_alloc(nb)\n    }\n\n    unsafe fn sys_alloc(&mut self, size: usize) -> *mut u8 {\n        self.check_malloc_state();\n        let asize = align_up(size + self.top_foot_size() + self.malloc_alignment(),\n                             DEFAULT_GRANULARITY);\n\n        let (tbase, tsize, flags) = sys::alloc(asize);\n        if tbase.is_null() {\n            return tbase\n        }\n\n        self.footprint += tsize;\n        self.max_footprint = cmp::max(self.max_footprint, self.footprint);\n\n        if self.top.is_null() {\n            if self.least_addr.is_null() || tbase < self.least_addr {\n                self.least_addr = tbase;\n            }\n            self.seg.base = tbase;\n            self.seg.size = tsize;\n            self.seg.flags = flags;\n            self.release_checks = MAX_RELEASE_CHECK_RATE;\n            self.init_bins();\n            let tsize = tsize - self.top_foot_size();\n            self.init_top(tbase as *mut Chunk, tsize);\n            // let mn = Chunk::next(Chunk::from_mem(self as *mut _ as *mut u8));\n            // let top_foot_size = self.top_foot_size();\n            // self.init_top(mn, tbase as usize + tsize - mn as usize - top_foot_size);\n        } else {\n            let mut sp = &mut self.seg as *mut Segment;\n            while !sp.is_null() && tbase != Segment::top(sp) {\n                sp = (*sp).next;\n            }\n            if !sp.is_null() &&\n                !Segment::is_extern(sp) &&\n                Segment::sys_flags(sp) == flags &&\n                Segment::holds(sp, self.top as *mut u8)\n            {\n                (*sp).size += tsize;\n                let ptr = self.top;\n                let size = self.topsize + tsize;\n                self.init_top(ptr, size);\n            } else {\n                self.least_addr = cmp::min(tbase, self.least_addr);\n                let mut sp = &mut self.seg as *mut Segment;\n                while !sp.is_null() && (*sp).base != tbase.offset(tsize as isize) {\n                    sp = (*sp).next;\n                }\n                if !sp.is_null() &&\n                    !Segment::is_extern(sp) &&\n                    Segment::sys_flags(sp) == flags\n                {\n                    let oldbase = (*sp).base;\n                    (*sp).base = tbase;\n                    (*sp).size += tsize;\n                    return self.prepend_alloc(tbase, oldbase, size);\n                } else {\n                    self.add_segment(tbase, tsize, flags);\n                }\n            }\n        }\n\n        if size < self.topsize {\n            self.topsize -= size;\n            let rsize = self.topsize;\n            let p = self.top;\n            self.top = Chunk::plus_offset(p, size);\n            let r = self.top;\n            (*r).head = rsize | PINUSE;\n            Chunk::set_size_and_pinuse_of_inuse_chunk(p, size);\n            let ret = Chunk::to_mem(p);\n            self.check_top_chunk(self.top);\n            self.check_malloced_chunk(ret, size);\n            self.check_malloc_state();\n            return ret\n        }\n\n        return ptr::null_mut()\n    }\n\n    pub unsafe fn realloc(&mut self, oldmem: *mut u8, bytes: usize) -> *mut u8 {\n        if bytes >= self.max_request() {\n            return ptr::null_mut()\n        }\n        let nb = self.request2size(bytes);\n        let oldp = Chunk::from_mem(oldmem);\n        let newp = self.try_realloc_chunk(oldp, nb, true);\n        if !newp.is_null() {\n            self.check_inuse_chunk(newp);\n            return Chunk::to_mem(newp)\n        }\n        let ptr = self.malloc(bytes);\n        if !ptr.is_null() {\n            let oc = Chunk::size(oldp) - self.overhead_for(oldp);\n            ptr::copy_nonoverlapping(oldmem, ptr, cmp::min(oc, bytes));\n            self.free(oldmem);\n        }\n        return ptr\n    }\n\n    unsafe fn try_realloc_chunk(&mut self, p: *mut Chunk, nb: usize, can_move: bool)\n        -> *mut Chunk\n    {\n        let oldsize = Chunk::size(p);\n        let next = Chunk::plus_offset(p, oldsize);\n\n        if Chunk::mmapped(p) {\n            self.mmap_resize(p, nb, can_move)\n        } else if oldsize >= nb {\n            let rsize = oldsize - nb;\n            if rsize >= self.min_chunk_size() {\n                let r = Chunk::plus_offset(p, nb);\n                Chunk::set_inuse(p, nb);\n                Chunk::set_inuse(r, rsize);\n                self.dispose_chunk(r, rsize);\n            }\n            p\n        } else if next == self.top { // extend into top\n            if oldsize + self.topsize <= nb {\n                return ptr::null_mut()\n            }\n            let newsize = oldsize + self.topsize;\n            let newtopsize = newsize - nb;\n            let newtop = Chunk::plus_offset(p, nb);\n            Chunk::set_inuse(p, nb);\n            (*newtop).head = newtopsize | PINUSE;\n            self.top = newtop;\n            self.topsize = newtopsize;\n            p\n        } else if next == self.dv { // extend into dv\n            let dvs = self.dvsize;\n            if oldsize + dvs < nb {\n                return ptr::null_mut()\n            }\n            let dsize = oldsize + dvs - nb;\n            if dsize >= self.min_chunk_size() {\n                let r = Chunk::plus_offset(p, nb);\n                let n = Chunk::plus_offset(r, dsize);\n                Chunk::set_inuse(p, nb);\n                Chunk::set_size_and_pinuse_of_free_chunk(r, dsize);\n                Chunk::clear_pinuse(n);\n                self.dvsize = dsize;\n                self.dv = r;\n            } else { // exhaust dv\n                let newsize = oldsize + dvs;\n                Chunk::set_inuse(p, newsize);\n                self.dvsize = 0;\n                self.dv = ptr::null_mut();\n            }\n            return p\n        } else if !Chunk::cinuse(next) { // extend into the next free chunk\n            let nextsize = Chunk::size(next);\n            if oldsize + nextsize < nb {\n                return ptr::null_mut()\n            }\n            let rsize = oldsize + nextsize - nb;\n            self.unlink_chunk(next, nextsize);\n            if rsize < self.min_chunk_size() {\n                let newsize = oldsize + nextsize;\n                Chunk::set_inuse(p, newsize);\n            } else {\n                let r = Chunk::plus_offset(p, nb);\n                Chunk::set_inuse(p, nb);\n                Chunk::set_inuse(r, rsize);\n                self.dispose_chunk(r, rsize);\n            }\n            p\n        } else {\n            ptr::null_mut()\n        }\n    }\n\n    unsafe fn mmap_resize(&mut self, oldp: *mut Chunk, nb: usize, can_move: bool)\n        -> *mut Chunk\n    {\n        let oldsize = Chunk::size(oldp);\n        // Can't shrink mmap regions below a small size\n        if self.is_small(nb) {\n            return ptr::null_mut()\n        }\n\n        // Keep the old chunk if it's big enough but not too big\n        if oldsize >= nb + mem::size_of::<usize>() &&\n            (oldsize - nb) <= (DEFAULT_GRANULARITY << 1)\n        {\n            return oldp\n        }\n\n        let offset = (*oldp).prev_foot;\n        let oldmmsize = oldsize + offset + self.mmap_foot_pad();\n        let newmmsize = self.mmap_align(nb + 6 * mem::size_of::<usize>() +\n                                        self.malloc_alignment() - 1);\n        let ptr = sys::remap((oldp as *mut u8).offset(-(offset as isize)),\n                             oldmmsize,\n                             newmmsize,\n                             can_move);\n        if ptr.is_null() {\n            return ptr::null_mut();\n        }\n        let newp = ptr.offset(offset as isize) as *mut Chunk;\n        let psize = newmmsize - offset - self.mmap_foot_pad();\n        (*newp).head = psize;\n        (*Chunk::plus_offset(newp, psize)).head = Chunk::fencepost_head();\n        (*Chunk::plus_offset(newp, psize + mem::size_of::<usize>())).head = 0;\n        self.least_addr = cmp::min(ptr, self.least_addr);\n        self.footprint = self.footprint + newmmsize - oldmmsize;\n        self.max_footprint = cmp::max(self.max_footprint, self.footprint);\n        self.check_mmapped_chunk(newp);\n        return newp\n    }\n\n    fn mmap_align(&self, a: usize) -> usize {\n        align_up(a, sys::page_size())\n    }\n\n    // Only call this with power-of-two alignment and alignment >\n    // `self.malloc_alignment()`\n    pub unsafe fn memalign(&mut self, mut alignment: usize, bytes: usize)\n        -> *mut u8\n    {\n        if alignment < self.min_chunk_size() {\n            alignment = self.min_chunk_size();\n        }\n        if bytes >= self.max_request() - alignment {\n            return ptr::null_mut()\n        }\n        let nb = self.request2size(bytes);\n        let req = nb + alignment + self.min_chunk_size() - self.chunk_overhead();\n        let mem = self.malloc(req);\n        if mem.is_null() {\n            return mem\n        }\n        let mut p = Chunk::from_mem(mem);\n        if mem as usize & (alignment - 1) != 0 {\n            // Here we find an aligned sopt inside the chunk. Since we need to\n            // give back leading space in a chunk of at least `min_chunk_size`,\n            // if the first calculation places us at a spot with less than\n            // `min_chunk_size` leader we can move to the next aligned spot.\n            // we've allocated enough total room so that this is always possible\n            let br = Chunk::from_mem(((mem as usize + alignment - 1) & (!alignment + 1)) as *mut u8);\n            let pos = if (br as usize - p as usize) > self.min_chunk_size() {\n                br as *mut u8\n            } else {\n                (br as *mut u8).offset(alignment as isize)\n            };\n            let newp = pos as *mut Chunk;\n            let leadsize = pos as usize - p as usize;\n            let newsize = Chunk::size(p) - leadsize;\n\n            // for mmapped chunks just adjust the offset\n            if Chunk::mmapped(p) {\n                (*newp).prev_foot = (*p).prev_foot + leadsize;\n                (*newp).head = newsize;\n            } else {\n                // give back the leader, use the rest\n                Chunk::set_inuse(newp, newsize);\n                Chunk::set_inuse(p, leadsize);\n                self.dispose_chunk(p, leadsize);\n            }\n            p = newp;\n        }\n\n        // give back spare room at the end\n        if !Chunk::mmapped(p) {\n            let size = Chunk::size(p);\n            if size > nb + self.min_chunk_size() {\n                let remainder_size = size - nb;\n                let remainder = Chunk::plus_offset(p, nb);\n                Chunk::set_inuse(p, nb);\n                Chunk::set_inuse(remainder, remainder_size);\n                self.dispose_chunk(remainder, remainder_size);\n            }\n        }\n\n        let mem = Chunk::to_mem(p);\n        debug_assert!(Chunk::size(p) >= nb);\n        debug_assert_eq!(align_up(mem as usize, alignment), mem as usize);\n        self.check_inuse_chunk(p);\n        return mem\n    }\n\n    // consolidate and bin a chunk, differs from exported versions of free\n    // mainly in that the chunk need not be marked as inuse\n    unsafe fn dispose_chunk(&mut self, mut p: *mut Chunk, mut psize: usize) {\n        let next = Chunk::plus_offset(p, psize);\n        if !Chunk::pinuse(p) {\n            let prevsize = (*p).prev_foot;\n            if Chunk::mmapped(p) {\n                psize += prevsize + self.mmap_foot_pad();\n                if sys::free((p as *mut u8).offset(-(prevsize as isize)), psize) {\n                    self.footprint -= psize;\n                }\n                return\n            }\n            let prev = Chunk::minus_offset(p, prevsize);\n            psize += prevsize;\n            p = prev;\n            if p != self.dv {\n                self.unlink_chunk(p, prevsize);\n            } else if (*next).head & INUSE == INUSE {\n                self.dvsize = psize;\n                Chunk::set_free_with_pinuse(p, psize, next);\n                return\n            }\n        }\n\n        if !Chunk::cinuse(next) { // consolidate forward\n            if next == self.top {\n                self.topsize += psize;\n                let tsize = self.topsize;\n                self.top = p;\n                (*p).head = tsize | PINUSE;\n                if p == self.dv {\n                    self.dv = ptr::null_mut();\n                    self.dvsize = 0;\n                }\n                return\n            } else if next == self.dv {\n                self.dvsize += psize;\n                let dsize = self.dvsize;\n                self.dv = p;\n                Chunk::set_size_and_pinuse_of_free_chunk(p, dsize);\n                return\n            } else {\n                let nsize = Chunk::size(next);\n                psize += nsize;\n                self.unlink_chunk(next, nsize);\n                Chunk::set_size_and_pinuse_of_free_chunk(p, psize);\n                if p == self.dv {\n                    self.dvsize = psize;\n                    return\n                }\n            }\n        } else {\n            Chunk::set_free_with_pinuse(p, psize, next);\n        }\n        self.insert_chunk(p, psize);\n    }\n\n    unsafe fn init_top(&mut self, ptr: *mut Chunk, size: usize) {\n        let offset = self.align_offset(Chunk::to_mem(ptr));\n        let p = Chunk::plus_offset(ptr, offset);\n        let size = size - offset;\n\n        self.top = p;\n        self.topsize = size;\n        (*p).head = size | PINUSE;\n        (*Chunk::plus_offset(p, size)).head = self.top_foot_size();\n        self.trim_check = DEFAULT_TRIM_THRESHOLD;\n    }\n\n    unsafe fn init_bins(&mut self) {\n        for i in 0..NSMALLBINS as u32 {\n            let bin = self.smallbin_at(i);\n            (*bin).next = bin;\n            (*bin).prev = bin;\n        }\n    }\n\n    unsafe fn prepend_alloc(&mut self,\n                            newbase: *mut u8,\n                            oldbase: *mut u8,\n                            size: usize) -> *mut u8 {\n        let p = self.align_as_chunk(newbase);\n        let mut oldfirst = self.align_as_chunk(oldbase);\n        let psize = oldfirst as usize - p as usize;\n        let q = Chunk::plus_offset(p, size);\n        let mut qsize = psize - size;\n        Chunk::set_size_and_pinuse_of_inuse_chunk(p, size);\n\n        debug_assert!(oldfirst > q);\n        debug_assert!(Chunk::pinuse(oldfirst));\n        debug_assert!(qsize >= self.min_chunk_size());\n\n\n        // consolidate the remainder with the first chunk of the old base\n        if oldfirst == self.top {\n            self.topsize += qsize;\n            let tsize = self.topsize ;\n            self.top = q;\n            (*q).head = tsize | PINUSE;\n            self.check_top_chunk(q);\n        } else if oldfirst == self.dv {\n            self.dvsize += qsize;\n            let dsize = self.dvsize;\n            self.dv = q;\n            Chunk::set_size_and_pinuse_of_free_chunk(q, dsize);\n        } else {\n            if !Chunk::inuse(oldfirst) {\n                let nsize = Chunk::size(oldfirst);\n                self.unlink_chunk(oldfirst, nsize);\n                oldfirst = Chunk::plus_offset(oldfirst, nsize);\n                qsize += nsize;\n            }\n            Chunk::set_free_with_pinuse(q, qsize, oldfirst);\n            self.insert_chunk(q, qsize);\n            self.check_free_chunk(q);\n        }\n\n        let ret = Chunk::to_mem(p);\n        self.check_malloced_chunk(ret, size);\n        self.check_malloc_state();\n        return ret\n    }\n\n    // add a segment to hold a new noncontiguous region\n    unsafe fn add_segment(&mut self, tbase: *mut u8, tsize: usize, flags: u32) {\n        // TODO: what in the world is this function doing\n\n        // Determine locations and sizes of segment, fenceposts, and the old top\n        let old_top = self.top as *mut u8;\n        let oldsp = self.segment_holding(old_top);\n        let old_end = Segment::top(oldsp);\n        let ssize = self.pad_request(mem::size_of::<Segment>());\n        let offset = ssize + mem::size_of::<usize>() * 4 + self.malloc_alignment() - 1;\n        let rawsp = old_end.offset(-(offset as isize));\n        let offset = self.align_offset(Chunk::to_mem(rawsp as *mut Chunk));\n        let asp = rawsp.offset(offset as isize);\n        let csp = if asp < old_top.offset(self.min_chunk_size() as isize) {\n            old_top\n        } else {\n            asp\n        };\n        let sp = csp as *mut Chunk;\n        let ss = Chunk::to_mem(sp) as *mut Segment;\n        let tnext = Chunk::plus_offset(sp, ssize);\n        let mut p = tnext;\n        let mut nfences = 0;\n\n        // reset the top to our new space\n        let size = tsize - self.top_foot_size();\n        self.init_top(tbase as *mut Chunk, size);\n\n        // set up our segment record\n        debug_assert!(self.is_aligned(ss as usize));\n        Chunk::set_size_and_pinuse_of_inuse_chunk(sp, ssize);\n        *ss = self.seg; // push our current record\n        self.seg.base = tbase;\n        self.seg.size = tsize;\n        self.seg.flags = flags;\n        self.seg.next = ss;\n\n        // insert trailing fences\n        loop {\n            let nextp = Chunk::plus_offset(p, mem::size_of::<usize>());\n            (*p).head = Chunk::fencepost_head();\n            nfences += 1;\n            if (&(*nextp).head as *const usize as *mut u8) < old_end {\n                p = nextp;\n            } else {\n                break\n            }\n        }\n        debug_assert!(nfences >= 2);\n\n        // insert the rest of the old top into a bin as an ordinary free chunk\n        if csp != old_top {\n            let q = old_top as *mut Chunk;\n            let psize = csp as usize - old_top as usize;\n            let tn = Chunk::plus_offset(q, psize);\n            Chunk::set_free_with_pinuse(q, psize, tn);\n            self.insert_chunk(q, psize);\n        }\n\n        self.check_top_chunk(self.top);\n        self.check_malloc_state();\n    }\n\n    unsafe fn segment_holding(&self, ptr: *mut u8) -> *mut Segment {\n        let mut sp = &self.seg as *const Segment as *mut Segment;\n        while !sp.is_null() {\n            if (*sp).base <= ptr && ptr < Segment::top(sp) {\n                return sp\n            }\n            sp = (*sp).next;\n        }\n        ptr::null_mut()\n    }\n\n    unsafe fn tmalloc_small(&mut self, size: usize) -> *mut u8 {\n        let leastbit = least_bit(self.treemap);\n        let i = leastbit.trailing_zeros();\n        let mut v = *self.treebin_at(i);\n        let mut t = v;\n        let mut rsize = Chunk::size(TreeChunk::chunk(t)) - size;\n\n        loop {\n            t = TreeChunk::leftmost_child(t);\n            if t.is_null() {\n                break\n            }\n            let trem = Chunk::size(TreeChunk::chunk(t)) - size;\n            if trem < rsize {\n                rsize = trem;\n                v = t;\n            }\n        }\n\n        let vc = TreeChunk::chunk(v);\n        let r = Chunk::plus_offset(vc, size) as *mut TreeChunk;\n        debug_assert_eq!(Chunk::size(vc), rsize + size);\n        self.unlink_large_chunk(v);\n        if rsize < self.min_chunk_size() {\n            Chunk::set_inuse_and_pinuse(vc, rsize + size);\n        } else {\n            let rc = TreeChunk::chunk(r);\n            Chunk::set_size_and_pinuse_of_inuse_chunk(vc, size);\n            Chunk::set_size_and_pinuse_of_free_chunk(rc, rsize);\n            self.replace_dv(rc, rsize);\n        }\n        Chunk::to_mem(vc)\n    }\n\n    unsafe fn tmalloc_large(&mut self, size: usize) -> *mut u8 {\n        let mut v = ptr::null_mut();\n        let mut rsize = !size + 1;\n        let idx = self.compute_tree_index(size);\n        let mut t = *self.treebin_at(idx);\n        if !t.is_null() {\n            // Traverse thre tree for this bin looking for a node with size\n            // equal to the `size` above.\n            let mut sizebits = size << leftshift_for_tree_index(idx);\n            // Keep track of the deepest untaken right subtree\n            let mut rst = ptr::null_mut();\n            loop {\n                let csize = Chunk::size(TreeChunk::chunk(t));\n                if csize >= size && csize - size < rsize {\n                    v = t;\n                    rsize = csize - size;\n                    if rsize == 0  {\n                        break\n                    }\n                }\n                let rt = (*t).child[1];\n                t = (*t).child[(sizebits >> (mem::size_of::<usize>() * 8 - 1)) & 1];\n                if !rt.is_null() && rt != t {\n                    rst = rt;\n                }\n                if t.is_null() {\n                    // Reset `t` to the least subtree holding sizes greater than\n                    // the `size` above, breaking out\n                    t = rst;\n                    break\n                }\n                sizebits <<= 1;\n            }\n        }\n\n        // Set t to the root of the next non-empty treebin\n        if t.is_null() && v.is_null() {\n            let leftbits = left_bits(1 << idx) & self.treemap;\n            if leftbits != 0 {\n                let leastbit = least_bit(leftbits);\n                let i = leastbit.trailing_zeros();\n                t = *self.treebin_at(i);\n            }\n        }\n\n        // Find the smallest of this tree or subtree\n        while !t.is_null() {\n            let csize = Chunk::size(TreeChunk::chunk(t));\n            if csize >= size && csize - size < rsize {\n                rsize = csize - size;\n                v = t;\n            }\n            t = TreeChunk::leftmost_child(t);\n        }\n\n        // If dv is a better fit, then return null so malloc will use it\n        if v.is_null() || (self.dvsize >= size && !(rsize < self.dvsize - size)) {\n            return ptr::null_mut()\n        }\n\n        let vc = TreeChunk::chunk(v);\n        let r = Chunk::plus_offset(vc, size);\n        debug_assert_eq!(Chunk::size(vc), rsize + size);\n        self.unlink_large_chunk(v);\n        if rsize < self.min_chunk_size() {\n            Chunk::set_inuse_and_pinuse(vc, rsize + size);\n        } else {\n            Chunk::set_size_and_pinuse_of_inuse_chunk(vc, size);\n            Chunk::set_size_and_pinuse_of_free_chunk(r, rsize);\n            self.insert_chunk(r, rsize);\n        }\n        Chunk::to_mem(vc)\n    }\n\n    unsafe fn smallbin_at(&mut self, idx: u32) -> *mut Chunk {\n        debug_assert!(((idx * 2) as usize) < self.smallbins.len());\n        &mut *self.smallbins.get_unchecked_mut((idx as usize) * 2)\n            as *mut *mut Chunk as *mut Chunk\n    }\n\n    unsafe fn treebin_at(&mut self, idx: u32) -> *mut *mut TreeChunk {\n        debug_assert!((idx as usize) < self.treebins.len());\n        &mut *self.treebins.get_unchecked_mut(idx as usize)\n    }\n\n    fn compute_tree_index(&self, size: usize) -> u32 {\n        let x = size >> TREEBIN_SHIFT;\n        if x == 0 {\n            0\n        } else if x > 0xffff {\n            NTREEBINS as u32 - 1\n        } else {\n            let k = mem::size_of_val(&x) * 8 - 1 - (x.leading_zeros() as usize);\n            ((k << 1) + (size >> (k + TREEBIN_SHIFT - 1) & 1)) as u32\n        }\n    }\n\n    unsafe fn unlink_first_small_chunk(&mut self,\n                                       head: *mut Chunk,\n                                       next: *mut Chunk,\n                                       idx: u32) {\n        let ptr = (*next).prev;\n        debug_assert!(next != head);\n        debug_assert!(next != ptr);\n        debug_assert_eq!(Chunk::size(next), self.small_index2size(idx));\n        if head == ptr {\n            self.clear_smallmap(idx);\n        } else {\n            (*ptr).next = head;\n            (*head).prev = ptr;\n        }\n    }\n\n    unsafe fn replace_dv(&mut self, chunk: *mut Chunk, size: usize) {\n        let dvs = self.dvsize;\n        debug_assert!(self.is_small(dvs));\n        if dvs != 0 {\n            let dv = self.dv;\n            self.insert_small_chunk(dv, dvs);\n        }\n        self.dvsize = size;\n        self.dv = chunk;\n    }\n\n    unsafe fn insert_chunk(&mut self, chunk: *mut Chunk, size: usize) {\n        if self.is_small(size) {\n            self.insert_small_chunk(chunk, size);\n        } else {\n            self.insert_large_chunk(chunk as *mut TreeChunk, size);\n        }\n    }\n\n    unsafe fn insert_small_chunk(&mut self, chunk: *mut Chunk, size: usize) {\n        let idx = self.small_index(size);\n        let head = self.smallbin_at(idx);\n        let mut f = head;\n        debug_assert!(size >= self.min_chunk_size());\n        if !self.smallmap_is_marked(idx) {\n            self.mark_smallmap(idx);\n        } else {\n            f = (*head).prev;\n        }\n\n        (*head).prev = chunk;\n        (*f).next = chunk;\n        (*chunk).prev = f;\n        (*chunk).next = head;\n    }\n\n    unsafe fn insert_large_chunk(&mut self, chunk: *mut TreeChunk, size: usize) {\n        let idx = self.compute_tree_index(size);\n        let h = self.treebin_at(idx);\n        (*chunk).index = idx;\n        (*chunk).child[0] = ptr::null_mut();\n        (*chunk).child[1] = ptr::null_mut();\n        let chunkc = TreeChunk::chunk(chunk);\n        if !self.treemap_is_marked(idx) {\n            self.mark_treemap(idx);\n            *h = chunk;\n            (*chunk).parent = h as *mut TreeChunk; // TODO: dubious?\n            (*chunkc).next = chunkc;\n            (*chunkc).prev = chunkc;\n        } else {\n            let mut t = *h;\n            let mut k = size << leftshift_for_tree_index(idx);\n            loop {\n                if Chunk::size(TreeChunk::chunk(t)) != size {\n                    let c = &mut (*t).child[(k >> mem::size_of::<usize>() * 8 - 1) & 1];\n                    k <<= 1;\n                    if !c.is_null() {\n                        t = *c;\n                    } else {\n                        *c = chunk;\n                        (*chunk).parent = t;\n                        (*chunkc).next = chunkc;\n                        (*chunkc).prev = chunkc;\n                        break\n                    }\n                } else {\n                    let tc = TreeChunk::chunk(t);\n                    let f = (*tc).prev;\n                    (*f).next = chunkc;\n                    (*tc).prev = chunkc;\n                    (*chunkc).prev = f;\n                    (*chunkc).next = tc;\n                    (*chunk).parent = ptr::null_mut();\n                    break\n                }\n            }\n        }\n    }\n\n    unsafe fn smallmap_is_marked(&self, idx: u32) -> bool {\n        self.smallmap & (1 << idx) != 0\n    }\n\n    unsafe fn mark_smallmap(&mut self, idx: u32) {\n        self.smallmap |= 1 << idx;\n    }\n\n    unsafe fn clear_smallmap(&mut self, idx: u32) {\n        self.smallmap &= !(1 << idx);\n    }\n\n    unsafe fn treemap_is_marked(&self, idx: u32) -> bool {\n        self.treemap & (1 << idx) != 0\n    }\n\n    unsafe fn mark_treemap(&mut self, idx: u32) {\n        self.treemap |= 1 << idx;\n    }\n\n    unsafe fn clear_treemap(&mut self, idx: u32) {\n        self.treemap &= !(1 << idx);\n    }\n\n    unsafe fn unlink_chunk(&mut self, chunk: *mut Chunk, size: usize) {\n        if self.is_small(size) {\n            self.unlink_small_chunk(chunk, size)\n        } else {\n            self.unlink_large_chunk(chunk as *mut TreeChunk);\n        }\n    }\n\n    unsafe fn unlink_small_chunk(&mut self, chunk: *mut Chunk, size: usize) {\n        let f = (*chunk).prev;\n        let b = (*chunk).next;\n        let idx = self.small_index(size);\n        debug_assert!(chunk != b);\n        debug_assert!(chunk != f);\n        debug_assert_eq!(Chunk::size(chunk), self.small_index2size(idx));\n        if b == f {\n            self.clear_smallmap(idx);\n        } else {\n            (*f).next = b;\n            (*b).prev = f;\n        }\n    }\n\n    unsafe fn unlink_large_chunk(&mut self, chunk: *mut TreeChunk) {\n        let xp = (*chunk).parent;\n        let mut r;\n        if TreeChunk::next(chunk) != chunk {\n            let f = TreeChunk::prev(chunk);\n            r = TreeChunk::next(chunk);\n            (*f).chunk.next = TreeChunk::chunk(r);\n            (*r).chunk.prev = TreeChunk::chunk(f);\n        } else {\n            let mut rp = &mut (*chunk).child[1];\n            if rp.is_null() {\n                rp = &mut (*chunk).child[0];\n            }\n            r = *rp;\n            if !rp.is_null() {\n                loop {\n                    let mut cp = &mut (**rp).child[1];\n                    if cp.is_null() {\n                        cp = &mut (**rp).child[0];\n                    }\n                    if cp.is_null() {\n                        break\n                    }\n                    rp = cp;\n                }\n                r = *rp;\n                *rp = ptr::null_mut();\n            }\n        }\n\n        if xp.is_null() {\n            return\n        }\n\n        let h = self.treebin_at((*chunk).index);\n        if chunk == *h {\n            *h = r;\n            if r.is_null() {\n                self.clear_treemap((*chunk).index);\n            }\n        } else {\n            if (*xp).child[0] == chunk {\n                (*xp).child[0] = r;\n            } else {\n                (*xp).child[1] = r;\n            }\n        }\n\n        if !r.is_null() {\n            (*r).parent = xp;\n            let c0 = (*chunk).child[0];\n            if !c0.is_null() {\n                (*r).child[0] = c0;\n                (*c0).parent = r;\n            }\n            let c1 = (*chunk).child[1];\n            if !c1.is_null() {\n                (*r).child[1] = c1;\n                (*c1).parent = r;\n            }\n        }\n    }\n\n    pub unsafe fn free(&mut self, mem: *mut u8) {\n        self.check_malloc_state();\n\n        let mut p = Chunk::from_mem(mem);\n        let mut psize = Chunk::size(p);\n        let next = Chunk::plus_offset(p, psize);\n        if !Chunk::pinuse(p) {\n            let prevsize = (*p).prev_foot;\n\n            if Chunk::mmapped(p) {\n                psize += prevsize + self.mmap_foot_pad();\n                if sys::free((p as *mut u8).offset(-(prevsize as isize)), psize) {\n                    self.footprint -= psize;\n                }\n                return\n            }\n\n            let prev = Chunk::minus_offset(p, prevsize);\n            psize += prevsize;\n            p = prev;\n            if p != self.dv {\n                self.unlink_chunk(p, prevsize);\n            } else if (*next).head & INUSE == INUSE {\n                self.dvsize = psize;\n                Chunk::set_free_with_pinuse(p, psize, next);\n                return\n            }\n        }\n\n        // Consolidate forward if we can\n        if !Chunk::cinuse(next) {\n            if next == self.top {\n                self.topsize += psize;\n                let tsize = self.topsize;\n                self.top = p;\n                (*p).head = tsize | PINUSE;\n                if p == self.dv {\n                    self.dv = ptr::null_mut();\n                    self.dvsize = 0;\n                }\n                if self.should_trim(tsize) {\n                    self.sys_trim(0);\n                }\n                return\n            } else if next == self.dv {\n                self.dvsize += psize;\n                let dsize = self.dvsize;\n                self.dv = p;\n                Chunk::set_size_and_pinuse_of_free_chunk(p, dsize);\n                return\n            } else {\n                let nsize = Chunk::size(next);\n                psize += nsize;\n                self.unlink_chunk(next, nsize);\n                Chunk::set_size_and_pinuse_of_free_chunk(p, psize);\n                if p == self.dv {\n                    self.dvsize = psize;\n                    return\n                }\n            }\n        } else {\n            Chunk::set_free_with_pinuse(p, psize, next);\n        }\n\n        if self.is_small(psize) {\n            self.insert_small_chunk(p, psize);\n            self.check_free_chunk(p);\n        } else {\n            self.insert_large_chunk(p as *mut TreeChunk, psize);\n            self.check_free_chunk(p);\n            self.release_checks -= 1;\n            if self.release_checks == 0 {\n                self.release_unused_segments();\n            }\n        }\n    }\n\n    fn should_trim(&self, size: usize) -> bool {\n        size > self.trim_check\n    }\n\n    unsafe fn sys_trim(&mut self, mut pad: usize) -> bool {\n        let mut released = 0;\n        if pad < self.max_request() && !self.top.is_null() {\n            pad += self.top_foot_size();\n            if self.topsize > pad {\n                let unit = DEFAULT_GRANULARITY;\n                let extra = ((self.topsize - pad + unit - 1) / unit - 1) * unit;\n                let sp = self.segment_holding(self.top as *mut u8);\n                debug_assert!(!sp.is_null());\n\n                if !Segment::is_extern(sp) {\n                    if Segment::can_release_part(sp) {\n                        if (*sp).size >= extra && !self.has_segment_link(sp) {\n                            let newsize = (*sp).size - extra;\n                            if sys::free_part((*sp).base, (*sp).size, newsize) {\n                                released = extra;\n                            }\n                        }\n                    }\n                }\n\n                if released != 0 {\n                    (*sp).size -= released;\n                    self.footprint -= released;\n                    let top = self.top;\n                    let topsize = self.topsize - released;\n                    self.init_top(top, topsize);\n                    self.check_top_chunk(self.top);\n                }\n            }\n\n            released += self.release_unused_segments();\n\n            if released == 0 && self.topsize > self.trim_check {\n                self.trim_check = usize::max_value();\n            }\n        }\n\n        released != 0\n    }\n\n    unsafe fn has_segment_link(&self, ptr: *mut Segment) -> bool {\n        let mut sp = &self.seg as *const Segment as *mut Segment;\n        while !sp.is_null() {\n            if Segment::holds(ptr, sp as *mut u8) {\n                return true\n            }\n            sp = (*sp).next;\n        }\n        false\n    }\n\n    /// Unmap and unlink any mapped segments that don't contain used chunks\n    unsafe fn release_unused_segments(&mut self) -> usize {\n        let mut released = 0;\n        let mut nsegs = 0;\n        let mut pred = &mut self.seg as *mut Segment;\n        let mut sp = (*pred).next;\n        while !sp.is_null() {\n            let base = (*sp).base;\n            let size = (*sp).size;\n            let next = (*sp).next;\n            nsegs += 1;\n\n            if Segment::can_release_part(sp) && !Segment::is_extern(sp) {\n                let p = self.align_as_chunk(base);\n                let psize = Chunk::size(p);\n                // We can unmap if the first chunk holds the entire segment and\n                // isn't pinned.\n                let chunk_top = (p as *mut u8).offset(psize as isize);\n                let top = base.offset((size - self.top_foot_size()) as isize);\n                if !Chunk::inuse(p) && chunk_top >= top {\n                    let tp = p as *mut TreeChunk;\n                    debug_assert!(Segment::holds(sp, sp as *mut u8));\n                    if p == self.dv {\n                        self.dv = ptr::null_mut();\n                        self.dvsize = 0;\n                    } else {\n                        self.unlink_large_chunk(tp);\n                    }\n                    if sys::free(base, size) {\n                        released += size;\n                        self.footprint -= size;\n                        // unlink our obsolete record\n                        sp = pred;\n                        (*sp).next = next;\n                    } else {\n                        // back out if we can't unmap\n                        self.insert_large_chunk(tp, psize);\n                    }\n                }\n            }\n            pred = sp;\n            sp = next;\n        }\n        self.release_checks = if nsegs > MAX_RELEASE_CHECK_RATE {\n            nsegs\n        } else {\n            MAX_RELEASE_CHECK_RATE\n        };\n        return released\n    }\n\n    // Sanity checks\n\n    unsafe fn check_any_chunk(&self, p: *mut Chunk) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        debug_assert!(self.is_aligned(Chunk::to_mem(p) as usize) ||\n                (*p).head == Chunk::fencepost_head());\n        debug_assert!(p as *mut u8 >= self.least_addr);\n    }\n\n    unsafe fn check_top_chunk(&self, p: *mut Chunk) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let sp = self.segment_holding(p as *mut u8);\n        let sz = (*p).head & !INUSE;\n        debug_assert!(!sp.is_null());\n        debug_assert!(self.is_aligned(Chunk::to_mem(p) as usize) ||\n                (*p).head == Chunk::fencepost_head());\n        debug_assert!(p as *mut u8 >= self.least_addr);\n        debug_assert_eq!(sz, self.topsize);\n        debug_assert!(sz > 0);\n        debug_assert_eq!(sz, (*sp).base as usize + (*sp).size - p as usize - self.top_foot_size());\n        debug_assert!(Chunk::pinuse(p));\n        debug_assert!(!Chunk::pinuse(Chunk::plus_offset(p, sz)));\n    }\n\n    unsafe fn check_malloced_chunk(&self, mem: *mut u8, s: usize) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        if mem.is_null() {\n            return\n        }\n        let p = Chunk::from_mem(mem);\n        let sz = (*p).head & !INUSE;\n        self.check_inuse_chunk(p);\n        debug_assert_eq!(align_up(sz, self.malloc_alignment()), sz);\n        debug_assert!(sz >= self.min_chunk_size());\n        debug_assert!(sz >= s);\n        debug_assert!(Chunk::mmapped(p) || sz < (s + self.min_chunk_size()));\n    }\n\n    unsafe fn check_inuse_chunk(&self, p: *mut Chunk) {\n        self.check_any_chunk(p);\n        debug_assert!(Chunk::inuse(p));\n        debug_assert!(Chunk::pinuse(Chunk::next(p)));\n        debug_assert!(Chunk::mmapped(p) || Chunk::pinuse(p) ||\n                Chunk::next(Chunk::prev(p)) == p);\n        if Chunk::mmapped(p) {\n            self.check_mmapped_chunk(p);\n        }\n    }\n\n    unsafe fn check_mmapped_chunk(&self, p: *mut Chunk) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let sz = Chunk::size(p);\n        let len = sz + (*p).prev_foot + self.mmap_foot_pad();\n        debug_assert!(Chunk::mmapped(p));\n        debug_assert!(self.is_aligned(Chunk::to_mem(p) as usize) ||\n                (*p).head == Chunk::fencepost_head());\n        debug_assert!(p as *mut u8 >= self.least_addr);\n        debug_assert!(!self.is_small(sz));\n        debug_assert_eq!(align_up(len, sys::page_size()), len);\n        debug_assert_eq!((*Chunk::plus_offset(p, sz)).head, Chunk::fencepost_head());\n        debug_assert_eq!((*Chunk::plus_offset(p, sz + mem::size_of::<usize>())).head, 0);\n    }\n\n    unsafe fn check_free_chunk(&self, p: *mut Chunk) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let sz = Chunk::size(p);\n        let next = Chunk::plus_offset(p, sz);\n        self.check_any_chunk(p);\n        debug_assert!(!Chunk::inuse(p));\n        debug_assert!(!Chunk::pinuse(Chunk::next(p)));\n        debug_assert!(!Chunk::mmapped(p));\n        if p != self.dv && p != self.top {\n            if sz >= self.min_chunk_size() {\n                debug_assert_eq!(align_up(sz, self.malloc_alignment()), sz);\n                debug_assert!(self.is_aligned(Chunk::to_mem(p) as usize));\n                debug_assert_eq!((*next).prev_foot, sz);\n                debug_assert!(Chunk::pinuse(p));\n                debug_assert!(next == self.top || Chunk::inuse(next));\n                debug_assert_eq!((*(*p).next).prev, p);\n                debug_assert_eq!((*(*p).prev).next, p);\n            } else {\n                debug_assert_eq!(sz, mem::size_of::<usize>());\n            }\n        }\n    }\n\n    unsafe fn check_malloc_state(&mut self) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        for i in 0..NSMALLBINS {\n            self.check_smallbin(i as u32);\n        }\n        for i in 0..NTREEBINS {\n            self.check_treebin(i as u32);\n        }\n        if self.dvsize != 0 {\n            self.check_any_chunk(self.dv);\n            debug_assert_eq!(self.dvsize, Chunk::size(self.dv));\n            debug_assert!(self.dvsize >= self.min_chunk_size());\n            let dv = self.dv;\n            debug_assert!(!self.bin_find(dv));\n        }\n        if !self.top.is_null() {\n            self.check_top_chunk(self.top);\n            debug_assert!(self.topsize > 0);\n            let top = self.top;\n            debug_assert!(!self.bin_find(top));\n        }\n        let total = self.traverse_and_check();\n        debug_assert!(total <= self.footprint);\n        debug_assert!(self.footprint <= self.max_footprint);\n    }\n\n    unsafe fn check_smallbin(&mut self, idx: u32) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let b = self.smallbin_at(idx);\n        let mut p = (*b).next;\n        let empty = self.smallmap & (1 << idx) == 0;\n        if p == b {\n            debug_assert!(empty)\n        }\n        if !empty {\n            while p != b {\n                let size = Chunk::size(p);\n                self.check_free_chunk(p);\n                debug_assert_eq!(self.small_index(size), idx);\n                debug_assert!((*p).next == b ||\n                        Chunk::size((*p).next) == Chunk::size(p));\n                let q = Chunk::next(p);\n                if (*q).head != Chunk::fencepost_head() {\n                    self.check_inuse_chunk(q);\n                }\n                p = (*p).next;\n            }\n        }\n    }\n\n    unsafe fn check_treebin(&mut self, idx: u32) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let tb = self.treebin_at(idx);\n        let t = *tb;\n        let empty = self.treemap & (1 << idx) == 0;\n        if t.is_null() {\n            debug_assert!(empty);\n        }\n        if !empty {\n            self.check_tree(t);\n        }\n    }\n\n    unsafe fn check_tree(&mut self, t: *mut TreeChunk) {\n        if !cfg!(debug_assertions) {\n            return\n        }\n        let tc = TreeChunk::chunk(t);\n        let tindex = (*t).index;\n        let tsize = Chunk::size(tc);\n        let idx = self.compute_tree_index(tsize);\n        debug_assert_eq!(tindex, idx);\n        debug_assert!(tsize >= self.min_large_size());\n        debug_assert!(tsize >= self.min_size_for_tree_index(idx));\n        debug_assert!(idx == NTREEBINS as u32 - 1 ||\n                tsize < self.min_size_for_tree_index(idx + 1));\n\n        let mut u = t;\n        let mut head = ptr::null_mut::<TreeChunk>();\n        loop {\n            let uc = TreeChunk::chunk(u);\n            self.check_any_chunk(uc);\n            debug_assert_eq!((*u).index, tindex);\n            debug_assert_eq!(Chunk::size(uc), tsize);\n            debug_assert!(!Chunk::inuse(uc));\n            debug_assert!(!Chunk::pinuse(Chunk::next(uc)));\n            debug_assert_eq!((*(*uc).next).prev, uc);\n            debug_assert_eq!((*(*uc).prev).next, uc);\n            let left = (*u).child[0];\n            let right = (*u).child[1];\n            if (*u).parent.is_null() {\n                debug_assert!(left.is_null());\n                debug_assert!(right.is_null());\n            } else {\n                debug_assert!(head.is_null());\n                head = u;\n                debug_assert!((*u).parent != u);\n                debug_assert!((*(*u).parent).child[0] == u ||\n                        (*(*u).parent).child[1] == u ||\n                        *((*u).parent as *mut *mut TreeChunk) == u);\n                if !left.is_null() {\n                    debug_assert_eq!((*left).parent, u);\n                    debug_assert!(left != u);\n                    self.check_tree(left);\n                }\n                if !right.is_null() {\n                    debug_assert_eq!((*right).parent, u);\n                    debug_assert!(right != u);\n                    self.check_tree(right);\n                }\n                if !left.is_null() && !right.is_null() {\n                    debug_assert!(Chunk::size(TreeChunk::chunk(left)) <\n                            Chunk::size(TreeChunk::chunk(right)));\n                }\n            }\n\n            u = TreeChunk::prev(u);\n            if u == t {\n                break\n            }\n        }\n        debug_assert!(!head.is_null());\n    }\n\n    fn min_size_for_tree_index(&self, idx: u32) -> usize {\n        let idx = idx as usize;\n        (1 << ((idx >> 1) + TREEBIN_SHIFT)) |\n            ((idx & 1) << ((idx >> 1) + TREEBIN_SHIFT - 1))\n    }\n\n    unsafe fn bin_find(&mut self, chunk: *mut Chunk) -> bool {\n        let size = Chunk::size(chunk);\n        if self.is_small(size) {\n            let sidx = self.small_index(size);\n            let b = self.smallbin_at(sidx);\n            if !self.smallmap_is_marked(sidx) {\n                return false\n            }\n            let mut p = b;\n            loop {\n                if p == chunk {\n                    return true\n                }\n                p = (*p).prev;\n                if p == b {\n                    return false\n                }\n            }\n        } else {\n            let tidx = self.compute_tree_index(size);\n            if !self.treemap_is_marked(tidx) {\n                return false\n            }\n            let mut t = *self.treebin_at(tidx);\n            let mut sizebits = size << leftshift_for_tree_index(tidx);\n            while !t.is_null() && Chunk::size(TreeChunk::chunk(t)) != size {\n                t = (*t).child[(sizebits >> (mem::size_of::<usize>() * 8 - 1)) & 1];\n                sizebits <<= 1;\n            }\n            if t.is_null() {\n                return false\n            }\n            let mut u = t;\n            let chunk = chunk as *mut TreeChunk;\n            loop {\n                if u == chunk {\n                    return true\n                }\n                u = TreeChunk::prev(u);\n                if u == t {\n                    return false\n                }\n            }\n        }\n\n    }\n\n    unsafe fn traverse_and_check(&self) -> usize {\n        0\n    }\n}\n\nconst PINUSE: usize = 1 << 0;\nconst CINUSE: usize = 1 << 1;\nconst FLAG4: usize = 1 << 2;\nconst INUSE: usize = PINUSE | CINUSE;\nconst FLAG_BITS: usize = PINUSE | CINUSE | FLAG4;\n\nimpl Chunk {\n    unsafe fn fencepost_head() -> usize {\n        INUSE | mem::size_of::<usize>()\n    }\n\n    unsafe fn size(me: *mut Chunk) -> usize {\n        (*me).head & !FLAG_BITS\n    }\n\n    unsafe fn next(me: *mut Chunk) -> *mut Chunk {\n        (me as *mut u8).offset(((*me).head & !FLAG_BITS) as isize) as *mut Chunk\n    }\n\n    unsafe fn prev(me: *mut Chunk) -> *mut Chunk {\n        (me as *mut u8).offset(-((*me).prev_foot as isize)) as *mut Chunk\n    }\n\n    unsafe fn cinuse(me: *mut Chunk) -> bool {\n        (*me).head & CINUSE != 0\n    }\n\n    unsafe fn pinuse(me: *mut Chunk) -> bool {\n        (*me).head & PINUSE != 0\n    }\n\n    unsafe fn clear_pinuse(me: *mut Chunk) {\n        (*me).head &= !PINUSE;\n    }\n\n    unsafe fn inuse(me: *mut Chunk) -> bool {\n        (*me).head & INUSE != PINUSE\n    }\n\n    unsafe fn mmapped(me: *mut Chunk) -> bool {\n        (*me).head & INUSE == 0\n    }\n\n    unsafe fn set_inuse(me: *mut Chunk, size: usize) {\n        (*me).head = ((*me).head & PINUSE) | size | CINUSE;\n        let next = Chunk::plus_offset(me, size);\n        (*next).head |= PINUSE;\n    }\n\n    unsafe fn set_inuse_and_pinuse(me: *mut Chunk, size: usize) {\n        (*me).head = PINUSE | size | CINUSE;\n        let next = Chunk::plus_offset(me, size);\n        (*next).head |= PINUSE;\n    }\n\n    unsafe fn set_size_and_pinuse_of_inuse_chunk(me: *mut Chunk, size: usize) {\n        (*me).head = size | PINUSE | CINUSE;\n    }\n\n    unsafe fn set_size_and_pinuse_of_free_chunk(me: *mut Chunk, size: usize) {\n        (*me).head = size | PINUSE;\n        Chunk::set_foot(me, size);\n    }\n\n    unsafe fn set_free_with_pinuse(p: *mut Chunk, size: usize, n: *mut Chunk) {\n        Chunk::clear_pinuse(n);\n        Chunk::set_size_and_pinuse_of_free_chunk(p, size);\n    }\n\n    unsafe fn set_foot(me: *mut Chunk, size: usize) {\n        let next = Chunk::plus_offset(me, size);\n        (*next).prev_foot = size;\n    }\n\n    unsafe fn plus_offset(me: *mut Chunk, offset: usize) -> *mut Chunk {\n        (me as *mut u8).offset(offset as isize) as *mut Chunk\n    }\n\n    unsafe fn minus_offset(me: *mut Chunk, offset: usize) -> *mut Chunk {\n        (me as *mut u8).offset(-(offset as isize)) as *mut Chunk\n    }\n\n    unsafe fn to_mem(me: *mut Chunk) -> *mut u8 {\n        (me as *mut u8).offset(2 * (mem::size_of::<usize>() as isize))\n    }\n\n    unsafe fn from_mem(mem: *mut u8) -> *mut Chunk {\n        mem.offset(-2 * (mem::size_of::<usize>() as isize)) as *mut Chunk\n    }\n}\n\nimpl TreeChunk {\n    unsafe fn leftmost_child(me: *mut TreeChunk) -> *mut TreeChunk {\n        let left = (*me).child[0];\n        if left.is_null() {\n            (*me).child[1]\n        } else {\n            left\n        }\n    }\n\n    unsafe fn chunk(me: *mut TreeChunk) -> *mut Chunk {\n        &mut (*me).chunk\n    }\n\n    unsafe fn next(me: *mut TreeChunk) -> *mut TreeChunk {\n        (*TreeChunk::chunk(me)).next as *mut TreeChunk\n    }\n\n    unsafe fn prev(me: *mut TreeChunk) -> *mut TreeChunk {\n        (*TreeChunk::chunk(me)).prev as *mut TreeChunk\n    }\n}\n\nconst EXTERN: u32 = 1 << 0;\n\nimpl Segment {\n    unsafe fn is_extern(seg: *mut Segment) -> bool {\n        (*seg).flags & EXTERN != 0\n    }\n\n    unsafe fn can_release_part(seg: *mut Segment) -> bool {\n        sys::can_release_part((*seg).flags >> 1)\n    }\n\n    unsafe fn sys_flags(seg: *mut Segment) -> u32 {\n        (*seg).flags >> 1\n    }\n\n    unsafe fn holds(seg: *mut Segment, addr: *mut u8) -> bool {\n        (*seg).base <= addr && addr < Segment::top(seg)\n    }\n\n    unsafe fn top(seg: *mut Segment) -> *mut u8 {\n        (*seg).base.offset((*seg).size as isize)\n    }\n}\n","use core::ptr;\n\nextern {\n    #[link_name = \"llvm.wasm.grow.memory.i32\"]\n    fn grow_memory(pages: u32) -> i32;\n}\n\npub unsafe fn alloc(size: usize) -> (*mut u8, usize, u32) {\n    let pages = size / page_size();\n    let prev = grow_memory(pages as u32);\n    if prev == -1 {\n        return (ptr::null_mut(), 0, 0);\n    }\n    let prev = prev as usize;\n    ((prev * page_size()) as *mut u8, pages * page_size(), 0)\n}\n\npub unsafe fn remap(_ptr: *mut u8, _oldsize: usize, _newsize: usize, _can_move: bool)\n    -> *mut u8\n{\n    // TODO: I think this can be implemented near the end?\n    ptr::null_mut()\n}\n\npub unsafe fn free_part(_ptr: *mut u8, _oldsize: usize, _newsize: usize) -> bool {\n    false\n}\n\npub unsafe fn free(_ptr: *mut u8, _size: usize) -> bool {\n    false\n}\n\npub fn can_release_part(_flags: u32) -> bool {\n    false\n}\n\npub fn acquire_global_lock() {\n    // single threaded, no need!\n}\n\npub fn release_global_lock() {\n    // single threaded, no need!\n}\n\npub fn allocates_zeros() -> bool {\n    true\n}\n\npub fn page_size() -> usize {\n    64 * 1024\n}\n","// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse convert::TryFrom;\nuse mem;\nuse ops::{self, Add, Sub};\nuse usize;\n\nuse super::{FusedIterator, TrustedLen};\n\n/// Objects that can be stepped over in both directions.\n///\n/// The `steps_between` function provides a way to efficiently compare\n/// two `Step` objects.\n#[unstable(feature = \"step_trait\",\n           reason = \"likely to be replaced by finer-grained traits\",\n           issue = \"42168\")]\npub trait Step: Clone + PartialOrd + Sized {\n    /// Returns the number of steps between two step objects. The count is\n    /// inclusive of `start` and exclusive of `end`.\n    ///\n    /// Returns `None` if it is not possible to calculate `steps_between`\n    /// without overflow.\n    fn steps_between(start: &Self, end: &Self) -> Option<usize>;\n\n    /// Replaces this step with `1`, returning itself\n    fn replace_one(&mut self) -> Self;\n\n    /// Replaces this step with `0`, returning itself\n    fn replace_zero(&mut self) -> Self;\n\n    /// Adds one to this step, returning the result\n    fn add_one(&self) -> Self;\n\n    /// Subtracts one to this step, returning the result\n    fn sub_one(&self) -> Self;\n\n    /// Add an usize, returning None on overflow\n    fn add_usize(&self, n: usize) -> Option<Self>;\n}\n\n// These are still macro-generated because the integer literals resolve to different types.\nmacro_rules! step_identical_methods {\n    () => {\n        #[inline]\n        fn replace_one(&mut self) -> Self {\n            mem::replace(self, 1)\n        }\n\n        #[inline]\n        fn replace_zero(&mut self) -> Self {\n            mem::replace(self, 0)\n        }\n\n        #[inline]\n        fn add_one(&self) -> Self {\n            Add::add(*self, 1)\n        }\n\n        #[inline]\n        fn sub_one(&self) -> Self {\n            Sub::sub(*self, 1)\n        }\n    }\n}\n\nmacro_rules! step_impl_unsigned {\n    ($($t:ty)*) => ($(\n        #[unstable(feature = \"step_trait\",\n                   reason = \"likely to be replaced by finer-grained traits\",\n                   issue = \"42168\")]\n        impl Step for $t {\n            #[inline]\n            #[allow(trivial_numeric_casts)]\n            fn steps_between(start: &$t, end: &$t) -> Option<usize> {\n                if *start < *end {\n                    // Note: We assume $t <= usize here\n                    Some((*end - *start) as usize)\n                } else {\n                    Some(0)\n                }\n            }\n\n            #[inline]\n            #[allow(unreachable_patterns)]\n            fn add_usize(&self, n: usize) -> Option<Self> {\n                match <$t>::try_from(n) {\n                    Ok(n_as_t) => self.checked_add(n_as_t),\n                    Err(_) => None,\n                }\n            }\n\n            step_identical_methods!();\n        }\n    )*)\n}\nmacro_rules! step_impl_signed {\n    ($( [$t:ty : $unsigned:ty] )*) => ($(\n        #[unstable(feature = \"step_trait\",\n                   reason = \"likely to be replaced by finer-grained traits\",\n                   issue = \"42168\")]\n        impl Step for $t {\n            #[inline]\n            #[allow(trivial_numeric_casts)]\n            fn steps_between(start: &$t, end: &$t) -> Option<usize> {\n                if *start < *end {\n                    // Note: We assume $t <= isize here\n                    // Use .wrapping_sub and cast to usize to compute the\n                    // difference that may not fit inside the range of isize.\n                    Some((*end as isize).wrapping_sub(*start as isize) as usize)\n                } else {\n                    Some(0)\n                }\n            }\n\n            #[inline]\n            #[allow(unreachable_patterns)]\n            fn add_usize(&self, n: usize) -> Option<Self> {\n                match <$unsigned>::try_from(n) {\n                    Ok(n_as_unsigned) => {\n                        // Wrapping in unsigned space handles cases like\n                        // `-120_i8.add_usize(200) == Some(80_i8)`,\n                        // even though 200_usize is out of range for i8.\n                        let wrapped = (*self as $unsigned).wrapping_add(n_as_unsigned) as $t;\n                        if wrapped >= *self {\n                            Some(wrapped)\n                        } else {\n                            None  // Addition overflowed\n                        }\n                    }\n                    Err(_) => None,\n                }\n            }\n\n            step_identical_methods!();\n        }\n    )*)\n}\n\nmacro_rules! step_impl_no_between {\n    ($($t:ty)*) => ($(\n        #[unstable(feature = \"step_trait\",\n                   reason = \"likely to be replaced by finer-grained traits\",\n                   issue = \"42168\")]\n        impl Step for $t {\n            #[inline]\n            fn steps_between(_start: &Self, _end: &Self) -> Option<usize> {\n                None\n            }\n\n            #[inline]\n            fn add_usize(&self, n: usize) -> Option<Self> {\n                self.checked_add(n as $t)\n            }\n\n            step_identical_methods!();\n        }\n    )*)\n}\n\nstep_impl_unsigned!(usize u8 u16);\n#[cfg(not(target_pointer_witdth = \"16\"))]\nstep_impl_unsigned!(u32);\n#[cfg(target_pointer_witdth = \"16\")]\nstep_impl_no_between!(u32);\nstep_impl_signed!([isize: usize] [i8: u8] [i16: u16]);\n#[cfg(not(target_pointer_witdth = \"16\"))]\nstep_impl_signed!([i32: u32]);\n#[cfg(target_pointer_witdth = \"16\")]\nstep_impl_no_between!(i32);\n#[cfg(target_pointer_width = \"64\")]\nstep_impl_unsigned!(u64);\n#[cfg(target_pointer_width = \"64\")]\nstep_impl_signed!([i64: u64]);\n// If the target pointer width is not 64-bits, we\n// assume here that it is less than 64-bits.\n#[cfg(not(target_pointer_width = \"64\"))]\nstep_impl_no_between!(u64 i64);\nstep_impl_no_between!(u128 i128);\n\nmacro_rules! range_exact_iter_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl ExactSizeIterator for ops::Range<$t> { }\n    )*)\n}\n\nmacro_rules! range_incl_exact_iter_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n        impl ExactSizeIterator for ops::RangeInclusive<$t> { }\n    )*)\n}\n\nmacro_rules! range_trusted_len_impl {\n    ($($t:ty)*) => ($(\n        #[unstable(feature = \"trusted_len\", issue = \"37572\")]\n        unsafe impl TrustedLen for ops::Range<$t> { }\n    )*)\n}\n\nmacro_rules! range_incl_trusted_len_impl {\n    ($($t:ty)*) => ($(\n        #[unstable(feature = \"trusted_len\", issue = \"37572\")]\n        unsafe impl TrustedLen for ops::RangeInclusive<$t> { }\n    )*)\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A: Step> Iterator for ops::Range<A> {\n    type Item = A;\n\n    #[inline]\n    fn next(&mut self) -> Option<A> {\n        if self.start < self.end {\n            // We check for overflow here, even though it can't actually\n            // happen. Adding this check does however help llvm vectorize loops\n            // for some ranges that don't get vectorized otherwise,\n            // and this won't actually result in an extra check in an optimized build.\n            if let Some(mut n) = self.start.add_usize(1) {\n                mem::swap(&mut n, &mut self.start);\n                Some(n)\n            } else {\n                None\n            }\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        match Step::steps_between(&self.start, &self.end) {\n            Some(hint) => (hint, Some(hint)),\n            None => (0, None)\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<A> {\n        if let Some(plus_n) = self.start.add_usize(n) {\n            if plus_n < self.end {\n                self.start = plus_n.add_one();\n                return Some(plus_n)\n            }\n        }\n\n        self.start = self.end.clone();\n        None\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<A> {\n        self.next_back()\n    }\n\n    #[inline]\n    fn min(mut self) -> Option<A> {\n        self.next()\n    }\n\n    #[inline]\n    fn max(mut self) -> Option<A> {\n        self.next_back()\n    }\n}\n\n// These macros generate `ExactSizeIterator` impls for various range types.\n// Range<{u,i}64> and RangeInclusive<{u,i}{32,64,size}> are excluded\n// because they cannot guarantee having a length <= usize::MAX, which is\n// required by ExactSizeIterator.\nrange_exact_iter_impl!(usize u8 u16 u32 isize i8 i16 i32);\nrange_incl_exact_iter_impl!(u8 u16 i8 i16);\n\n// These macros generate `TrustedLen` impls.\n//\n// They need to guarantee that .size_hint() is either exact, or that\n// the upper bound is None when it does not fit the type limits.\nrange_trusted_len_impl!(usize isize u8 i8 u16 i16 u32 i32 i64 u64);\nrange_incl_trusted_len_impl!(usize isize u8 i8 u16 i16 u32 i32 i64 u64);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A: Step> DoubleEndedIterator for ops::Range<A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<A> {\n        if self.start < self.end {\n            self.end = self.end.sub_one();\n            Some(self.end.clone())\n        } else {\n            None\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A: Step> FusedIterator for ops::Range<A> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A: Step> Iterator for ops::RangeFrom<A> {\n    type Item = A;\n\n    #[inline]\n    fn next(&mut self) -> Option<A> {\n        let mut n = self.start.add_one();\n        mem::swap(&mut n, &mut self.start);\n        Some(n)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (usize::MAX, None)\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<A> {\n        let plus_n = self.start.add_usize(n).expect(\"overflow in RangeFrom::nth\");\n        self.start = plus_n.add_one();\n        Some(plus_n)\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A: Step> FusedIterator for ops::RangeFrom<A> {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A: Step> TrustedLen for ops::RangeFrom<A> {}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<A: Step> Iterator for ops::RangeInclusive<A> {\n    type Item = A;\n\n    #[inline]\n    fn next(&mut self) -> Option<A> {\n        self.compute_is_empty();\n        if self.is_empty.unwrap_or_default() {\n            return None;\n        }\n        let is_iterating = self.start < self.end;\n        self.is_empty = Some(!is_iterating);\n        Some(if is_iterating {\n            let n = self.start.add_one();\n            mem::replace(&mut self.start, n)\n        } else {\n            self.start.clone()\n        })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.is_empty() {\n            return (0, Some(0));\n        }\n\n        match Step::steps_between(&self.start, &self.end) {\n            Some(hint) => (hint.saturating_add(1), hint.checked_add(1)),\n            None => (0, None),\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<A> {\n        self.compute_is_empty();\n        if self.is_empty.unwrap_or_default() {\n            return None;\n        }\n\n        if let Some(plus_n) = self.start.add_usize(n) {\n            use cmp::Ordering::*;\n\n            match plus_n.partial_cmp(&self.end) {\n                Some(Less) => {\n                    self.is_empty = Some(false);\n                    self.start = plus_n.add_one();\n                    return Some(plus_n)\n                }\n                Some(Equal) => {\n                    self.is_empty = Some(true);\n                    return Some(plus_n)\n                }\n                _ => {}\n            }\n        }\n\n        self.is_empty = Some(true);\n        None\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<A> {\n        self.next_back()\n    }\n\n    #[inline]\n    fn min(mut self) -> Option<A> {\n        self.next()\n    }\n\n    #[inline]\n    fn max(mut self) -> Option<A> {\n        self.next_back()\n    }\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<A: Step> DoubleEndedIterator for ops::RangeInclusive<A> {\n    #[inline]\n    fn next_back(&mut self) -> Option<A> {\n        self.compute_is_empty();\n        if self.is_empty.unwrap_or_default() {\n            return None;\n        }\n        let is_iterating = self.start < self.end;\n        self.is_empty = Some(!is_iterating);\n        Some(if is_iterating {\n            let n = self.end.sub_one();\n            mem::replace(&mut self.end, n)\n        } else {\n            self.end.clone()\n        })\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A: Step> FusedIterator for ops::RangeInclusive<A> {}\n","// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Utilities for formatting and printing `String`s.\n//!\n//! This module contains the runtime support for the [`format!`] syntax extension.\n//! This macro is implemented in the compiler to emit calls to this module in\n//! order to format arguments at runtime into strings.\n//!\n//! # Usage\n//!\n//! The [`format!`] macro is intended to be familiar to those coming from C's\n//! `printf`/`fprintf` functions or Python's `str.format` function.\n//!\n//! Some examples of the [`format!`] extension are:\n//!\n//! ```\n//! format!(\"Hello\");                 // => \"Hello\"\n//! format!(\"Hello, {}!\", \"world\");   // => \"Hello, world!\"\n//! format!(\"The number is {}\", 1);   // => \"The number is 1\"\n//! format!(\"{:?}\", (3, 4));          // => \"(3, 4)\"\n//! format!(\"{value}\", value=4);      // => \"4\"\n//! format!(\"{} {}\", 1, 2);           // => \"1 2\"\n//! format!(\"{:04}\", 42);             // => \"0042\" with leading zeros\n//! ```\n//!\n//! From these, you can see that the first argument is a format string. It is\n//! required by the compiler for this to be a string literal; it cannot be a\n//! variable passed in (in order to perform validity checking). The compiler\n//! will then parse the format string and determine if the list of arguments\n//! provided is suitable to pass to this format string.\n//!\n//! ## Positional parameters\n//!\n//! Each formatting argument is allowed to specify which value argument it's\n//! referencing, and if omitted it is assumed to be \"the next argument\". For\n//! example, the format string `{} {} {}` would take three parameters, and they\n//! would be formatted in the same order as they're given. The format string\n//! `{2} {1} {0}`, however, would format arguments in reverse order.\n//!\n//! Things can get a little tricky once you start intermingling the two types of\n//! positional specifiers. The \"next argument\" specifier can be thought of as an\n//! iterator over the argument. Each time a \"next argument\" specifier is seen,\n//! the iterator advances. This leads to behavior like this:\n//!\n//! ```\n//! format!(\"{1} {} {0} {}\", 1, 2); // => \"2 1 1 2\"\n//! ```\n//!\n//! The internal iterator over the argument has not been advanced by the time\n//! the first `{}` is seen, so it prints the first argument. Then upon reaching\n//! the second `{}`, the iterator has advanced forward to the second argument.\n//! Essentially, parameters which explicitly name their argument do not affect\n//! parameters which do not name an argument in terms of positional specifiers.\n//!\n//! A format string is required to use all of its arguments, otherwise it is a\n//! compile-time error. You may refer to the same argument more than once in the\n//! format string.\n//!\n//! ## Named parameters\n//!\n//! Rust itself does not have a Python-like equivalent of named parameters to a\n//! function, but the [`format!`] macro is a syntax extension which allows it to\n//! leverage named parameters. Named parameters are listed at the end of the\n//! argument list and have the syntax:\n//!\n//! ```text\n//! identifier '=' expression\n//! ```\n//!\n//! For example, the following [`format!`] expressions all use named argument:\n//!\n//! ```\n//! format!(\"{argument}\", argument = \"test\");   // => \"test\"\n//! format!(\"{name} {}\", 1, name = 2);          // => \"2 1\"\n//! format!(\"{a} {c} {b}\", a=\"a\", b='b', c=3);  // => \"a 3 b\"\n//! ```\n//!\n//! It is not valid to put positional parameters (those without names) after\n//! arguments which have names. Like with positional parameters, it is not\n//! valid to provide named parameters that are unused by the format string.\n//!\n//! ## Argument types\n//!\n//! Each argument's type is dictated by the format string.\n//! There are various parameters which require a particular type, however.\n//! An example is the `{:.*}` syntax, which sets the number of decimal places\n//! in floating-point types:\n//!\n//! ```\n//! let formatted_number = format!(\"{:.*}\", 2, 1.234567);\n//!\n//! assert_eq!(\"1.23\", formatted_number)\n//! ```\n//!\n//! If this syntax is used, then the number of characters to print precedes the\n//! actual object being formatted, and the number of characters must have the\n//! type [`usize`].\n//!\n//! ## Formatting traits\n//!\n//! When requesting that an argument be formatted with a particular type, you\n//! are actually requesting that an argument ascribes to a particular trait.\n//! This allows multiple actual types to be formatted via `{:x}` (like [`i8`] as\n//! well as [`isize`]).  The current mapping of types to traits is:\n//!\n//! * *nothing* \u21d2 [`Display`]\n//! * `?` \u21d2 [`Debug`]\n//! * `x?` \u21d2 [`Debug`] with lower-case hexadecimal integers\n//! * `X?` \u21d2 [`Debug`] with upper-case hexadecimal integers\n//! * `o` \u21d2 [`Octal`](trait.Octal.html)\n//! * `x` \u21d2 [`LowerHex`](trait.LowerHex.html)\n//! * `X` \u21d2 [`UpperHex`](trait.UpperHex.html)\n//! * `p` \u21d2 [`Pointer`](trait.Pointer.html)\n//! * `b` \u21d2 [`Binary`]\n//! * `e` \u21d2 [`LowerExp`](trait.LowerExp.html)\n//! * `E` \u21d2 [`UpperExp`](trait.UpperExp.html)\n//!\n//! What this means is that any type of argument which implements the\n//! [`fmt::Binary`][`Binary`] trait can then be formatted with `{:b}`. Implementations\n//! are provided for these traits for a number of primitive types by the\n//! standard library as well. If no format is specified (as in `{}` or `{:6}`),\n//! then the format trait used is the [`Display`] trait.\n//!\n//! When implementing a format trait for your own type, you will have to\n//! implement a method of the signature:\n//!\n//! ```\n//! # #![allow(dead_code)]\n//! # use std::fmt;\n//! # struct Foo; // our custom type\n//! # impl fmt::Display for Foo {\n//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n//! # write!(f, \"testing, testing\")\n//! # } }\n//! ```\n//!\n//! Your type will be passed as `self` by-reference, and then the function\n//! should emit output into the `f.buf` stream. It is up to each format trait\n//! implementation to correctly adhere to the requested formatting parameters.\n//! The values of these parameters will be listed in the fields of the\n//! [`Formatter`] struct. In order to help with this, the [`Formatter`] struct also\n//! provides some helper methods.\n//!\n//! Additionally, the return value of this function is [`fmt::Result`] which is a\n//! type alias of [`Result`]`<(), `[`std::fmt::Error`]`>`. Formatting implementations\n//! should ensure that they propagate errors from the [`Formatter`][`Formatter`] (e.g., when\n//! calling [`write!`]). However, they should never return errors spuriously. That\n//! is, a formatting implementation must and may only return an error if the\n//! passed-in [`Formatter`] returns an error. This is because, contrary to what\n//! the function signature might suggest, string formatting is an infallible\n//! operation. This function only returns a result because writing to the\n//! underlying stream might fail and it must provide a way to propagate the fact\n//! that an error has occurred back up the stack.\n//!\n//! An example of implementing the formatting traits would look\n//! like:\n//!\n//! ```\n//! use std::fmt;\n//!\n//! #[derive(Debug)]\n//! struct Vector2D {\n//!     x: isize,\n//!     y: isize,\n//! }\n//!\n//! impl fmt::Display for Vector2D {\n//!     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n//!         // The `f` value implements the `Write` trait, which is what the\n//!         // write! macro is expecting. Note that this formatting ignores the\n//!         // various flags provided to format strings.\n//!         write!(f, \"({}, {})\", self.x, self.y)\n//!     }\n//! }\n//!\n//! // Different traits allow different forms of output of a type. The meaning\n//! // of this format is to print the magnitude of a vector.\n//! impl fmt::Binary for Vector2D {\n//!     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n//!         let magnitude = (self.x * self.x + self.y * self.y) as f64;\n//!         let magnitude = magnitude.sqrt();\n//!\n//!         // Respect the formatting flags by using the helper method\n//!         // `pad_integral` on the Formatter object. See the method\n//!         // documentation for details, and the function `pad` can be used\n//!         // to pad strings.\n//!         let decimals = f.precision().unwrap_or(3);\n//!         let string = format!(\"{:.*}\", decimals, magnitude);\n//!         f.pad_integral(true, \"\", &string)\n//!     }\n//! }\n//!\n//! fn main() {\n//!     let myvector = Vector2D { x: 3, y: 4 };\n//!\n//!     println!(\"{}\", myvector);       // => \"(3, 4)\"\n//!     println!(\"{:?}\", myvector);     // => \"Vector2D {x: 3, y:4}\"\n//!     println!(\"{:10.3b}\", myvector); // => \"     5.000\"\n//! }\n//! ```\n//!\n//! ### `fmt::Display` vs `fmt::Debug`\n//!\n//! These two formatting traits have distinct purposes:\n//!\n//! - [`fmt::Display`][`Display`] implementations assert that the type can be faithfully\n//!   represented as a UTF-8 string at all times. It is **not** expected that\n//!   all types implement the [`Display`] trait.\n//! - [`fmt::Debug`][`Debug`] implementations should be implemented for **all** public types.\n//!   Output will typically represent the internal state as faithfully as possible.\n//!   The purpose of the [`Debug`] trait is to facilitate debugging Rust code. In\n//!   most cases, using `#[derive(Debug)]` is sufficient and recommended.\n//!\n//! Some examples of the output from both traits:\n//!\n//! ```\n//! assert_eq!(format!(\"{} {:?}\", 3, 4), \"3 4\");\n//! assert_eq!(format!(\"{} {:?}\", 'a', 'b'), \"a 'b'\");\n//! assert_eq!(format!(\"{} {:?}\", \"foo\\n\", \"bar\\n\"), \"foo\\n \\\"bar\\\\n\\\"\");\n//! ```\n//!\n//! ## Related macros\n//!\n//! There are a number of related macros in the [`format!`] family. The ones that\n//! are currently implemented are:\n//!\n//! ```ignore (only-for-syntax-highlight)\n//! format!      // described above\n//! write!       // first argument is a &mut io::Write, the destination\n//! writeln!     // same as write but appends a newline\n//! print!       // the format string is printed to the standard output\n//! println!     // same as print but appends a newline\n//! eprint!      // the format string is printed to the standard error\n//! eprintln!    // same as eprint but appends a newline\n//! format_args! // described below.\n//! ```\n//!\n//! ### `write!`\n//!\n//! This and [`writeln!`] are two macros which are used to emit the format string\n//! to a specified stream. This is used to prevent intermediate allocations of\n//! format strings and instead directly write the output. Under the hood, this\n//! function is actually invoking the [`write_fmt`] function defined on the\n//! [`std::io::Write`] trait. Example usage is:\n//!\n//! ```\n//! # #![allow(unused_must_use)]\n//! use std::io::Write;\n//! let mut w = Vec::new();\n//! write!(&mut w, \"Hello {}!\", \"world\");\n//! ```\n//!\n//! ### `print!`\n//!\n//! This and [`println!`] emit their output to stdout. Similarly to the [`write!`]\n//! macro, the goal of these macros is to avoid intermediate allocations when\n//! printing output. Example usage is:\n//!\n//! ```\n//! print!(\"Hello {}!\", \"world\");\n//! println!(\"I have a newline {}\", \"character at the end\");\n//! ```\n//! ### `eprint!`\n//!\n//! The [`eprint!`] and [`eprintln!`] macros are identical to\n//! [`print!`] and [`println!`], respectively, except they emit their\n//! output to stderr.\n//!\n//! ### `format_args!`\n//!\n//! This is a curious macro which is used to safely pass around\n//! an opaque object describing the format string. This object\n//! does not require any heap allocations to create, and it only\n//! references information on the stack. Under the hood, all of\n//! the related macros are implemented in terms of this. First\n//! off, some example usage is:\n//!\n//! ```\n//! # #![allow(unused_must_use)]\n//! use std::fmt;\n//! use std::io::{self, Write};\n//!\n//! let mut some_writer = io::stdout();\n//! write!(&mut some_writer, \"{}\", format_args!(\"print with a {}\", \"macro\"));\n//!\n//! fn my_fmt_fn(args: fmt::Arguments) {\n//!     write!(&mut io::stdout(), \"{}\", args);\n//! }\n//! my_fmt_fn(format_args!(\", or a {} too\", \"function\"));\n//! ```\n//!\n//! The result of the [`format_args!`] macro is a value of type [`fmt::Arguments`].\n//! This structure can then be passed to the [`write`] and [`format`] functions\n//! inside this module in order to process the format string.\n//! The goal of this macro is to even further prevent intermediate allocations\n//! when dealing formatting strings.\n//!\n//! For example, a logging library could use the standard formatting syntax, but\n//! it would internally pass around this structure until it has been determined\n//! where output should go to.\n//!\n//! # Syntax\n//!\n//! The syntax for the formatting language used is drawn from other languages,\n//! so it should not be too alien. Arguments are formatted with Python-like\n//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like\n//! `%`. The actual grammar for the formatting syntax is:\n//!\n//! ```text\n//! format_string := <text> [ maybe-format <text> ] *\n//! maybe-format := '{' '{' | '}' '}' | <format>\n//! format := '{' [ argument ] [ ':' format_spec ] '}'\n//! argument := integer | identifier\n//!\n//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type]\n//! fill := character\n//! align := '<' | '^' | '>'\n//! sign := '+' | '-'\n//! width := count\n//! precision := count | '*'\n//! type := identifier | '?' | ''\n//! count := parameter | integer\n//! parameter := argument '$'\n//! ```\n//!\n//! # Formatting Parameters\n//!\n//! Each argument being formatted can be transformed by a number of formatting\n//! parameters (corresponding to `format_spec` in the syntax above). These\n//! parameters affect the string representation of what's being formatted.\n//!\n//! ## Fill/Alignment\n//!\n//! The fill character is provided normally in conjunction with the\n//! [`width`](#width)\n//! parameter. This indicates that if the value being formatted is smaller than\n//! `width` some extra characters will be printed around it. The extra\n//! characters are specified by `fill`, and the alignment can be one of the\n//! following options:\n//!\n//! * `<` - the argument is left-aligned in `width` columns\n//! * `^` - the argument is center-aligned in `width` columns\n//! * `>` - the argument is right-aligned in `width` columns\n//!\n//! Note that alignment may not be implemented by some types. A good way\n//! to ensure padding is applied is to format your input, then use this\n//! resulting string to pad your output.\n//!\n//! ## Sign/`#`/`0`\n//!\n//! These can all be interpreted as flags for a particular formatter.\n//!\n//! * `+` - This is intended for numeric types and indicates that the sign\n//!         should always be printed. Positive signs are never printed by\n//!         default, and the negative sign is only printed by default for the\n//!         `Signed` trait. This flag indicates that the correct sign (`+` or `-`)\n//!         should always be printed.\n//! * `-` - Currently not used\n//! * `#` - This flag is indicates that the \"alternate\" form of printing should\n//!         be used. The alternate forms are:\n//!     * `#?` - pretty-print the [`Debug`] formatting\n//!     * `#x` - precedes the argument with a `0x`\n//!     * `#X` - precedes the argument with a `0x`\n//!     * `#b` - precedes the argument with a `0b`\n//!     * `#o` - precedes the argument with a `0o`\n//! * `0` - This is used to indicate for integer formats that the padding should\n//!         both be done with a `0` character as well as be sign-aware. A format\n//!         like `{:08}` would yield `00000001` for the integer `1`, while the\n//!         same format would yield `-0000001` for the integer `-1`. Notice that\n//!         the negative version has one fewer zero than the positive version.\n//!         Note that padding zeroes are always placed after the sign (if any)\n//!         and before the digits. When used together with the `#` flag, a similar\n//!         rule applies: padding zeroes are inserted after the prefix but before\n//!         the digits.\n//!\n//! ## Width\n//!\n//! This is a parameter for the \"minimum width\" that the format should take up.\n//! If the value's string does not fill up this many characters, then the\n//! padding specified by fill/alignment will be used to take up the required\n//! space.\n//!\n//! The default [fill/alignment](#fillalignment) for non-numerics is a space and\n//! left-aligned. The\n//! defaults for numeric formatters is also a space but with right-alignment. If\n//! the `0` flag is specified for numerics, then the implicit fill character is\n//! `0`.\n//!\n//! The value for the width can also be provided as a [`usize`] in the list of\n//! parameters by using the dollar syntax indicating that the second argument is\n//! a [`usize`] specifying the width, for example:\n//!\n//! ```\n//! // All of these print \"Hello x    !\"\n//! println!(\"Hello {:5}!\", \"x\");\n//! println!(\"Hello {:1$}!\", \"x\", 5);\n//! println!(\"Hello {1:0$}!\", 5, \"x\");\n//! println!(\"Hello {:width$}!\", \"x\", width = 5);\n//! ```\n//!\n//! Referring to an argument with the dollar syntax does not affect the \"next\n//! argument\" counter, so it's usually a good idea to refer to arguments by\n//! position, or use named arguments.\n//!\n//! ## Precision\n//!\n//! For non-numeric types, this can be considered a \"maximum width\". If the resulting string is\n//! longer than this width, then it is truncated down to this many characters and that truncated\n//! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set.\n//!\n//! For integral types, this is ignored.\n//!\n//! For floating-point types, this indicates how many digits after the decimal point should be\n//! printed.\n//!\n//! There are three possible ways to specify the desired `precision`:\n//!\n//! 1. An integer `.N`:\n//!\n//!    the integer `N` itself is the precision.\n//!\n//! 2. An integer or name followed by dollar sign `.N$`:\n//!\n//!    use format *argument* `N` (which must be a `usize`) as the precision.\n//!\n//! 3. An asterisk `.*`:\n//!\n//!    `.*` means that this `{...}` is associated with *two* format inputs rather than one: the\n//!    first input holds the `usize` precision, and the second holds the value to print.  Note that\n//!    in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers\n//!    to the *value* to print, and the `precision` must come in the input preceding `<arg>`.\n//!\n//! For example, the following calls all print the same thing `Hello x is 0.01000`:\n//!\n//! ```\n//! // Hello {arg 0 (\"x\")} is {arg 1 (0.01) with precision specified inline (5)}\n//! println!(\"Hello {0} is {1:.5}\", \"x\", 0.01);\n//!\n//! // Hello {arg 1 (\"x\")} is {arg 2 (0.01) with precision specified in arg 0 (5)}\n//! println!(\"Hello {1} is {2:.0$}\", 5, \"x\", 0.01);\n//!\n//! // Hello {arg 0 (\"x\")} is {arg 2 (0.01) with precision specified in arg 1 (5)}\n//! println!(\"Hello {0} is {2:.1$}\", \"x\", 5, 0.01);\n//!\n//! // Hello {next arg (\"x\")} is {second of next two args (0.01) with precision\n//! //                          specified in first of next two args (5)}\n//! println!(\"Hello {} is {:.*}\",    \"x\", 5, 0.01);\n//!\n//! // Hello {next arg (\"x\")} is {arg 2 (0.01) with precision\n//! //                          specified in its predecessor (5)}\n//! println!(\"Hello {} is {2:.*}\",   \"x\", 5, 0.01);\n//!\n//! // Hello {next arg (\"x\")} is {arg \"number\" (0.01) with precision specified\n//! //                          in arg \"prec\" (5)}\n//! println!(\"Hello {} is {number:.prec$}\", \"x\", prec = 5, number = 0.01);\n//! ```\n//!\n//! While these:\n//!\n//! ```\n//! println!(\"{}, `{name:.*}` has 3 fractional digits\", \"Hello\", 3, name=1234.56);\n//! println!(\"{}, `{name:.*}` has 3 characters\", \"Hello\", 3, name=\"1234.56\");\n//! println!(\"{}, `{name:>8.*}` has 3 right-aligned characters\", \"Hello\", 3, name=\"1234.56\");\n//! ```\n//!\n//! print two significantly different things:\n//!\n//! ```text\n//! Hello, `1234.560` has 3 fractional digits\n//! Hello, `123` has 3 characters\n//! Hello, `     123` has 3 right-aligned characters\n//! ```\n//!\n//! # Escaping\n//!\n//! The literal characters `{` and `}` may be included in a string by preceding\n//! them with the same character. For example, the `{` character is escaped with\n//! `{{` and the `}` character is escaped with `}}`.\n//!\n//! [`usize`]: ../../std/primitive.usize.html\n//! [`isize`]: ../../std/primitive.isize.html\n//! [`i8`]: ../../std/primitive.i8.html\n//! [`Display`]: trait.Display.html\n//! [`Binary`]: trait.Binary.html\n//! [`fmt::Result`]: type.Result.html\n//! [`Result`]: ../../std/result/enum.Result.html\n//! [`std::fmt::Error`]: struct.Error.html\n//! [`Formatter`]: struct.Formatter.html\n//! [`write!`]: ../../std/macro.write.html\n//! [`Debug`]: trait.Debug.html\n//! [`format!`]: ../../std/macro.format.html\n//! [`writeln!`]: ../../std/macro.writeln.html\n//! [`write_fmt`]: ../../std/io/trait.Write.html#method.write_fmt\n//! [`std::io::Write`]: ../../std/io/trait.Write.html\n//! [`print!`]: ../../std/macro.print.html\n//! [`println!`]: ../../std/macro.println.html\n//! [`eprint!`]: ../../std/macro.eprint.html\n//! [`eprintln!`]: ../../std/macro.eprintln.html\n//! [`write!`]: ../../std/macro.write.html\n//! [`format_args!`]: ../../std/macro.format_args.html\n//! [`fmt::Arguments`]: struct.Arguments.html\n//! [`write`]: fn.write.html\n//! [`format`]: fn.format.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n#[unstable(feature = \"fmt_internals\", issue = \"0\")]\npub use core::fmt::rt;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{Formatter, Result, Write};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{Binary, Octal};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{Debug, Display};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{LowerHex, Pointer, UpperHex};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{LowerExp, UpperExp};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::Error;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{write, ArgumentV1, Arguments};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};\n#[stable(feature = \"fmt_flags_align\", since = \"1.28.0\")]\npub use core::fmt::{Alignment};\n\nuse string;\n\n/// The `format` function takes an [`Arguments`] struct and returns the resulting\n/// formatted string.\n///\n/// The [`Arguments`] instance can be created with the [`format_args!`] macro.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::fmt;\n///\n/// let s = fmt::format(format_args!(\"Hello, {}!\", \"world\"));\n/// assert_eq!(s, \"Hello, world!\");\n/// ```\n///\n/// Please note that using [`format!`] might be preferable.\n/// Example:\n///\n/// ```\n/// let s = format!(\"Hello, {}!\", \"world\");\n/// assert_eq!(s, \"Hello, world!\");\n/// ```\n///\n/// [`Arguments`]: struct.Arguments.html\n/// [`format_args!`]: ../../std/macro.format_args.html\n/// [`format!`]: ../../std/macro.format.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn format(args: Arguments) -> string::String {\n    let capacity = args.estimated_capacity();\n    let mut output = string::String::with_capacity(capacity);\n    output\n        .write_fmt(args)\n        .expect(\"a formatting trait implementation returned an error\");\n    output\n}\n","// Copyright 2012 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// The addition operator `+`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory. For\n/// example, [`std::time::SystemTime`] implements `Add<Duration>`, which permits\n/// operations of the form `SystemTime = SystemTime + Duration`.\n///\n/// [`std::time::SystemTime`]: ../../std/time/struct.SystemTime.html\n///\n/// # Examples\n///\n/// ## `Add`able points\n///\n/// ```\n/// use std::ops::Add;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl Add for Point {\n///     type Output = Point;\n///\n///     fn add(self, other: Point) -> Point {\n///         Point {\n///             x: self.x + other.x,\n///             y: self.y + other.y,\n///         }\n///     }\n/// }\n///\n/// assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },\n///            Point { x: 3, y: 3 });\n/// ```\n///\n/// ## Implementing `Add` with generics\n///\n/// Here is an example of the same `Point` struct implementing the `Add` trait\n/// using generics.\n///\n/// ```\n/// use std::ops::Add;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point<T> {\n///     x: T,\n///     y: T,\n/// }\n///\n/// // Notice that the implementation uses the associated type `Output`.\n/// impl<T: Add<Output=T>> Add for Point<T> {\n///     type Output = Point<T>;\n///\n///     fn add(self, other: Point<T>) -> Point<T> {\n///         Point {\n///             x: self.x + other.x,\n///             y: self.y + other.y,\n///         }\n///     }\n/// }\n///\n/// assert_eq!(Point { x: 1, y: 0 } + Point { x: 2, y: 3 },\n///            Point { x: 3, y: 3 });\n/// ```\n#[lang = \"add\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    on(\n        all(_Self=\"{integer}\", RHS=\"{float}\"),\n        message=\"cannot add a float to an integer\",\n    ),\n    on(\n        all(_Self=\"{float}\", RHS=\"{integer}\"),\n        message=\"cannot add an integer to a float\",\n    ),\n    message=\"cannot add `{RHS}` to `{Self}`\",\n    label=\"no implementation for `{Self} + {RHS}`\",\n)]\n#[doc(alias = \"+\")]\npub trait Add<RHS=Self> {\n    /// The resulting type after applying the `+` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `+` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn add(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! add_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Add for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn add(self, other: $t) -> $t { self + other }\n        }\n\n        forward_ref_binop! { impl Add, add for $t, $t }\n    )*)\n}\n\nadd_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The subtraction operator `-`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory. For\n/// example, [`std::time::SystemTime`] implements `Sub<Duration>`, which permits\n/// operations of the form `SystemTime = SystemTime - Duration`.\n///\n/// [`std::time::SystemTime`]: ../../std/time/struct.SystemTime.html\n///\n/// # Examples\n///\n/// ## `Sub`tractable points\n///\n/// ```\n/// use std::ops::Sub;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl Sub for Point {\n///     type Output = Point;\n///\n///     fn sub(self, other: Point) -> Point {\n///         Point {\n///             x: self.x - other.x,\n///             y: self.y - other.y,\n///         }\n///     }\n/// }\n///\n/// assert_eq!(Point { x: 3, y: 3 } - Point { x: 2, y: 3 },\n///            Point { x: 1, y: 0 });\n/// ```\n///\n/// ## Implementing `Sub` with generics\n///\n/// Here is an example of the same `Point` struct implementing the `Sub` trait\n/// using generics.\n///\n/// ```\n/// use std::ops::Sub;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point<T> {\n///     x: T,\n///     y: T,\n/// }\n///\n/// // Notice that the implementation uses the associated type `Output`.\n/// impl<T: Sub<Output=T>> Sub for Point<T> {\n///     type Output = Point<T>;\n///\n///     fn sub(self, other: Point<T>) -> Point<T> {\n///         Point {\n///             x: self.x - other.x,\n///             y: self.y - other.y,\n///         }\n///     }\n/// }\n///\n/// assert_eq!(Point { x: 2, y: 3 } - Point { x: 1, y: 0 },\n///            Point { x: 1, y: 3 });\n/// ```\n#[lang = \"sub\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"cannot subtract `{RHS}` from `{Self}`\",\n                         label=\"no implementation for `{Self} - {RHS}`\")]\n#[doc(alias = \"-\")]\npub trait Sub<RHS=Self> {\n    /// The resulting type after applying the `-` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `-` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn sub(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! sub_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Sub for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn sub(self, other: $t) -> $t { self - other }\n        }\n\n        forward_ref_binop! { impl Sub, sub for $t, $t }\n    )*)\n}\n\nsub_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The multiplication operator `*`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// ## `Mul`tipliable rational numbers\n///\n/// ```\n/// use std::ops::Mul;\n///\n/// // By the fundamental theorem of arithmetic, rational numbers in lowest\n/// // terms are unique. So, by keeping `Rational`s in reduced form, we can\n/// // derive `Eq` and `PartialEq`.\n/// #[derive(Debug, Eq, PartialEq)]\n/// struct Rational {\n///     nominator: usize,\n///     denominator: usize,\n/// }\n///\n/// impl Rational {\n///     fn new(nominator: usize, denominator: usize) -> Self {\n///         if denominator == 0 {\n///             panic!(\"Zero is an invalid denominator!\");\n///         }\n///\n///         // Reduce to lowest terms by dividing by the greatest common\n///         // divisor.\n///         let gcd = gcd(nominator, denominator);\n///         Rational {\n///             nominator: nominator / gcd,\n///             denominator: denominator / gcd,\n///         }\n///     }\n/// }\n///\n/// impl Mul for Rational {\n///     // The multiplication of rational numbers is a closed operation.\n///     type Output = Self;\n///\n///     fn mul(self, rhs: Self) -> Self {\n///         let nominator = self.nominator * rhs.nominator;\n///         let denominator = self.denominator * rhs.denominator;\n///         Rational::new(nominator, denominator)\n///     }\n/// }\n///\n/// // Euclid's two-thousand-year-old algorithm for finding the greatest common\n/// // divisor.\n/// fn gcd(x: usize, y: usize) -> usize {\n///     let mut x = x;\n///     let mut y = y;\n///     while y != 0 {\n///         let t = y;\n///         y = x % y;\n///         x = t;\n///     }\n///     x\n/// }\n///\n/// assert_eq!(Rational::new(1, 2), Rational::new(2, 4));\n/// assert_eq!(Rational::new(2, 3) * Rational::new(3, 4),\n///            Rational::new(1, 2));\n/// ```\n///\n/// ## Multiplying vectors by scalars as in linear algebra\n///\n/// ```\n/// use std::ops::Mul;\n///\n/// struct Scalar { value: usize }\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Vector { value: Vec<usize> }\n///\n/// impl Mul<Scalar> for Vector {\n///     type Output = Vector;\n///\n///     fn mul(self, rhs: Scalar) -> Vector {\n///         Vector { value: self.value.iter().map(|v| v * rhs.value).collect() }\n///     }\n/// }\n///\n/// let vector = Vector { value: vec![2, 4, 6] };\n/// let scalar = Scalar { value: 3 };\n/// assert_eq!(vector * scalar, Vector { value: vec![6, 12, 18] });\n/// ```\n#[lang = \"mul\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"cannot multiply `{RHS}` to `{Self}`\",\n                         label=\"no implementation for `{Self} * {RHS}`\")]\n#[doc(alias = \"*\")]\npub trait Mul<RHS=Self> {\n    /// The resulting type after applying the `*` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `*` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn mul(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! mul_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Mul for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn mul(self, other: $t) -> $t { self * other }\n        }\n\n        forward_ref_binop! { impl Mul, mul for $t, $t }\n    )*)\n}\n\nmul_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The division operator `/`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// ## `Div`idable rational numbers\n///\n/// ```\n/// use std::ops::Div;\n///\n/// // By the fundamental theorem of arithmetic, rational numbers in lowest\n/// // terms are unique. So, by keeping `Rational`s in reduced form, we can\n/// // derive `Eq` and `PartialEq`.\n/// #[derive(Debug, Eq, PartialEq)]\n/// struct Rational {\n///     nominator: usize,\n///     denominator: usize,\n/// }\n///\n/// impl Rational {\n///     fn new(nominator: usize, denominator: usize) -> Self {\n///         if denominator == 0 {\n///             panic!(\"Zero is an invalid denominator!\");\n///         }\n///\n///         // Reduce to lowest terms by dividing by the greatest common\n///         // divisor.\n///         let gcd = gcd(nominator, denominator);\n///         Rational {\n///             nominator: nominator / gcd,\n///             denominator: denominator / gcd,\n///         }\n///     }\n/// }\n///\n/// impl Div for Rational {\n///     // The division of rational numbers is a closed operation.\n///     type Output = Self;\n///\n///     fn div(self, rhs: Self) -> Self {\n///         if rhs.nominator == 0 {\n///             panic!(\"Cannot divide by zero-valued `Rational`!\");\n///         }\n///\n///         let nominator = self.nominator * rhs.denominator;\n///         let denominator = self.denominator * rhs.nominator;\n///         Rational::new(nominator, denominator)\n///     }\n/// }\n///\n/// // Euclid's two-thousand-year-old algorithm for finding the greatest common\n/// // divisor.\n/// fn gcd(x: usize, y: usize) -> usize {\n///     let mut x = x;\n///     let mut y = y;\n///     while y != 0 {\n///         let t = y;\n///         y = x % y;\n///         x = t;\n///     }\n///     x\n/// }\n///\n/// assert_eq!(Rational::new(1, 2), Rational::new(2, 4));\n/// assert_eq!(Rational::new(1, 2) / Rational::new(3, 4),\n///            Rational::new(2, 3));\n/// ```\n///\n/// ## Dividing vectors by scalars as in linear algebra\n///\n/// ```\n/// use std::ops::Div;\n///\n/// struct Scalar { value: f32 }\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Vector { value: Vec<f32> }\n///\n/// impl Div<Scalar> for Vector {\n///     type Output = Vector;\n///\n///     fn div(self, rhs: Scalar) -> Vector {\n///         Vector { value: self.value.iter().map(|v| v / rhs.value).collect() }\n///     }\n/// }\n///\n/// let scalar = Scalar { value: 2f32 };\n/// let vector = Vector { value: vec![2f32, 4f32, 6f32] };\n/// assert_eq!(vector / scalar, Vector { value: vec![1f32, 2f32, 3f32] });\n/// ```\n#[lang = \"div\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"cannot divide `{Self}` by `{RHS}`\",\n                         label=\"no implementation for `{Self} / {RHS}`\")]\n#[doc(alias = \"/\")]\npub trait Div<RHS=Self> {\n    /// The resulting type after applying the `/` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `/` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn div(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! div_impl_integer {\n    ($($t:ty)*) => ($(\n        /// This operation rounds towards zero, truncating any\n        /// fractional part of the exact result.\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Div for $t {\n            type Output = $t;\n\n            #[inline]\n            fn div(self, other: $t) -> $t { self / other }\n        }\n\n        forward_ref_binop! { impl Div, div for $t, $t }\n    )*)\n}\n\ndiv_impl_integer! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\nmacro_rules! div_impl_float {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Div for $t {\n            type Output = $t;\n\n            #[inline]\n            fn div(self, other: $t) -> $t { self / other }\n        }\n\n        forward_ref_binop! { impl Div, div for $t, $t }\n    )*)\n}\n\ndiv_impl_float! { f32 f64 }\n\n/// The remainder operator `%`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// This example implements `Rem` on a `SplitSlice` object. After `Rem` is\n/// implemented, one can use the `%` operator to find out what the remaining\n/// elements of the slice would be after splitting it into equal slices of a\n/// given length.\n///\n/// ```\n/// use std::ops::Rem;\n///\n/// #[derive(PartialEq, Debug)]\n/// struct SplitSlice<'a, T: 'a> {\n///     slice: &'a [T],\n/// }\n///\n/// impl<'a, T> Rem<usize> for SplitSlice<'a, T> {\n///     type Output = SplitSlice<'a, T>;\n///\n///     fn rem(self, modulus: usize) -> Self {\n///         let len = self.slice.len();\n///         let rem = len % modulus;\n///         let start = len - rem;\n///         SplitSlice {slice: &self.slice[start..]}\n///     }\n/// }\n///\n/// // If we were to divide &[0, 1, 2, 3, 4, 5, 6, 7] into slices of size 3,\n/// // the remainder would be &[6, 7].\n/// assert_eq!(SplitSlice { slice: &[0, 1, 2, 3, 4, 5, 6, 7] } % 3,\n///            SplitSlice { slice: &[6, 7] });\n/// ```\n#[lang = \"rem\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"cannot mod `{Self}` by `{RHS}`\",\n                         label=\"no implementation for `{Self} % {RHS}`\")]\n#[doc(alias = \"%\")]\npub trait Rem<RHS=Self> {\n    /// The resulting type after applying the `%` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output = Self;\n\n    /// Performs the `%` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn rem(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! rem_impl_integer {\n    ($($t:ty)*) => ($(\n        /// This operation satisfies `n % d == n - (n / d) * d`.  The\n        /// result has the same sign as the left operand.\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Rem for $t {\n            type Output = $t;\n\n            #[inline]\n            fn rem(self, other: $t) -> $t { self % other }\n        }\n\n        forward_ref_binop! { impl Rem, rem for $t, $t }\n    )*)\n}\n\nrem_impl_integer! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n\nmacro_rules! rem_impl_float {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Rem for $t {\n            type Output = $t;\n\n            #[inline]\n            fn rem(self, other: $t) -> $t { self % other }\n        }\n\n        forward_ref_binop! { impl Rem, rem for $t, $t }\n    )*)\n}\n\nrem_impl_float! { f32 f64 }\n\n/// The unary negation operator `-`.\n///\n/// # Examples\n///\n/// An implementation of `Neg` for `Sign`, which allows the use of `-` to\n/// negate its value.\n///\n/// ```\n/// use std::ops::Neg;\n///\n/// #[derive(Debug, PartialEq)]\n/// enum Sign {\n///     Negative,\n///     Zero,\n///     Positive,\n/// }\n///\n/// impl Neg for Sign {\n///     type Output = Sign;\n///\n///     fn neg(self) -> Sign {\n///         match self {\n///             Sign::Negative => Sign::Positive,\n///             Sign::Zero => Sign::Zero,\n///             Sign::Positive => Sign::Negative,\n///         }\n///     }\n/// }\n///\n/// // A negative positive is a negative.\n/// assert_eq!(-Sign::Positive, Sign::Negative);\n/// // A double negative is a positive.\n/// assert_eq!(-Sign::Negative, Sign::Positive);\n/// // Zero is its own negation.\n/// assert_eq!(-Sign::Zero, Sign::Zero);\n/// ```\n#[lang = \"neg\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(alias = \"-\")]\npub trait Neg {\n    /// The resulting type after applying the `-` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the unary `-` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn neg(self) -> Self::Output;\n}\n\n\n\nmacro_rules! neg_impl_core {\n    ($id:ident => $body:expr, $($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Neg for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn neg(self) -> $t { let $id = self; $body }\n        }\n\n        forward_ref_unop! { impl Neg, neg for $t }\n    )*)\n}\n\nmacro_rules! neg_impl_numeric {\n    ($($t:ty)*) => { neg_impl_core!{ x => -x, $($t)*} }\n}\n\n#[allow(unused_macros)]\nmacro_rules! neg_impl_unsigned {\n    ($($t:ty)*) => {\n        neg_impl_core!{ x => {\n            !x.wrapping_add(1)\n        }, $($t)*} }\n}\n\n// neg_impl_unsigned! { usize u8 u16 u32 u64 }\nneg_impl_numeric! { isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The addition assignment operator `+=`.\n///\n/// # Examples\n///\n/// This example creates a `Point` struct that implements the `AddAssign`\n/// trait, and then demonstrates add-assigning to a mutable `Point`.\n///\n/// ```\n/// use std::ops::AddAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl AddAssign for Point {\n///     fn add_assign(&mut self, other: Point) {\n///         *self = Point {\n///             x: self.x + other.x,\n///             y: self.y + other.y,\n///         };\n///     }\n/// }\n///\n/// let mut point = Point { x: 1, y: 0 };\n/// point += Point { x: 2, y: 3 };\n/// assert_eq!(point, Point { x: 3, y: 3 });\n/// ```\n#[lang = \"add_assign\"]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"cannot add-assign `{Rhs}` to `{Self}`\",\n                         label=\"no implementation for `{Self} += {Rhs}`\")]\n#[doc(alias = \"+\")]\n#[doc(alias = \"+=\")]\npub trait AddAssign<Rhs=Self> {\n    /// Performs the `+=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn add_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! add_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl AddAssign for $t {\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn add_assign(&mut self, other: $t) { *self += other }\n        }\n\n        forward_ref_op_assign! { impl AddAssign, add_assign for $t, $t }\n    )+)\n}\n\nadd_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The subtraction assignment operator `-=`.\n///\n/// # Examples\n///\n/// This example creates a `Point` struct that implements the `SubAssign`\n/// trait, and then demonstrates sub-assigning to a mutable `Point`.\n///\n/// ```\n/// use std::ops::SubAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Point {\n///     x: i32,\n///     y: i32,\n/// }\n///\n/// impl SubAssign for Point {\n///     fn sub_assign(&mut self, other: Point) {\n///         *self = Point {\n///             x: self.x - other.x,\n///             y: self.y - other.y,\n///         };\n///     }\n/// }\n///\n/// let mut point = Point { x: 3, y: 3 };\n/// point -= Point { x: 2, y: 3 };\n/// assert_eq!(point, Point {x: 1, y: 0});\n/// ```\n#[lang = \"sub_assign\"]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"cannot subtract-assign `{Rhs}` from `{Self}`\",\n                         label=\"no implementation for `{Self} -= {Rhs}`\")]\n#[doc(alias = \"-\")]\n#[doc(alias = \"-=\")]\npub trait SubAssign<Rhs=Self> {\n    /// Performs the `-=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn sub_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! sub_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl SubAssign for $t {\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn sub_assign(&mut self, other: $t) { *self -= other }\n        }\n\n        forward_ref_op_assign! { impl SubAssign, sub_assign for $t, $t }\n    )+)\n}\n\nsub_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The multiplication assignment operator `*=`.\n///\n/// # Examples\n///\n/// ```\n/// use std::ops::MulAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Frequency { hertz: f64 }\n///\n/// impl MulAssign<f64> for Frequency {\n///     fn mul_assign(&mut self, rhs: f64) {\n///         self.hertz *= rhs;\n///     }\n/// }\n///\n/// let mut frequency = Frequency { hertz: 50.0 };\n/// frequency *= 4.0;\n/// assert_eq!(Frequency { hertz: 200.0 }, frequency);\n/// ```\n#[lang = \"mul_assign\"]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"cannot multiply-assign `{Rhs}` to `{Self}`\",\n                         label=\"no implementation for `{Self} *= {Rhs}`\")]\n#[doc(alias = \"*\")]\n#[doc(alias = \"*=\")]\npub trait MulAssign<Rhs=Self> {\n    /// Performs the `*=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn mul_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! mul_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl MulAssign for $t {\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn mul_assign(&mut self, other: $t) { *self *= other }\n        }\n\n        forward_ref_op_assign! { impl MulAssign, mul_assign for $t, $t }\n    )+)\n}\n\nmul_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The division assignment operator `/=`.\n///\n/// # Examples\n///\n/// ```\n/// use std::ops::DivAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Frequency { hertz: f64 }\n///\n/// impl DivAssign<f64> for Frequency {\n///     fn div_assign(&mut self, rhs: f64) {\n///         self.hertz /= rhs;\n///     }\n/// }\n///\n/// let mut frequency = Frequency { hertz: 200.0 };\n/// frequency /= 4.0;\n/// assert_eq!(Frequency { hertz: 50.0 }, frequency);\n/// ```\n#[lang = \"div_assign\"]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"cannot divide-assign `{Self}` by `{Rhs}`\",\n                         label=\"no implementation for `{Self} /= {Rhs}`\")]\n#[doc(alias = \"/\")]\n#[doc(alias = \"/=\")]\npub trait DivAssign<Rhs=Self> {\n    /// Performs the `/=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn div_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! div_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl DivAssign for $t {\n            #[inline]\n            fn div_assign(&mut self, other: $t) { *self /= other }\n        }\n\n        forward_ref_op_assign! { impl DivAssign, div_assign for $t, $t }\n    )+)\n}\n\ndiv_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n\n/// The remainder assignment operator `%=`.\n///\n/// # Examples\n///\n/// ```\n/// use std::ops::RemAssign;\n///\n/// struct CookieJar { cookies: u32 }\n///\n/// impl RemAssign<u32> for CookieJar {\n///     fn rem_assign(&mut self, piles: u32) {\n///         self.cookies %= piles;\n///     }\n/// }\n///\n/// let mut jar = CookieJar { cookies: 31 };\n/// let piles = 4;\n///\n/// println!(\"Splitting up {} cookies into {} even piles!\", jar.cookies, piles);\n///\n/// jar %= piles;\n///\n/// println!(\"{} cookies remain in the cookie jar!\", jar.cookies);\n/// ```\n#[lang = \"rem_assign\"]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"cannot mod-assign `{Self}` by `{Rhs}``\",\n                         label=\"no implementation for `{Self} %= {Rhs}`\")]\n#[doc(alias = \"%\")]\n#[doc(alias = \"%=\")]\npub trait RemAssign<Rhs=Self> {\n    /// Performs the `%=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn rem_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! rem_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl RemAssign for $t {\n            #[inline]\n            fn rem_assign(&mut self, other: $t) { *self %= other }\n        }\n\n        forward_ref_op_assign! { impl RemAssign, rem_assign for $t, $t }\n    )+)\n}\n\nrem_assign_impl! { usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 f32 f64 }\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Panic support for libcore\n//!\n//! The core library cannot define panicking, but it does *declare* panicking. This\n//! means that the functions inside of libcore are allowed to panic, but to be\n//! useful an upstream crate must define panicking for libcore to use. The current\n//! interface for panicking is:\n//!\n//! ```\n//! # use std::fmt;\n//! fn panic_impl(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> !\n//! # { loop {} }\n//! ```\n//!\n//! This definition allows for panicking with any general message, but it does not\n//! allow for failing with a `Box<Any>` value. The reason for this is that libcore\n//! is not allowed to allocate.\n//!\n//! This module contains a few other panicking functions, but these are just the\n//! necessary lang items for the compiler. All panics are funneled through this\n//! one function. Currently, the actual symbol is declared in the standard\n//! library, but the location of this may change over time.\n\n#![allow(dead_code, missing_docs)]\n#![unstable(feature = \"core_panic\",\n            reason = \"internal details of the implementation of the `panic!` \\\n                      and related macros\",\n            issue = \"0\")]\n\nuse fmt;\nuse panic::{Location, PanicInfo};\n\n#[cold] #[inline(never)] // this is the slow path, always\n#[lang = \"panic\"]\npub fn panic(expr_file_line_col: &(&'static str, &'static str, u32, u32)) -> ! {\n    // Use Arguments::new_v1 instead of format_args!(\"{}\", expr) to potentially\n    // reduce size overhead. The format_args! macro uses str's Display trait to\n    // write expr, which calls Formatter::pad, which must accommodate string\n    // truncation and padding (even though none is used here). Using\n    // Arguments::new_v1 may allow the compiler to omit Formatter::pad from the\n    // output binary, saving up to a few kilobytes.\n    let (expr, file, line, col) = *expr_file_line_col;\n    panic_fmt(fmt::Arguments::new_v1(&[expr], &[]), &(file, line, col))\n}\n\n#[cold] #[inline(never)]\n#[lang = \"panic_bounds_check\"]\nfn panic_bounds_check(file_line_col: &(&'static str, u32, u32),\n                     index: usize, len: usize) -> ! {\n    panic_fmt(format_args!(\"index out of bounds: the len is {} but the index is {}\",\n                           len, index), file_line_col)\n}\n\n#[cold] #[inline(never)]\npub fn panic_fmt(fmt: fmt::Arguments, file_line_col: &(&'static str, u32, u32)) -> ! {\n    // NOTE This function never crosses the FFI boundary; it's a Rust-to-Rust call\n    #[allow(improper_ctypes)] // PanicInfo contains a trait object which is not FFI safe\n    extern \"Rust\" {\n        #[lang = \"panic_impl\"]\n        fn panic_impl(pi: &PanicInfo) -> !;\n    }\n\n    let (file, line, col) = *file_line_col;\n    let pi = PanicInfo::internal_constructor(\n        Some(&fmt),\n        Location::internal_constructor(file, line, col),\n    );\n    unsafe { panic_impl(&pi) }\n}\n","// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cmp::Ordering;\nuse ops::Try;\n\nuse super::LoopState;\nuse super::{Chain, Cycle, Cloned, Enumerate, Filter, FilterMap, Fuse};\nuse super::{Flatten, FlatMap, flatten_compat};\nuse super::{Inspect, Map, Peekable, Scan, Skip, SkipWhile, StepBy, Take, TakeWhile, Rev};\nuse super::{Zip, Sum, Product};\nuse super::{ChainState, FromIterator, ZipImpl};\n\nfn _assert_is_object_safe(_: &dyn Iterator<Item=()>) {}\n\n/// An interface for dealing with iterators.\n///\n/// This is the main iterator trait. For more about the concept of iterators\n/// generally, please see the [module-level documentation]. In particular, you\n/// may want to know how to [implement `Iterator`][impl].\n///\n/// [module-level documentation]: index.html\n/// [impl]: index.html#implementing-iterator\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    on(\n        _Self=\"[std::ops::Range<Idx>; 1]\",\n        label=\"if you meant to iterate between two values, remove the square brackets\",\n        note=\"`[start..end]` is an array of one `Range`; you might have meant to have a `Range` \\\n              without the brackets: `start..end`\"\n    ),\n    on(\n        _Self=\"[std::ops::RangeFrom<Idx>; 1]\",\n        label=\"if you meant to iterate from a value onwards, remove the square brackets\",\n        note=\"`[start..]` is an array of one `RangeFrom`; you might have meant to have a \\\n              `RangeFrom` without the brackets: `start..`, keeping in mind that iterating over an \\\n              unbounded iterator will run forever unless you `break` or `return` from within the \\\n              loop\"\n    ),\n    on(\n        _Self=\"[std::ops::RangeTo<Idx>; 1]\",\n        label=\"if you meant to iterate until a value, remove the square brackets and add a \\\n               starting value\",\n        note=\"`[..end]` is an array of one `RangeTo`; you might have meant to have a bounded \\\n              `Range` without the brackets: `0..end`\"\n    ),\n    on(\n        _Self=\"[std::ops::RangeInclusive<Idx>; 1]\",\n        label=\"if you meant to iterate between two values, remove the square brackets\",\n        note=\"`[start..=end]` is an array of one `RangeInclusive`; you might have meant to have a \\\n              `RangeInclusive` without the brackets: `start..=end`\"\n    ),\n    on(\n        _Self=\"[std::ops::RangeToInclusive<Idx>; 1]\",\n        label=\"if you meant to iterate until a value (including it), remove the square brackets \\\n               and add a starting value\",\n        note=\"`[..=end]` is an array of one `RangeToInclusive`; you might have meant to have a \\\n              bounded `RangeInclusive` without the brackets: `0..=end`\"\n    ),\n    on(\n        _Self=\"std::ops::RangeTo<Idx>\",\n        label=\"if you meant to iterate until a value, add a starting value\",\n        note=\"`..end` is a `RangeTo`, which cannot be iterated on; you might have meant to have a \\\n              bounded `Range`: `0..end`\"\n    ),\n    on(\n        _Self=\"std::ops::RangeToInclusive<Idx>\",\n        label=\"if you meant to iterate until a value (including it), add a starting value\",\n        note=\"`..=end` is a `RangeToInclusive`, which cannot be iterated on; you might have meant \\\n              to have a bounded `RangeInclusive`: `0..=end`\"\n    ),\n    on(\n        _Self=\"&str\",\n        label=\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"\n    ),\n    on(\n        _Self=\"std::string::String\",\n        label=\"`{Self}` is not an iterator; try calling `.chars()` or `.bytes()`\"\n    ),\n    on(\n        _Self=\"[]\",\n        label=\"borrow the array with `&` or call `.iter()` on it to iterate over it\",\n        note=\"arrays are not an iterators, but slices like the following are: `&[1, 2, 3]`\"\n    ),\n    on(\n        _Self=\"{integral}\",\n        note=\"if you want to iterate between `start` until a value `end`, use the exclusive range \\\n              syntax `start..end` or the inclusive range syntax `start..=end`\"\n    ),\n    label=\"`{Self}` is not an iterator\",\n    message=\"`{Self}` is not an iterator\"\n)]\n#[doc(spotlight)]\npub trait Iterator {\n    /// The type of the elements being iterated over.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Item;\n\n    /// Advances the iterator and returns the next value.\n    ///\n    /// Returns [`None`] when iteration is finished. Individual iterator\n    /// implementations may choose to resume iteration, and so calling `next()`\n    /// again may or may not eventually start returning [`Some(Item)`] again at some\n    /// point.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`Some(Item)`]: ../../std/option/enum.Option.html#variant.Some\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// // A call to next() returns the next value...\n    /// assert_eq!(Some(&1), iter.next());\n    /// assert_eq!(Some(&2), iter.next());\n    /// assert_eq!(Some(&3), iter.next());\n    ///\n    /// // ... and then None once it's over.\n    /// assert_eq!(None, iter.next());\n    ///\n    /// // More calls may or may not return None. Here, they always will.\n    /// assert_eq!(None, iter.next());\n    /// assert_eq!(None, iter.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn next(&mut self) -> Option<Self::Item>;\n\n    /// Returns the bounds on the remaining length of the iterator.\n    ///\n    /// Specifically, `size_hint()` returns a tuple where the first element\n    /// is the lower bound, and the second element is the upper bound.\n    ///\n    /// The second half of the tuple that is returned is an [`Option`]`<`[`usize`]`>`.\n    /// A [`None`] here means that either there is no known upper bound, or the\n    /// upper bound is larger than [`usize`].\n    ///\n    /// # Implementation notes\n    ///\n    /// It is not enforced that an iterator implementation yields the declared\n    /// number of elements. A buggy iterator may yield less than the lower bound\n    /// or more than the upper bound of elements.\n    ///\n    /// `size_hint()` is primarily intended to be used for optimizations such as\n    /// reserving space for the elements of the iterator, but must not be\n    /// trusted to e.g. omit bounds checks in unsafe code. An incorrect\n    /// implementation of `size_hint()` should not lead to memory safety\n    /// violations.\n    ///\n    /// That said, the implementation should provide a correct estimation,\n    /// because otherwise it would be a violation of the trait's protocol.\n    ///\n    /// The default implementation returns `(0, None)` which is correct for any\n    /// iterator.\n    ///\n    /// [`usize`]: ../../std/primitive.usize.html\n    /// [`Option`]: ../../std/option/enum.Option.html\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// let iter = a.iter();\n    ///\n    /// assert_eq!((3, Some(3)), iter.size_hint());\n    /// ```\n    ///\n    /// A more complex example:\n    ///\n    /// ```\n    /// // The even numbers from zero to ten.\n    /// let iter = (0..10).filter(|x| x % 2 == 0);\n    ///\n    /// // We might iterate from zero to ten times. Knowing that it's five\n    /// // exactly wouldn't be possible without executing filter().\n    /// assert_eq!((0, Some(10)), iter.size_hint());\n    ///\n    /// // Let's add five more numbers with chain()\n    /// let iter = (0..10).filter(|x| x % 2 == 0).chain(15..20);\n    ///\n    /// // now both bounds are increased by five\n    /// assert_eq!((5, Some(15)), iter.size_hint());\n    /// ```\n    ///\n    /// Returning `None` for an upper bound:\n    ///\n    /// ```\n    /// // an infinite iterator has no upper bound\n    /// // and the maximum possible lower bound\n    /// let iter = 0..;\n    ///\n    /// assert_eq!((usize::max_value(), None), iter.size_hint());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn size_hint(&self) -> (usize, Option<usize>) { (0, None) }\n\n    /// Consumes the iterator, counting the number of iterations and returning it.\n    ///\n    /// This method will evaluate the iterator until its [`next`] returns\n    /// [`None`]. Once [`None`] is encountered, `count()` returns the number of\n    /// times it called [`next`].\n    ///\n    /// [`next`]: #tymethod.next\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Overflow Behavior\n    ///\n    /// The method does no guarding against overflows, so counting elements of\n    /// an iterator with more than [`usize::MAX`] elements either produces the\n    /// wrong result or panics. If debug assertions are enabled, a panic is\n    /// guaranteed.\n    ///\n    /// # Panics\n    ///\n    /// This function might panic if the iterator has more than [`usize::MAX`]\n    /// elements.\n    ///\n    /// [`usize::MAX`]: ../../std/usize/constant.MAX.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert_eq!(a.iter().count(), 3);\n    ///\n    /// let a = [1, 2, 3, 4, 5];\n    /// assert_eq!(a.iter().count(), 5);\n    /// ```\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn count(self) -> usize where Self: Sized {\n        // Might overflow.\n        self.fold(0, |cnt, _| cnt + 1)\n    }\n\n    /// Consumes the iterator, returning the last element.\n    ///\n    /// This method will evaluate the iterator until it returns [`None`]. While\n    /// doing so, it keeps track of the current element. After [`None`] is\n    /// returned, `last()` will then return the last element it saw.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert_eq!(a.iter().last(), Some(&3));\n    ///\n    /// let a = [1, 2, 3, 4, 5];\n    /// assert_eq!(a.iter().last(), Some(&5));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn last(self) -> Option<Self::Item> where Self: Sized {\n        let mut last = None;\n        for x in self { last = Some(x); }\n        last\n    }\n\n    /// Returns the `n`th element of the iterator.\n    ///\n    /// Like most indexing operations, the count starts from zero, so `nth(0)`\n    /// returns the first value, `nth(1)` the second, and so on.\n    ///\n    /// Note that all preceding elements, as well as the returned element, will be\n    /// consumed from the iterator. That means that the preceding elements will be\n    /// discarded, and also that calling `nth(0)` multiple times on the same iterator\n    /// will return different elements.\n    ///\n    /// `nth()` will return [`None`] if `n` is greater than or equal to the length of the\n    /// iterator.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert_eq!(a.iter().nth(1), Some(&2));\n    /// ```\n    ///\n    /// Calling `nth()` multiple times doesn't rewind the iterator:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert_eq!(iter.nth(1), Some(&2));\n    /// assert_eq!(iter.nth(1), None);\n    /// ```\n    ///\n    /// Returning `None` if there are less than `n + 1` elements:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// assert_eq!(a.iter().nth(10), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn nth(&mut self, mut n: usize) -> Option<Self::Item> {\n        for x in self {\n            if n == 0 { return Some(x) }\n            n -= 1;\n        }\n        None\n    }\n\n    /// Creates an iterator starting at the same point, but stepping by\n    /// the given amount at each iteration.\n    ///\n    /// Note 1: The first element of the iterator will always be returned,\n    /// regardless of the step given.\n    ///\n    /// Note 2: The time at which ignored elements are pulled is not fixed.\n    /// `StepBy` behaves like the sequence `next(), nth(step-1), nth(step-1), \u2026`,\n    /// but is also free to behave like the sequence\n    /// `advance_n_and_return_first(step), advance_n_and_return_first(step), \u2026`\n    /// Which way is used may change for some iterators for performance reasons.\n    /// The second way will advance the iterator earlier and may consume more items.\n    ///\n    /// `advance_n_and_return_first` is the equivalent of:\n    /// ```\n    /// fn advance_n_and_return_first<I>(iter: &mut I, total_step: usize) -> Option<I::Item>\n    /// where\n    ///     I: Iterator,\n    /// {\n    ///     let next = iter.next();\n    ///     if total_step > 1 {\n    ///         iter.nth(total_step-2);\n    ///     }\n    ///     next\n    /// }\n    /// ```\n    ///\n    /// # Panics\n    ///\n    /// The method will panic if the given step is `0`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [0, 1, 2, 3, 4, 5];\n    /// let mut iter = a.into_iter().step_by(2);\n    ///\n    /// assert_eq!(iter.next(), Some(&0));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), Some(&4));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_step_by\", since = \"1.28.0\")]\n    fn step_by(self, step: usize) -> StepBy<Self> where Self: Sized {\n        assert!(step != 0);\n        StepBy{iter: self, step: step - 1, first_take: true}\n    }\n\n    /// Takes two iterators and creates a new iterator over both in sequence.\n    ///\n    /// `chain()` will return a new iterator which will first iterate over\n    /// values from the first iterator and then over values from the second\n    /// iterator.\n    ///\n    /// In other words, it links two iterators together, in a chain. \ud83d\udd17\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a1 = [1, 2, 3];\n    /// let a2 = [4, 5, 6];\n    ///\n    /// let mut iter = a1.iter().chain(a2.iter());\n    ///\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), Some(&3));\n    /// assert_eq!(iter.next(), Some(&4));\n    /// assert_eq!(iter.next(), Some(&5));\n    /// assert_eq!(iter.next(), Some(&6));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Since the argument to `chain()` uses [`IntoIterator`], we can pass\n    /// anything that can be converted into an [`Iterator`], not just an\n    /// [`Iterator`] itself. For example, slices (`&[T]`) implement\n    /// [`IntoIterator`], and so can be passed to `chain()` directly:\n    ///\n    /// [`IntoIterator`]: trait.IntoIterator.html\n    /// [`Iterator`]: trait.Iterator.html\n    ///\n    /// ```\n    /// let s1 = &[1, 2, 3];\n    /// let s2 = &[4, 5, 6];\n    ///\n    /// let mut iter = s1.iter().chain(s2);\n    ///\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), Some(&3));\n    /// assert_eq!(iter.next(), Some(&4));\n    /// assert_eq!(iter.next(), Some(&5));\n    /// assert_eq!(iter.next(), Some(&6));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where\n        Self: Sized, U: IntoIterator<Item=Self::Item>,\n    {\n        Chain{a: self, b: other.into_iter(), state: ChainState::Both}\n    }\n\n    /// 'Zips up' two iterators into a single iterator of pairs.\n    ///\n    /// `zip()` returns a new iterator that will iterate over two other\n    /// iterators, returning a tuple where the first element comes from the\n    /// first iterator, and the second element comes from the second iterator.\n    ///\n    /// In other words, it zips two iterators together, into a single one.\n    ///\n    /// If either iterator returns [`None`], [`next`] from the zipped iterator\n    /// will return [`None`]. If the first iterator returns [`None`], `zip` will\n    /// short-circuit and `next` will not be called on the second iterator.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a1 = [1, 2, 3];\n    /// let a2 = [4, 5, 6];\n    ///\n    /// let mut iter = a1.iter().zip(a2.iter());\n    ///\n    /// assert_eq!(iter.next(), Some((&1, &4)));\n    /// assert_eq!(iter.next(), Some((&2, &5)));\n    /// assert_eq!(iter.next(), Some((&3, &6)));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Since the argument to `zip()` uses [`IntoIterator`], we can pass\n    /// anything that can be converted into an [`Iterator`], not just an\n    /// [`Iterator`] itself. For example, slices (`&[T]`) implement\n    /// [`IntoIterator`], and so can be passed to `zip()` directly:\n    ///\n    /// [`IntoIterator`]: trait.IntoIterator.html\n    /// [`Iterator`]: trait.Iterator.html\n    ///\n    /// ```\n    /// let s1 = &[1, 2, 3];\n    /// let s2 = &[4, 5, 6];\n    ///\n    /// let mut iter = s1.iter().zip(s2);\n    ///\n    /// assert_eq!(iter.next(), Some((&1, &4)));\n    /// assert_eq!(iter.next(), Some((&2, &5)));\n    /// assert_eq!(iter.next(), Some((&3, &6)));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// `zip()` is often used to zip an infinite iterator to a finite one.\n    /// This works because the finite iterator will eventually return [`None`],\n    /// ending the zipper. Zipping with `(0..)` can look a lot like [`enumerate`]:\n    ///\n    /// ```\n    /// let enumerate: Vec<_> = \"foo\".chars().enumerate().collect();\n    ///\n    /// let zipper: Vec<_> = (0..).zip(\"foo\".chars()).collect();\n    ///\n    /// assert_eq!((0, 'f'), enumerate[0]);\n    /// assert_eq!((0, 'f'), zipper[0]);\n    ///\n    /// assert_eq!((1, 'o'), enumerate[1]);\n    /// assert_eq!((1, 'o'), zipper[1]);\n    ///\n    /// assert_eq!((2, 'o'), enumerate[2]);\n    /// assert_eq!((2, 'o'), zipper[2]);\n    /// ```\n    ///\n    /// [`enumerate`]: trait.Iterator.html#method.enumerate\n    /// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where\n        Self: Sized, U: IntoIterator\n    {\n        Zip::new(self, other.into_iter())\n    }\n\n    /// Takes a closure and creates an iterator which calls that closure on each\n    /// element.\n    ///\n    /// `map()` transforms one iterator into another, by means of its argument:\n    /// something that implements `FnMut`. It produces a new iterator which\n    /// calls this closure on each element of the original iterator.\n    ///\n    /// If you are good at thinking in types, you can think of `map()` like this:\n    /// If you have an iterator that gives you elements of some type `A`, and\n    /// you want an iterator of some other type `B`, you can use `map()`,\n    /// passing a closure that takes an `A` and returns a `B`.\n    ///\n    /// `map()` is conceptually similar to a [`for`] loop. However, as `map()` is\n    /// lazy, it is best used when you're already working with other iterators.\n    /// If you're doing some sort of looping for a side effect, it's considered\n    /// more idiomatic to use [`for`] than `map()`.\n    ///\n    /// [`for`]: ../../book/first-edition/loops.html#for\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.into_iter().map(|x| 2 * x);\n    ///\n    /// assert_eq!(iter.next(), Some(2));\n    /// assert_eq!(iter.next(), Some(4));\n    /// assert_eq!(iter.next(), Some(6));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// If you're doing some sort of side effect, prefer [`for`] to `map()`:\n    ///\n    /// ```\n    /// # #![allow(unused_must_use)]\n    /// // don't do this:\n    /// (0..5).map(|x| println!(\"{}\", x));\n    ///\n    /// // it won't even execute, as it is lazy. Rust will warn you about this.\n    ///\n    /// // Instead, use for:\n    /// for x in 0..5 {\n    ///     println!(\"{}\", x);\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn map<B, F>(self, f: F) -> Map<Self, F> where\n        Self: Sized, F: FnMut(Self::Item) -> B,\n    {\n        Map { iter: self, f }\n    }\n\n    /// Calls a closure on each element of an iterator.\n    ///\n    /// This is equivalent to using a [`for`] loop on the iterator, although\n    /// `break` and `continue` are not possible from a closure.  It's generally\n    /// more idiomatic to use a `for` loop, but `for_each` may be more legible\n    /// when processing items at the end of longer iterator chains.  In some\n    /// cases `for_each` may also be faster than a loop, because it will use\n    /// internal iteration on adaptors like `Chain`.\n    ///\n    /// [`for`]: ../../book/first-edition/loops.html#for\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::sync::mpsc::channel;\n    ///\n    /// let (tx, rx) = channel();\n    /// (0..5).map(|x| x * 2 + 1)\n    ///       .for_each(move |x| tx.send(x).unwrap());\n    ///\n    /// let v: Vec<_> =  rx.iter().collect();\n    /// assert_eq!(v, vec![1, 3, 5, 7, 9]);\n    /// ```\n    ///\n    /// For such a small example, a `for` loop may be cleaner, but `for_each`\n    /// might be preferable to keep a functional style with longer iterators:\n    ///\n    /// ```\n    /// (0..5).flat_map(|x| x * 100 .. x * 110)\n    ///       .enumerate()\n    ///       .filter(|&(i, x)| (i + x) % 3 == 0)\n    ///       .for_each(|(i, x)| println!(\"{}:{}\", i, x));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_for_each\", since = \"1.21.0\")]\n    fn for_each<F>(self, mut f: F) where\n        Self: Sized, F: FnMut(Self::Item),\n    {\n        self.fold((), move |(), item| f(item));\n    }\n\n    /// Creates an iterator which uses a closure to determine if an element\n    /// should be yielded.\n    ///\n    /// The closure must return `true` or `false`. `filter()` creates an\n    /// iterator which calls this closure on each element. If the closure\n    /// returns `true`, then the element is returned. If the closure returns\n    /// `false`, it will try again, and call the closure on the next element,\n    /// seeing if it passes the test.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [0i32, 1, 2];\n    ///\n    /// let mut iter = a.into_iter().filter(|x| x.is_positive());\n    ///\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Because the closure passed to `filter()` takes a reference, and many\n    /// iterators iterate over references, this leads to a possibly confusing\n    /// situation, where the type of the closure is a double reference:\n    ///\n    /// ```\n    /// let a = [0, 1, 2];\n    ///\n    /// let mut iter = a.into_iter().filter(|x| **x > 1); // need two *s!\n    ///\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// It's common to instead use destructuring on the argument to strip away\n    /// one:\n    ///\n    /// ```\n    /// let a = [0, 1, 2];\n    ///\n    /// let mut iter = a.into_iter().filter(|&x| *x > 1); // both & and *\n    ///\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// or both:\n    ///\n    /// ```\n    /// let a = [0, 1, 2];\n    ///\n    /// let mut iter = a.into_iter().filter(|&&x| x > 1); // two &s\n    ///\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// of these layers.\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn filter<P>(self, predicate: P) -> Filter<Self, P> where\n        Self: Sized, P: FnMut(&Self::Item) -> bool,\n    {\n        Filter {iter: self, predicate }\n    }\n\n    /// Creates an iterator that both filters and maps.\n    ///\n    /// The closure must return an [`Option<T>`]. `filter_map` creates an\n    /// iterator which calls this closure on each element. If the closure\n    /// returns [`Some(element)`][`Some`], then that element is returned. If the\n    /// closure returns [`None`], it will try again, and call the closure on the\n    /// next element, seeing if it will return [`Some`].\n    ///\n    /// Why `filter_map` and not just [`filter`] and [`map`]? The key is in this\n    /// part:\n    ///\n    /// [`filter`]: #method.filter\n    /// [`map`]: #method.map\n    ///\n    /// > If the closure returns [`Some(element)`][`Some`], then that element is returned.\n    ///\n    /// In other words, it removes the [`Option<T>`] layer automatically. If your\n    /// mapping is already returning an [`Option<T>`] and you want to skip over\n    /// [`None`]s, then `filter_map` is much, much nicer to use.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [\"1\", \"lol\", \"3\", \"NaN\", \"5\"];\n    ///\n    /// let mut iter = a.iter().filter_map(|s| s.parse().ok());\n    ///\n    /// assert_eq!(iter.next(), Some(1));\n    /// assert_eq!(iter.next(), Some(3));\n    /// assert_eq!(iter.next(), Some(5));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Here's the same example, but with [`filter`] and [`map`]:\n    ///\n    /// ```\n    /// let a = [\"1\", \"lol\", \"3\", \"NaN\", \"5\"];\n    /// let mut iter = a.iter().map(|s| s.parse()).filter(|s| s.is_ok()).map(|s| s.unwrap());\n    /// assert_eq!(iter.next(), Some(1));\n    /// assert_eq!(iter.next(), Some(3));\n    /// assert_eq!(iter.next(), Some(5));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// [`Option<T>`]: ../../std/option/enum.Option.html\n    /// [`Some`]: ../../std/option/enum.Option.html#variant.Some\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where\n        Self: Sized, F: FnMut(Self::Item) -> Option<B>,\n    {\n        FilterMap { iter: self, f }\n    }\n\n    /// Creates an iterator which gives the current iteration count as well as\n    /// the next value.\n    ///\n    /// The iterator returned yields pairs `(i, val)`, where `i` is the\n    /// current index of iteration and `val` is the value returned by the\n    /// iterator.\n    ///\n    /// `enumerate()` keeps its count as a [`usize`]. If you want to count by a\n    /// different sized integer, the [`zip`] function provides similar\n    /// functionality.\n    ///\n    /// # Overflow Behavior\n    ///\n    /// The method does no guarding against overflows, so enumerating more than\n    /// [`usize::MAX`] elements either produces the wrong result or panics. If\n    /// debug assertions are enabled, a panic is guaranteed.\n    ///\n    /// # Panics\n    ///\n    /// The returned iterator might panic if the to-be-returned index would\n    /// overflow a [`usize`].\n    ///\n    /// [`usize::MAX`]: ../../std/usize/constant.MAX.html\n    /// [`usize`]: ../../std/primitive.usize.html\n    /// [`zip`]: #method.zip\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = ['a', 'b', 'c'];\n    ///\n    /// let mut iter = a.iter().enumerate();\n    ///\n    /// assert_eq!(iter.next(), Some((0, &'a')));\n    /// assert_eq!(iter.next(), Some((1, &'b')));\n    /// assert_eq!(iter.next(), Some((2, &'c')));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn enumerate(self) -> Enumerate<Self> where Self: Sized {\n        Enumerate { iter: self, count: 0 }\n    }\n\n    /// Creates an iterator which can use `peek` to look at the next element of\n    /// the iterator without consuming it.\n    ///\n    /// Adds a [`peek`] method to an iterator. See its documentation for\n    /// more information.\n    ///\n    /// Note that the underlying iterator is still advanced when [`peek`] is\n    /// called for the first time: In order to retrieve the next element,\n    /// [`next`] is called on the underlying iterator, hence any side effects (i.e.\n    /// anything other than fetching the next value) of the [`next`] method\n    /// will occur.\n    ///\n    /// [`peek`]: struct.Peekable.html#method.peek\n    /// [`next`]: ../../std/iter/trait.Iterator.html#tymethod.next\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let xs = [1, 2, 3];\n    ///\n    /// let mut iter = xs.iter().peekable();\n    ///\n    /// // peek() lets us see into the future\n    /// assert_eq!(iter.peek(), Some(&&1));\n    /// assert_eq!(iter.next(), Some(&1));\n    ///\n    /// assert_eq!(iter.next(), Some(&2));\n    ///\n    /// // we can peek() multiple times, the iterator won't advance\n    /// assert_eq!(iter.peek(), Some(&&3));\n    /// assert_eq!(iter.peek(), Some(&&3));\n    ///\n    /// assert_eq!(iter.next(), Some(&3));\n    ///\n    /// // after the iterator is finished, so is peek()\n    /// assert_eq!(iter.peek(), None);\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn peekable(self) -> Peekable<Self> where Self: Sized {\n        Peekable{iter: self, peeked: None}\n    }\n\n    /// Creates an iterator that [`skip`]s elements based on a predicate.\n    ///\n    /// [`skip`]: #method.skip\n    ///\n    /// `skip_while()` takes a closure as an argument. It will call this\n    /// closure on each element of the iterator, and ignore elements\n    /// until it returns `false`.\n    ///\n    /// After `false` is returned, `skip_while()`'s job is over, and the\n    /// rest of the elements are yielded.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [-1i32, 0, 1];\n    ///\n    /// let mut iter = a.into_iter().skip_while(|x| x.is_negative());\n    ///\n    /// assert_eq!(iter.next(), Some(&0));\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Because the closure passed to `skip_while()` takes a reference, and many\n    /// iterators iterate over references, this leads to a possibly confusing\n    /// situation, where the type of the closure is a double reference:\n    ///\n    /// ```\n    /// let a = [-1, 0, 1];\n    ///\n    /// let mut iter = a.into_iter().skip_while(|x| **x < 0); // need two *s!\n    ///\n    /// assert_eq!(iter.next(), Some(&0));\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Stopping after an initial `false`:\n    ///\n    /// ```\n    /// let a = [-1, 0, 1, -2];\n    ///\n    /// let mut iter = a.into_iter().skip_while(|x| **x < 0);\n    ///\n    /// assert_eq!(iter.next(), Some(&0));\n    /// assert_eq!(iter.next(), Some(&1));\n    ///\n    /// // while this would have been false, since we already got a false,\n    /// // skip_while() isn't used any more\n    /// assert_eq!(iter.next(), Some(&-2));\n    ///\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where\n        Self: Sized, P: FnMut(&Self::Item) -> bool,\n    {\n        SkipWhile { iter: self, flag: false, predicate }\n    }\n\n    /// Creates an iterator that yields elements based on a predicate.\n    ///\n    /// `take_while()` takes a closure as an argument. It will call this\n    /// closure on each element of the iterator, and yield elements\n    /// while it returns `true`.\n    ///\n    /// After `false` is returned, `take_while()`'s job is over, and the\n    /// rest of the elements are ignored.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [-1i32, 0, 1];\n    ///\n    /// let mut iter = a.into_iter().take_while(|x| x.is_negative());\n    ///\n    /// assert_eq!(iter.next(), Some(&-1));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Because the closure passed to `take_while()` takes a reference, and many\n    /// iterators iterate over references, this leads to a possibly confusing\n    /// situation, where the type of the closure is a double reference:\n    ///\n    /// ```\n    /// let a = [-1, 0, 1];\n    ///\n    /// let mut iter = a.into_iter().take_while(|x| **x < 0); // need two *s!\n    ///\n    /// assert_eq!(iter.next(), Some(&-1));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Stopping after an initial `false`:\n    ///\n    /// ```\n    /// let a = [-1, 0, 1, -2];\n    ///\n    /// let mut iter = a.into_iter().take_while(|x| **x < 0);\n    ///\n    /// assert_eq!(iter.next(), Some(&-1));\n    ///\n    /// // We have more elements that are less than zero, but since we already\n    /// // got a false, take_while() isn't used any more\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// Because `take_while()` needs to look at the value in order to see if it\n    /// should be included or not, consuming iterators will see that it is\n    /// removed:\n    ///\n    /// ```\n    /// let a = [1, 2, 3, 4];\n    /// let mut iter = a.into_iter();\n    ///\n    /// let result: Vec<i32> = iter.by_ref()\n    ///                            .take_while(|n| **n != 3)\n    ///                            .cloned()\n    ///                            .collect();\n    ///\n    /// assert_eq!(result, &[1, 2]);\n    ///\n    /// let result: Vec<i32> = iter.cloned().collect();\n    ///\n    /// assert_eq!(result, &[4]);\n    /// ```\n    ///\n    /// The `3` is no longer there, because it was consumed in order to see if\n    /// the iteration should stop, but wasn't placed back into the iterator or\n    /// some similar thing.\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where\n        Self: Sized, P: FnMut(&Self::Item) -> bool,\n    {\n        TakeWhile { iter: self, flag: false, predicate }\n    }\n\n    /// Creates an iterator that skips the first `n` elements.\n    ///\n    /// After they have been consumed, the rest of the elements are yielded.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter().skip(2);\n    ///\n    /// assert_eq!(iter.next(), Some(&3));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn skip(self, n: usize) -> Skip<Self> where Self: Sized {\n        Skip { iter: self, n }\n    }\n\n    /// Creates an iterator that yields its first `n` elements.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter().take(2);\n    ///\n    /// assert_eq!(iter.next(), Some(&1));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    ///\n    /// `take()` is often used with an infinite iterator, to make it finite:\n    ///\n    /// ```\n    /// let mut iter = (0..).take(3);\n    ///\n    /// assert_eq!(iter.next(), Some(0));\n    /// assert_eq!(iter.next(), Some(1));\n    /// assert_eq!(iter.next(), Some(2));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn take(self, n: usize) -> Take<Self> where Self: Sized, {\n        Take { iter: self, n }\n    }\n\n    /// An iterator adaptor similar to [`fold`] that holds internal state and\n    /// produces a new iterator.\n    ///\n    /// [`fold`]: #method.fold\n    ///\n    /// `scan()` takes two arguments: an initial value which seeds the internal\n    /// state, and a closure with two arguments, the first being a mutable\n    /// reference to the internal state and the second an iterator element.\n    /// The closure can assign to the internal state to share state between\n    /// iterations.\n    ///\n    /// On iteration, the closure will be applied to each element of the\n    /// iterator and the return value from the closure, an [`Option`], is\n    /// yielded by the iterator.\n    ///\n    /// [`Option`]: ../../std/option/enum.Option.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter().scan(1, |state, &x| {\n    ///     // each iteration, we'll multiply the state by the element\n    ///     *state = *state * x;\n    ///\n    ///     // then, we'll yield the negation of the state\n    ///     Some(-*state)\n    /// });\n    ///\n    /// assert_eq!(iter.next(), Some(-1));\n    /// assert_eq!(iter.next(), Some(-2));\n    /// assert_eq!(iter.next(), Some(-6));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>\n        where Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,\n    {\n        Scan { iter: self, f, state: initial_state }\n    }\n\n    /// Creates an iterator that works like map, but flattens nested structure.\n    ///\n    /// The [`map`] adapter is very useful, but only when the closure\n    /// argument produces values. If it produces an iterator instead, there's\n    /// an extra layer of indirection. `flat_map()` will remove this extra layer\n    /// on its own.\n    ///\n    /// You can think of `flat_map(f)` as the semantic equivalent\n    /// of [`map`]ping, and then [`flatten`]ing as in `map(f).flatten()`.\n    ///\n    /// Another way of thinking about `flat_map()`: [`map`]'s closure returns\n    /// one item for each element, and `flat_map()`'s closure returns an\n    /// iterator for each element.\n    ///\n    /// [`map`]: #method.map\n    /// [`flatten`]: #method.flatten\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let words = [\"alpha\", \"beta\", \"gamma\"];\n    ///\n    /// // chars() returns an iterator\n    /// let merged: String = words.iter()\n    ///                           .flat_map(|s| s.chars())\n    ///                           .collect();\n    /// assert_eq!(merged, \"alphabetagamma\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>\n        where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,\n    {\n        FlatMap { inner: flatten_compat(self.map(f)) }\n    }\n\n    /// Creates an iterator that flattens nested structure.\n    ///\n    /// This is useful when you have an iterator of iterators or an iterator of\n    /// things that can be turned into iterators and you want to remove one\n    /// level of indirection.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let data = vec![vec![1, 2, 3, 4], vec![5, 6]];\n    /// let flattened = data.into_iter().flatten().collect::<Vec<u8>>();\n    /// assert_eq!(flattened, &[1, 2, 3, 4, 5, 6]);\n    /// ```\n    ///\n    /// Mapping and then flattening:\n    ///\n    /// ```\n    /// let words = [\"alpha\", \"beta\", \"gamma\"];\n    ///\n    /// // chars() returns an iterator\n    /// let merged: String = words.iter()\n    ///                           .map(|s| s.chars())\n    ///                           .flatten()\n    ///                           .collect();\n    /// assert_eq!(merged, \"alphabetagamma\");\n    /// ```\n    ///\n    /// You can also rewrite this in terms of [`flat_map()`], which is preferable\n    /// in this case since it conveys intent more clearly:\n    ///\n    /// ```\n    /// let words = [\"alpha\", \"beta\", \"gamma\"];\n    ///\n    /// // chars() returns an iterator\n    /// let merged: String = words.iter()\n    ///                           .flat_map(|s| s.chars())\n    ///                           .collect();\n    /// assert_eq!(merged, \"alphabetagamma\");\n    /// ```\n    ///\n    /// Flattening once only removes one level of nesting:\n    ///\n    /// ```\n    /// let d3 = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];\n    ///\n    /// let d2 = d3.iter().flatten().collect::<Vec<_>>();\n    /// assert_eq!(d2, [&[1, 2], &[3, 4], &[5, 6], &[7, 8]]);\n    ///\n    /// let d1 = d3.iter().flatten().flatten().collect::<Vec<_>>();\n    /// assert_eq!(d1, [&1, &2, &3, &4, &5, &6, &7, &8]);\n    /// ```\n    ///\n    /// Here we see that `flatten()` does not perform a \"deep\" flatten.\n    /// Instead, only one level of nesting is removed. That is, if you\n    /// `flatten()` a three-dimensional array the result will be\n    /// two-dimensional and not one-dimensional. To get a one-dimensional\n    /// structure, you have to `flatten()` again.\n    ///\n    /// [`flat_map()`]: #method.flat_map\n    #[inline]\n    #[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\n    fn flatten(self) -> Flatten<Self>\n    where Self: Sized, Self::Item: IntoIterator {\n        Flatten { inner: flatten_compat(self) }\n    }\n\n    /// Creates an iterator which ends after the first [`None`].\n    ///\n    /// After an iterator returns [`None`], future calls may or may not yield\n    /// [`Some(T)`] again. `fuse()` adapts an iterator, ensuring that after a\n    /// [`None`] is given, it will always return [`None`] forever.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`Some(T)`]: ../../std/option/enum.Option.html#variant.Some\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // an iterator which alternates between Some and None\n    /// struct Alternate {\n    ///     state: i32,\n    /// }\n    ///\n    /// impl Iterator for Alternate {\n    ///     type Item = i32;\n    ///\n    ///     fn next(&mut self) -> Option<i32> {\n    ///         let val = self.state;\n    ///         self.state = self.state + 1;\n    ///\n    ///         // if it's even, Some(i32), else None\n    ///         if val % 2 == 0 {\n    ///             Some(val)\n    ///         } else {\n    ///             None\n    ///         }\n    ///     }\n    /// }\n    ///\n    /// let mut iter = Alternate { state: 0 };\n    ///\n    /// // we can see our iterator going back and forth\n    /// assert_eq!(iter.next(), Some(0));\n    /// assert_eq!(iter.next(), None);\n    /// assert_eq!(iter.next(), Some(2));\n    /// assert_eq!(iter.next(), None);\n    ///\n    /// // however, once we fuse it...\n    /// let mut iter = iter.fuse();\n    ///\n    /// assert_eq!(iter.next(), Some(4));\n    /// assert_eq!(iter.next(), None);\n    ///\n    /// // it will always return None after the first time.\n    /// assert_eq!(iter.next(), None);\n    /// assert_eq!(iter.next(), None);\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fuse(self) -> Fuse<Self> where Self: Sized {\n        Fuse{iter: self, done: false}\n    }\n\n    /// Do something with each element of an iterator, passing the value on.\n    ///\n    /// When using iterators, you'll often chain several of them together.\n    /// While working on such code, you might want to check out what's\n    /// happening at various parts in the pipeline. To do that, insert\n    /// a call to `inspect()`.\n    ///\n    /// It's more common for `inspect()` to be used as a debugging tool than to\n    /// exist in your final code, but applications may find it useful in certain\n    /// situations when errors need to be logged before being discarded.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 4, 2, 3];\n    ///\n    /// // this iterator sequence is complex.\n    /// let sum = a.iter()\n    ///     .cloned()\n    ///     .filter(|x| x % 2 == 0)\n    ///     .fold(0, |sum, i| sum + i);\n    ///\n    /// println!(\"{}\", sum);\n    ///\n    /// // let's add some inspect() calls to investigate what's happening\n    /// let sum = a.iter()\n    ///     .cloned()\n    ///     .inspect(|x| println!(\"about to filter: {}\", x))\n    ///     .filter(|x| x % 2 == 0)\n    ///     .inspect(|x| println!(\"made it through filter: {}\", x))\n    ///     .fold(0, |sum, i| sum + i);\n    ///\n    /// println!(\"{}\", sum);\n    /// ```\n    ///\n    /// This will print:\n    ///\n    /// ```text\n    /// 6\n    /// about to filter: 1\n    /// about to filter: 4\n    /// made it through filter: 4\n    /// about to filter: 2\n    /// made it through filter: 2\n    /// about to filter: 3\n    /// 6\n    /// ```\n    ///\n    /// Logging errors before discarding them:\n    ///\n    /// ```\n    /// let lines = [\"1\", \"2\", \"a\"];\n    ///\n    /// let sum: i32 = lines\n    ///     .iter()\n    ///     .map(|line| line.parse::<i32>())\n    ///     .inspect(|num| {\n    ///         if let Err(ref e) = *num {\n    ///             println!(\"Parsing error: {}\", e);\n    ///         }\n    ///     })\n    ///     .filter_map(Result::ok)\n    ///     .sum();\n    ///\n    /// println!(\"Sum: {}\", sum);\n    /// ```\n    ///\n    /// This will print:\n    ///\n    /// ```text\n    /// Parsing error: invalid digit found in string\n    /// Sum: 3\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn inspect<F>(self, f: F) -> Inspect<Self, F> where\n        Self: Sized, F: FnMut(&Self::Item),\n    {\n        Inspect { iter: self, f }\n    }\n\n    /// Borrows an iterator, rather than consuming it.\n    ///\n    /// This is useful to allow applying iterator adaptors while still\n    /// retaining ownership of the original iterator.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let iter = a.into_iter();\n    ///\n    /// let sum: i32 = iter.take(5).fold(0, |acc, i| acc + i );\n    ///\n    /// assert_eq!(sum, 6);\n    ///\n    /// // if we try to use iter again, it won't work. The following line\n    /// // gives \"error: use of moved value: `iter`\n    /// // assert_eq!(iter.next(), None);\n    ///\n    /// // let's try that again\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.into_iter();\n    ///\n    /// // instead, we add in a .by_ref()\n    /// let sum: i32 = iter.by_ref().take(2).fold(0, |acc, i| acc + i );\n    ///\n    /// assert_eq!(sum, 3);\n    ///\n    /// // now this is just fine:\n    /// assert_eq!(iter.next(), Some(&3));\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }\n\n    /// Transforms an iterator into a collection.\n    ///\n    /// `collect()` can take anything iterable, and turn it into a relevant\n    /// collection. This is one of the more powerful methods in the standard\n    /// library, used in a variety of contexts.\n    ///\n    /// The most basic pattern in which `collect()` is used is to turn one\n    /// collection into another. You take a collection, call [`iter`] on it,\n    /// do a bunch of transformations, and then `collect()` at the end.\n    ///\n    /// One of the keys to `collect()`'s power is that many things you might\n    /// not think of as 'collections' actually are. For example, a [`String`]\n    /// is a collection of [`char`]s. And a collection of\n    /// [`Result<T, E>`][`Result`] can be thought of as single\n    /// [`Result`]`<Collection<T>, E>`. See the examples below for more.\n    ///\n    /// Because `collect()` is so general, it can cause problems with type\n    /// inference. As such, `collect()` is one of the few times you'll see\n    /// the syntax affectionately known as the 'turbofish': `::<>`. This\n    /// helps the inference algorithm understand specifically which collection\n    /// you're trying to collect into.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let doubled: Vec<i32> = a.iter()\n    ///                          .map(|&x| x * 2)\n    ///                          .collect();\n    ///\n    /// assert_eq!(vec![2, 4, 6], doubled);\n    /// ```\n    ///\n    /// Note that we needed the `: Vec<i32>` on the left-hand side. This is because\n    /// we could collect into, for example, a [`VecDeque<T>`] instead:\n    ///\n    /// [`VecDeque<T>`]: ../../std/collections/struct.VecDeque.html\n    ///\n    /// ```\n    /// use std::collections::VecDeque;\n    ///\n    /// let a = [1, 2, 3];\n    ///\n    /// let doubled: VecDeque<i32> = a.iter().map(|&x| x * 2).collect();\n    ///\n    /// assert_eq!(2, doubled[0]);\n    /// assert_eq!(4, doubled[1]);\n    /// assert_eq!(6, doubled[2]);\n    /// ```\n    ///\n    /// Using the 'turbofish' instead of annotating `doubled`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let doubled = a.iter().map(|x| x * 2).collect::<Vec<i32>>();\n    ///\n    /// assert_eq!(vec![2, 4, 6], doubled);\n    /// ```\n    ///\n    /// Because `collect()` only cares about what you're collecting into, you can\n    /// still use a partial type hint, `_`, with the turbofish:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let doubled = a.iter().map(|x| x * 2).collect::<Vec<_>>();\n    ///\n    /// assert_eq!(vec![2, 4, 6], doubled);\n    /// ```\n    ///\n    /// Using `collect()` to make a [`String`]:\n    ///\n    /// ```\n    /// let chars = ['g', 'd', 'k', 'k', 'n'];\n    ///\n    /// let hello: String = chars.iter()\n    ///     .map(|&x| x as u8)\n    ///     .map(|x| (x + 1) as char)\n    ///     .collect();\n    ///\n    /// assert_eq!(\"hello\", hello);\n    /// ```\n    ///\n    /// If you have a list of [`Result<T, E>`][`Result`]s, you can use `collect()` to\n    /// see if any of them failed:\n    ///\n    /// ```\n    /// let results = [Ok(1), Err(\"nope\"), Ok(3), Err(\"bad\")];\n    ///\n    /// let result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n    ///\n    /// // gives us the first error\n    /// assert_eq!(Err(\"nope\"), result);\n    ///\n    /// let results = [Ok(1), Ok(3)];\n    ///\n    /// let result: Result<Vec<_>, &str> = results.iter().cloned().collect();\n    ///\n    /// // gives us the list of answers\n    /// assert_eq!(Ok(vec![1, 3]), result);\n    /// ```\n    ///\n    /// [`iter`]: ../../std/iter/trait.Iterator.html#tymethod.next\n    /// [`String`]: ../../std/string/struct.String.html\n    /// [`char`]: ../../std/primitive.char.html\n    /// [`Result`]: ../../std/result/enum.Result.html\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[must_use = \"if you really need to exhaust the iterator, consider `.for_each(drop)` instead\"]\n    fn collect<B: FromIterator<Self::Item>>(self) -> B where Self: Sized {\n        FromIterator::from_iter(self)\n    }\n\n    /// Consumes an iterator, creating two collections from it.\n    ///\n    /// The predicate passed to `partition()` can return `true`, or `false`.\n    /// `partition()` returns a pair, all of the elements for which it returned\n    /// `true`, and all of the elements for which it returned `false`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let (even, odd): (Vec<i32>, Vec<i32>) = a\n    ///     .into_iter()\n    ///     .partition(|&n| n % 2 == 0);\n    ///\n    /// assert_eq!(even, vec![2]);\n    /// assert_eq!(odd, vec![1, 3]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn partition<B, F>(self, mut f: F) -> (B, B) where\n        Self: Sized,\n        B: Default + Extend<Self::Item>,\n        F: FnMut(&Self::Item) -> bool\n    {\n        let mut left: B = Default::default();\n        let mut right: B = Default::default();\n\n        for x in self {\n            if f(&x) {\n                left.extend(Some(x))\n            } else {\n                right.extend(Some(x))\n            }\n        }\n\n        (left, right)\n    }\n\n    /// An iterator method that applies a function as long as it returns\n    /// successfully, producing a single, final value.\n    ///\n    /// `try_fold()` takes two arguments: an initial value, and a closure with\n    /// two arguments: an 'accumulator', and an element. The closure either\n    /// returns successfully, with the value that the accumulator should have\n    /// for the next iteration, or it returns failure, with an error value that\n    /// is propagated back to the caller immediately (short-circuiting).\n    ///\n    /// The initial value is the value the accumulator will have on the first\n    /// call.  If applying the closure succeeded against every element of the\n    /// iterator, `try_fold()` returns the final accumulator as success.\n    ///\n    /// Folding is useful whenever you have a collection of something, and want\n    /// to produce a single value from it.\n    ///\n    /// # Note to Implementors\n    ///\n    /// Most of the other (forward) methods have default implementations in\n    /// terms of this one, so try to implement this explicitly if it can\n    /// do something better than the default `for` loop implementation.\n    ///\n    /// In particular, try to have this call `try_fold()` on the internal parts\n    /// from which this iterator is composed.  If multiple calls are needed,\n    /// the `?` operator may be convenient for chaining the accumulator value\n    /// along, but beware any invariants that need to be upheld before those\n    /// early returns.  This is a `&mut self` method, so iteration needs to be\n    /// resumable after hitting an error here.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// // the checked sum of all of the elements of the array\n    /// let sum = a.iter().try_fold(0i8, |acc, &x| acc.checked_add(x));\n    ///\n    /// assert_eq!(sum, Some(6));\n    /// ```\n    ///\n    /// Short-circuiting:\n    ///\n    /// ```\n    /// let a = [10, 20, 30, 100, 40, 50];\n    /// let mut it = a.iter();\n    ///\n    /// // This sum overflows when adding the 100 element\n    /// let sum = it.try_fold(0i8, |acc, &x| acc.checked_add(x));\n    /// assert_eq!(sum, None);\n    ///\n    /// // Because it short-circuited, the remaining elements are still\n    /// // available through the iterator.\n    /// assert_eq!(it.len(), 2);\n    /// assert_eq!(it.next(), Some(&40));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_try_fold\", since = \"1.27.0\")]\n    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        let mut accum = init;\n        while let Some(x) = self.next() {\n            accum = f(accum, x)?;\n        }\n        Try::from_ok(accum)\n    }\n\n    /// An iterator method that applies a fallible function to each item in the\n    /// iterator, stopping at the first error and returning that error.\n    ///\n    /// This can also be thought of as the fallible form of [`for_each()`]\n    /// or as the stateless version of [`try_fold()`].\n    ///\n    /// [`for_each()`]: #method.for_each\n    /// [`try_fold()`]: #method.try_fold\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs::rename;\n    /// use std::io::{stdout, Write};\n    /// use std::path::Path;\n    ///\n    /// let data = [\"no_tea.txt\", \"stale_bread.json\", \"torrential_rain.png\"];\n    ///\n    /// let res = data.iter().try_for_each(|x| writeln!(stdout(), \"{}\", x));\n    /// assert!(res.is_ok());\n    ///\n    /// let mut it = data.iter().cloned();\n    /// let res = it.try_for_each(|x| rename(x, Path::new(x).with_extension(\"old\")));\n    /// assert!(res.is_err());\n    /// // It short-circuited, so the remaining items are still in the iterator:\n    /// assert_eq!(it.next(), Some(\"stale_bread.json\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_try_fold\", since = \"1.27.0\")]\n    fn try_for_each<F, R>(&mut self, mut f: F) -> R where\n        Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Ok=()>\n    {\n        self.try_fold((), move |(), x| f(x))\n    }\n\n    /// An iterator method that applies a function, producing a single, final value.\n    ///\n    /// `fold()` takes two arguments: an initial value, and a closure with two\n    /// arguments: an 'accumulator', and an element. The closure returns the value that\n    /// the accumulator should have for the next iteration.\n    ///\n    /// The initial value is the value the accumulator will have on the first\n    /// call.\n    ///\n    /// After applying this closure to every element of the iterator, `fold()`\n    /// returns the accumulator.\n    ///\n    /// This operation is sometimes called 'reduce' or 'inject'.\n    ///\n    /// Folding is useful whenever you have a collection of something, and want\n    /// to produce a single value from it.\n    ///\n    /// Note: `fold()`, and similar methods that traverse the entire iterator,\n    /// may not terminate for infinite iterators, even on traits for which a\n    /// result is determinable in finite time.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// // the sum of all of the elements of the array\n    /// let sum = a.iter().fold(0, |acc, x| acc + x);\n    ///\n    /// assert_eq!(sum, 6);\n    /// ```\n    ///\n    /// Let's walk through each step of the iteration here:\n    ///\n    /// | element | acc | x | result |\n    /// |---------|-----|---|--------|\n    /// |         | 0   |   |        |\n    /// | 1       | 0   | 1 | 1      |\n    /// | 2       | 1   | 2 | 3      |\n    /// | 3       | 3   | 3 | 6      |\n    ///\n    /// And so, our final result, `6`.\n    ///\n    /// It's common for people who haven't used iterators a lot to\n    /// use a `for` loop with a list of things to build up a result. Those\n    /// can be turned into `fold()`s:\n    ///\n    /// [`for`]: ../../book/first-edition/loops.html#for\n    ///\n    /// ```\n    /// let numbers = [1, 2, 3, 4, 5];\n    ///\n    /// let mut result = 0;\n    ///\n    /// // for loop:\n    /// for i in &numbers {\n    ///     result = result + i;\n    /// }\n    ///\n    /// // fold:\n    /// let result2 = numbers.iter().fold(0, |acc, &x| acc + x);\n    ///\n    /// // they're the same\n    /// assert_eq!(result, result2);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fold<B, F>(mut self, init: B, mut f: F) -> B where\n        Self: Sized, F: FnMut(B, Self::Item) -> B,\n    {\n        self.try_fold(init, move |acc, x| Ok::<B, !>(f(acc, x))).unwrap()\n    }\n\n    /// Tests if every element of the iterator matches a predicate.\n    ///\n    /// `all()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, and if they all return\n    /// `true`, then so does `all()`. If any of them return `false`, it\n    /// returns `false`.\n    ///\n    /// `all()` is short-circuiting; in other words, it will stop processing\n    /// as soon as it finds a `false`, given that no matter what else happens,\n    /// the result will also be `false`.\n    ///\n    /// An empty iterator returns `true`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert!(a.iter().all(|&x| x > 0));\n    ///\n    /// assert!(!a.iter().all(|&x| x > 2));\n    /// ```\n    ///\n    /// Stopping at the first `false`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert!(!iter.all(|&x| x != 2));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next(), Some(&3));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn all<F>(&mut self, mut f: F) -> bool where\n        Self: Sized, F: FnMut(Self::Item) -> bool\n    {\n        self.try_for_each(move |x| {\n            if f(x) { LoopState::Continue(()) }\n            else { LoopState::Break(()) }\n        }) == LoopState::Continue(())\n    }\n\n    /// Tests if any element of the iterator matches a predicate.\n    ///\n    /// `any()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, and if any of them return\n    /// `true`, then so does `any()`. If they all return `false`, it\n    /// returns `false`.\n    ///\n    /// `any()` is short-circuiting; in other words, it will stop processing\n    /// as soon as it finds a `true`, given that no matter what else happens,\n    /// the result will also be `true`.\n    ///\n    /// An empty iterator returns `false`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert!(a.iter().any(|&x| x > 0));\n    ///\n    /// assert!(!a.iter().any(|&x| x > 5));\n    /// ```\n    ///\n    /// Stopping at the first `true`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert!(iter.any(|&x| x != 2));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next(), Some(&2));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn any<F>(&mut self, mut f: F) -> bool where\n        Self: Sized,\n        F: FnMut(Self::Item) -> bool\n    {\n        self.try_for_each(move |x| {\n            if f(x) { LoopState::Break(()) }\n            else { LoopState::Continue(()) }\n        }) == LoopState::Break(())\n    }\n\n    /// Searches for an element of an iterator that satisfies a predicate.\n    ///\n    /// `find()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, and if any of them return\n    /// `true`, then `find()` returns [`Some(element)`]. If they all return\n    /// `false`, it returns [`None`].\n    ///\n    /// `find()` is short-circuiting; in other words, it will stop processing\n    /// as soon as the closure returns `true`.\n    ///\n    /// Because `find()` takes a reference, and many iterators iterate over\n    /// references, this leads to a possibly confusing situation where the\n    /// argument is a double reference. You can see this effect in the\n    /// examples below, with `&&x`.\n    ///\n    /// [`Some(element)`]: ../../std/option/enum.Option.html#variant.Some\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert_eq!(a.iter().find(|&&x| x == 2), Some(&2));\n    ///\n    /// assert_eq!(a.iter().find(|&&x| x == 5), None);\n    /// ```\n    ///\n    /// Stopping at the first `true`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert_eq!(iter.find(|&&x| x == 2), Some(&2));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next(), Some(&3));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where\n        Self: Sized,\n        P: FnMut(&Self::Item) -> bool,\n    {\n        self.try_for_each(move |x| {\n            if predicate(&x) { LoopState::Break(x) }\n            else { LoopState::Continue(()) }\n        }).break_value()\n    }\n\n    /// Applies function to the elements of iterator and returns\n    /// the first non-none result.\n    ///\n    /// `iter.find_map(f)` is equivalent to `iter.filter_map(f).next()`.\n    ///\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [\"lol\", \"NaN\", \"2\", \"5\"];\n    ///\n    /// let first_number = a.iter().find_map(|s| s.parse().ok());\n    ///\n    /// assert_eq!(first_number, Some(2));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_find_map\", since = \"1.30.0\")]\n    fn find_map<B, F>(&mut self, mut f: F) -> Option<B> where\n        Self: Sized,\n        F: FnMut(Self::Item) -> Option<B>,\n    {\n        self.try_for_each(move |x| {\n            match f(x) {\n                Some(x) => LoopState::Break(x),\n                None => LoopState::Continue(()),\n            }\n        }).break_value()\n    }\n\n    /// Searches for an element in an iterator, returning its index.\n    ///\n    /// `position()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, and if one of them\n    /// returns `true`, then `position()` returns [`Some(index)`]. If all of\n    /// them return `false`, it returns [`None`].\n    ///\n    /// `position()` is short-circuiting; in other words, it will stop\n    /// processing as soon as it finds a `true`.\n    ///\n    /// # Overflow Behavior\n    ///\n    /// The method does no guarding against overflows, so if there are more\n    /// than [`usize::MAX`] non-matching elements, it either produces the wrong\n    /// result or panics. If debug assertions are enabled, a panic is\n    /// guaranteed.\n    ///\n    /// # Panics\n    ///\n    /// This function might panic if the iterator has more than `usize::MAX`\n    /// non-matching elements.\n    ///\n    /// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`usize::MAX`]: ../../std/usize/constant.MAX.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert_eq!(a.iter().position(|&x| x == 2), Some(1));\n    ///\n    /// assert_eq!(a.iter().position(|&x| x == 5), None);\n    /// ```\n    ///\n    /// Stopping at the first `true`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3, 4];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert_eq!(iter.position(|&x| x >= 2), Some(1));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next(), Some(&3));\n    ///\n    /// // The returned index depends on iterator state\n    /// assert_eq!(iter.position(|&x| x == 4), Some(0));\n    ///\n    /// ```\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn position<P>(&mut self, mut predicate: P) -> Option<usize> where\n        Self: Sized,\n        P: FnMut(Self::Item) -> bool,\n    {\n        // The addition might panic on overflow\n        self.try_fold(0, move |i, x| {\n            if predicate(x) { LoopState::Break(i) }\n            else { LoopState::Continue(i + 1) }\n        }).break_value()\n    }\n\n    /// Searches for an element in an iterator from the right, returning its\n    /// index.\n    ///\n    /// `rposition()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, starting from the end,\n    /// and if one of them returns `true`, then `rposition()` returns\n    /// [`Some(index)`]. If all of them return `false`, it returns [`None`].\n    ///\n    /// `rposition()` is short-circuiting; in other words, it will stop\n    /// processing as soon as it finds a `true`.\n    ///\n    /// [`Some(index)`]: ../../std/option/enum.Option.html#variant.Some\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert_eq!(a.iter().rposition(|&x| x == 3), Some(2));\n    ///\n    /// assert_eq!(a.iter().rposition(|&x| x == 5), None);\n    /// ```\n    ///\n    /// Stopping at the first `true`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert_eq!(iter.rposition(|&x| x == 2), Some(1));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next(), Some(&1));\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn rposition<P>(&mut self, mut predicate: P) -> Option<usize> where\n        P: FnMut(Self::Item) -> bool,\n        Self: Sized + ExactSizeIterator + DoubleEndedIterator\n    {\n        // No need for an overflow check here, because `ExactSizeIterator`\n        // implies that the number of elements fits into a `usize`.\n        let n = self.len();\n        self.try_rfold(n, move |i, x| {\n            let i = i - 1;\n            if predicate(x) { LoopState::Break(i) }\n            else { LoopState::Continue(i) }\n        }).break_value()\n    }\n\n    /// Returns the maximum element of an iterator.\n    ///\n    /// If several elements are equally maximum, the last element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// let b: Vec<u32> = Vec::new();\n    ///\n    /// assert_eq!(a.iter().max(), Some(&3));\n    /// assert_eq!(b.iter().max(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn max(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord\n    {\n        select_fold1(self,\n                     |_| (),\n                     // switch to y even if it is only equal, to preserve\n                     // stability.\n                     |_, x, _, y| *x <= *y)\n            .map(|(_, x)| x)\n    }\n\n    /// Returns the minimum element of an iterator.\n    ///\n    /// If several elements are equally minimum, the first element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// let b: Vec<u32> = Vec::new();\n    ///\n    /// assert_eq!(a.iter().min(), Some(&1));\n    /// assert_eq!(b.iter().min(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn min(self) -> Option<Self::Item> where Self: Sized, Self::Item: Ord\n    {\n        select_fold1(self,\n                     |_| (),\n                     // only switch to y if it is strictly smaller, to\n                     // preserve stability.\n                     |_, x, _, y| *x > *y)\n            .map(|(_, x)| x)\n    }\n\n    /// Returns the element that gives the maximum value from the\n    /// specified function.\n    ///\n    /// If several elements are equally maximum, the last element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [-3_i32, 0, 1, 5, -10];\n    /// assert_eq!(*a.iter().max_by_key(|x| x.abs()).unwrap(), -10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"iter_cmp_by_key\", since = \"1.6.0\")]\n    fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>\n        where Self: Sized, F: FnMut(&Self::Item) -> B,\n    {\n        select_fold1(self,\n                     f,\n                     // switch to y even if it is only equal, to preserve\n                     // stability.\n                     |x_p, _, y_p, _| x_p <= y_p)\n            .map(|(_, x)| x)\n    }\n\n    /// Returns the element that gives the maximum value with respect to the\n    /// specified comparison function.\n    ///\n    /// If several elements are equally maximum, the last element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [-3_i32, 0, 1, 5, -10];\n    /// assert_eq!(*a.iter().max_by(|x, y| x.cmp(y)).unwrap(), 5);\n    /// ```\n    #[inline]\n    #[stable(feature = \"iter_max_by\", since = \"1.15.0\")]\n    fn max_by<F>(self, mut compare: F) -> Option<Self::Item>\n        where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,\n    {\n        select_fold1(self,\n                     |_| (),\n                     // switch to y even if it is only equal, to preserve\n                     // stability.\n                     |_, x, _, y| Ordering::Greater != compare(x, y))\n            .map(|(_, x)| x)\n    }\n\n    /// Returns the element that gives the minimum value from the\n    /// specified function.\n    ///\n    /// If several elements are equally minimum, the first element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [-3_i32, 0, 1, 5, -10];\n    /// assert_eq!(*a.iter().min_by_key(|x| x.abs()).unwrap(), 0);\n    /// ```\n    #[stable(feature = \"iter_cmp_by_key\", since = \"1.6.0\")]\n    fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>\n        where Self: Sized, F: FnMut(&Self::Item) -> B,\n    {\n        select_fold1(self,\n                     f,\n                     // only switch to y if it is strictly smaller, to\n                     // preserve stability.\n                     |x_p, _, y_p, _| x_p > y_p)\n            .map(|(_, x)| x)\n    }\n\n    /// Returns the element that gives the minimum value with respect to the\n    /// specified comparison function.\n    ///\n    /// If several elements are equally minimum, the first element is\n    /// returned. If the iterator is empty, [`None`] is returned.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [-3_i32, 0, 1, 5, -10];\n    /// assert_eq!(*a.iter().min_by(|x, y| x.cmp(y)).unwrap(), -10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"iter_min_by\", since = \"1.15.0\")]\n    fn min_by<F>(self, mut compare: F) -> Option<Self::Item>\n        where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,\n    {\n        select_fold1(self,\n                     |_| (),\n                     // switch to y even if it is strictly smaller, to\n                     // preserve stability.\n                     |_, x, _, y| Ordering::Greater == compare(x, y))\n            .map(|(_, x)| x)\n    }\n\n\n    /// Reverses an iterator's direction.\n    ///\n    /// Usually, iterators iterate from left to right. After using `rev()`,\n    /// an iterator will instead iterate from right to left.\n    ///\n    /// This is only possible if the iterator has an end, so `rev()` only\n    /// works on [`DoubleEndedIterator`]s.\n    ///\n    /// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter().rev();\n    ///\n    /// assert_eq!(iter.next(), Some(&3));\n    /// assert_eq!(iter.next(), Some(&2));\n    /// assert_eq!(iter.next(), Some(&1));\n    ///\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn rev(self) -> Rev<Self> where Self: Sized + DoubleEndedIterator {\n        Rev{iter: self}\n    }\n\n    /// Converts an iterator of pairs into a pair of containers.\n    ///\n    /// `unzip()` consumes an entire iterator of pairs, producing two\n    /// collections: one from the left elements of the pairs, and one\n    /// from the right elements.\n    ///\n    /// This function is, in some sense, the opposite of [`zip`].\n    ///\n    /// [`zip`]: #method.zip\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [(1, 2), (3, 4)];\n    ///\n    /// let (left, right): (Vec<_>, Vec<_>) = a.iter().cloned().unzip();\n    ///\n    /// assert_eq!(left, [1, 3]);\n    /// assert_eq!(right, [2, 4]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where\n        FromA: Default + Extend<A>,\n        FromB: Default + Extend<B>,\n        Self: Sized + Iterator<Item=(A, B)>,\n    {\n        let mut ts: FromA = Default::default();\n        let mut us: FromB = Default::default();\n\n        self.for_each(|(t, u)| {\n            ts.extend(Some(t));\n            us.extend(Some(u));\n        });\n\n        (ts, us)\n    }\n\n    /// Creates an iterator which [`clone`]s all of its elements.\n    ///\n    /// This is useful when you have an iterator over `&T`, but you need an\n    /// iterator over `T`.\n    ///\n    /// [`clone`]: ../../std/clone/trait.Clone.html#tymethod.clone\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let v_cloned: Vec<_> = a.iter().cloned().collect();\n    ///\n    /// // cloned is the same as .map(|&x| x), for integers\n    /// let v_map: Vec<_> = a.iter().map(|&x| x).collect();\n    ///\n    /// assert_eq!(v_cloned, vec![1, 2, 3]);\n    /// assert_eq!(v_map, vec![1, 2, 3]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn cloned<'a, T: 'a>(self) -> Cloned<Self>\n        where Self: Sized + Iterator<Item=&'a T>, T: Clone\n    {\n        Cloned { it: self }\n    }\n\n    /// Repeats an iterator endlessly.\n    ///\n    /// Instead of stopping at [`None`], the iterator will instead start again,\n    /// from the beginning. After iterating again, it will start at the\n    /// beginning again. And again. And again. Forever.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut it = a.iter().cycle();\n    ///\n    /// assert_eq!(it.next(), Some(&1));\n    /// assert_eq!(it.next(), Some(&2));\n    /// assert_eq!(it.next(), Some(&3));\n    /// assert_eq!(it.next(), Some(&1));\n    /// assert_eq!(it.next(), Some(&2));\n    /// assert_eq!(it.next(), Some(&3));\n    /// assert_eq!(it.next(), Some(&1));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    fn cycle(self) -> Cycle<Self> where Self: Sized + Clone {\n        Cycle{orig: self.clone(), iter: self}\n    }\n\n    /// Sums the elements of an iterator.\n    ///\n    /// Takes each element, adds them together, and returns the result.\n    ///\n    /// An empty iterator returns the zero value of the type.\n    ///\n    /// # Panics\n    ///\n    /// When calling `sum()` and a primitive integer type is being returned, this\n    /// method will panic if the computation overflows and debug assertions are\n    /// enabled.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    /// let sum: i32 = a.iter().sum();\n    ///\n    /// assert_eq!(sum, 6);\n    /// ```\n    #[stable(feature = \"iter_arith\", since = \"1.11.0\")]\n    fn sum<S>(self) -> S\n        where Self: Sized,\n              S: Sum<Self::Item>,\n    {\n        Sum::sum(self)\n    }\n\n    /// Iterates over the entire iterator, multiplying all the elements\n    ///\n    /// An empty iterator returns the one value of the type.\n    ///\n    /// # Panics\n    ///\n    /// When calling `product()` and a primitive integer type is being returned,\n    /// method will panic if the computation overflows and debug assertions are\n    /// enabled.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// fn factorial(n: u32) -> u32 {\n    ///     (1..).take_while(|&i| i <= n).product()\n    /// }\n    /// assert_eq!(factorial(0), 1);\n    /// assert_eq!(factorial(1), 1);\n    /// assert_eq!(factorial(5), 120);\n    /// ```\n    #[stable(feature = \"iter_arith\", since = \"1.11.0\")]\n    fn product<P>(self) -> P\n        where Self: Sized,\n              P: Product<Self::Item>,\n    {\n        Product::product(self)\n    }\n\n    /// Lexicographically compares the elements of this `Iterator` with those\n    /// of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn cmp<I>(mut self, other: I) -> Ordering where\n        I: IntoIterator<Item = Self::Item>,\n        Self::Item: Ord,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => if other.next().is_none() {\n                    return Ordering::Equal\n                } else {\n                    return Ordering::Less\n                },\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return Ordering::Greater,\n                Some(val) => val,\n            };\n\n            match x.cmp(&y) {\n                Ordering::Equal => (),\n                non_eq => return non_eq,\n            }\n        }\n    }\n\n    /// Lexicographically compares the elements of this `Iterator` with those\n    /// of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn partial_cmp<I>(mut self, other: I) -> Option<Ordering> where\n        I: IntoIterator,\n        Self::Item: PartialOrd<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => if other.next().is_none() {\n                    return Some(Ordering::Equal)\n                } else {\n                    return Some(Ordering::Less)\n                },\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return Some(Ordering::Greater),\n                Some(val) => val,\n            };\n\n            match x.partial_cmp(&y) {\n                Some(Ordering::Equal) => (),\n                non_eq => return non_eq,\n            }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are equal to those of\n    /// another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn eq<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialEq<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => return other.next().is_none(),\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return false,\n                Some(val) => val,\n            };\n\n            if x != y { return false }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are unequal to those of\n    /// another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn ne<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialEq<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => return other.next().is_some(),\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return true,\n                Some(val) => val,\n            };\n\n            if x != y { return true }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are lexicographically\n    /// less than those of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn lt<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialOrd<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => return other.next().is_some(),\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return false,\n                Some(val) => val,\n            };\n\n            match x.partial_cmp(&y) {\n                Some(Ordering::Less) => return true,\n                Some(Ordering::Equal) => (),\n                Some(Ordering::Greater) => return false,\n                None => return false,\n            }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are lexicographically\n    /// less or equal to those of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn le<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialOrd<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => { other.next(); return true; },\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return false,\n                Some(val) => val,\n            };\n\n            match x.partial_cmp(&y) {\n                Some(Ordering::Less) => return true,\n                Some(Ordering::Equal) => (),\n                Some(Ordering::Greater) => return false,\n                None => return false,\n            }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are lexicographically\n    /// greater than those of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn gt<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialOrd<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => { other.next(); return false; },\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return true,\n                Some(val) => val,\n            };\n\n            match x.partial_cmp(&y) {\n                Some(Ordering::Less) => return false,\n                Some(Ordering::Equal) => (),\n                Some(Ordering::Greater) => return true,\n                None => return false,\n            }\n        }\n    }\n\n    /// Determines if the elements of this `Iterator` are lexicographically\n    /// greater than or equal to those of another.\n    #[stable(feature = \"iter_order\", since = \"1.5.0\")]\n    fn ge<I>(mut self, other: I) -> bool where\n        I: IntoIterator,\n        Self::Item: PartialOrd<I::Item>,\n        Self: Sized,\n    {\n        let mut other = other.into_iter();\n\n        loop {\n            let x = match self.next() {\n                None => return other.next().is_none(),\n                Some(val) => val,\n            };\n\n            let y = match other.next() {\n                None => return true,\n                Some(val) => val,\n            };\n\n            match x.partial_cmp(&y) {\n                Some(Ordering::Less) => return false,\n                Some(Ordering::Equal) => (),\n                Some(Ordering::Greater) => return true,\n                None => return false,\n            }\n        }\n    }\n}\n\n/// Select an element from an iterator based on the given \"projection\"\n/// and \"comparison\" function.\n///\n/// This is an idiosyncratic helper to try to factor out the\n/// commonalities of {max,min}{,_by}. In particular, this avoids\n/// having to implement optimizations several times.\n#[inline]\nfn select_fold1<I, B, FProj, FCmp>(mut it: I,\n                                   mut f_proj: FProj,\n                                   mut f_cmp: FCmp) -> Option<(B, I::Item)>\n    where I: Iterator,\n          FProj: FnMut(&I::Item) -> B,\n          FCmp: FnMut(&B, &I::Item, &B, &I::Item) -> bool\n{\n    // start with the first element as our selection. This avoids\n    // having to use `Option`s inside the loop, translating to a\n    // sizeable performance gain (6x in one case).\n    it.next().map(|first| {\n        let first_p = f_proj(&first);\n\n        it.fold((first_p, first), |(sel_p, sel), x| {\n            let x_p = f_proj(&x);\n            if f_cmp(&sel_p, &sel, &x_p, &x) {\n                (x_p, x)\n            } else {\n                (sel_p, sel)\n            }\n        })\n    })\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator + ?Sized> Iterator for &mut I {\n    type Item = I::Item;\n    fn next(&mut self) -> Option<I::Item> { (**self).next() }\n    fn size_hint(&self) -> (usize, Option<usize>) { (**self).size_hint() }\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        (**self).nth(n)\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Integer and floating-point number formatting\n\n#![allow(deprecated)]\n\n\nuse fmt;\nuse ops::{Div, Rem, Sub};\nuse str;\nuse slice;\nuse ptr;\nuse mem;\n\n#[doc(hidden)]\ntrait Int: PartialEq + PartialOrd + Div<Output=Self> + Rem<Output=Self> +\n           Sub<Output=Self> + Copy {\n    fn zero() -> Self;\n    fn from_u8(u: u8) -> Self;\n    fn to_u8(&self) -> u8;\n    fn to_u16(&self) -> u16;\n    fn to_u32(&self) -> u32;\n    fn to_u64(&self) -> u64;\n    fn to_u128(&self) -> u128;\n}\n\nmacro_rules! doit {\n    ($($t:ident)*) => ($(impl Int for $t {\n        fn zero() -> $t { 0 }\n        fn from_u8(u: u8) -> $t { u as $t }\n        fn to_u8(&self) -> u8 { *self as u8 }\n        fn to_u16(&self) -> u16 { *self as u16 }\n        fn to_u32(&self) -> u32 { *self as u32 }\n        fn to_u64(&self) -> u64 { *self as u64 }\n        fn to_u128(&self) -> u128 { *self as u128 }\n    })*)\n}\ndoit! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }\n\n/// A type that represents a specific radix\n#[doc(hidden)]\ntrait GenericRadix {\n    /// The number of digits.\n    const BASE: u8;\n\n    /// A radix-specific prefix string.\n    const PREFIX: &'static str;\n\n    /// Converts an integer to corresponding radix digit.\n    fn digit(x: u8) -> u8;\n\n    /// Format an integer using the radix using a formatter.\n    fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {\n        // The radix can be as low as 2, so we need a buffer of at least 128\n        // characters for a base 2 number.\n        let zero = T::zero();\n        let is_nonnegative = x >= zero;\n        let mut buf: [u8; 128] = unsafe { mem::uninitialized() };\n        let mut curr = buf.len();\n        let base = T::from_u8(Self::BASE);\n        if is_nonnegative {\n            // Accumulate each digit of the number from the least significant\n            // to the most significant figure.\n            for byte in buf.iter_mut().rev() {\n                let n = x % base;               // Get the current place value.\n                x = x / base;                   // Deaccumulate the number.\n                *byte = Self::digit(n.to_u8()); // Store the digit in the buffer.\n                curr -= 1;\n                if x == zero {\n                    // No more digits left to accumulate.\n                    break\n                };\n            }\n        } else {\n            // Do the same as above, but accounting for two's complement.\n            for byte in buf.iter_mut().rev() {\n                let n = zero - (x % base);      // Get the current place value.\n                x = x / base;                   // Deaccumulate the number.\n                *byte = Self::digit(n.to_u8()); // Store the digit in the buffer.\n                curr -= 1;\n                if x == zero {\n                    // No more digits left to accumulate.\n                    break\n                };\n            }\n        }\n        let buf = unsafe { str::from_utf8_unchecked(&buf[curr..]) };\n        f.pad_integral(is_nonnegative, Self::PREFIX, buf)\n    }\n}\n\n/// A binary (base 2) radix\n#[derive(Clone, PartialEq)]\nstruct Binary;\n\n/// An octal (base 8) radix\n#[derive(Clone, PartialEq)]\nstruct Octal;\n\n/// A hexadecimal (base 16) radix, formatted with lower-case characters\n#[derive(Clone, PartialEq)]\nstruct LowerHex;\n\n/// A hexadecimal (base 16) radix, formatted with upper-case characters\n#[derive(Clone, PartialEq)]\nstruct UpperHex;\n\nmacro_rules! radix {\n    ($T:ident, $base:expr, $prefix:expr, $($x:pat => $conv:expr),+) => {\n        impl GenericRadix for $T {\n            const BASE: u8 = $base;\n            const PREFIX: &'static str = $prefix;\n            fn digit(x: u8) -> u8 {\n                match x {\n                    $($x => $conv,)+\n                    x => panic!(\"number not in the range 0..={}: {}\", Self::BASE - 1, x),\n                }\n            }\n        }\n    }\n}\n\nradix! { Binary,    2, \"0b\", x @  0 ..=  1 => b'0' + x }\nradix! { Octal,     8, \"0o\", x @  0 ..=  7 => b'0' + x }\nradix! { LowerHex, 16, \"0x\", x @  0 ..=  9 => b'0' + x,\n                             x @ 10 ..= 15 => b'a' + (x - 10) }\nradix! { UpperHex, 16, \"0x\", x @  0 ..=  9 => b'0' + x,\n                             x @ 10 ..= 15 => b'A' + (x - 10) }\n\nmacro_rules! int_base {\n    ($Trait:ident for $T:ident as $U:ident -> $Radix:ident) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl fmt::$Trait for $T {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                $Radix.fmt_int(*self as $U, f)\n            }\n        }\n    }\n}\n\nmacro_rules! debug {\n    ($T:ident) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl fmt::Debug for $T {\n            #[inline]\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                if f.debug_lower_hex() {\n                    fmt::LowerHex::fmt(self, f)\n                } else if f.debug_upper_hex() {\n                    fmt::UpperHex::fmt(self, f)\n                } else {\n                    fmt::Display::fmt(self, f)\n                }\n            }\n        }\n    }\n}\n\nmacro_rules! integer {\n    ($Int:ident, $Uint:ident) => {\n        int_base! { Binary   for $Int as $Uint  -> Binary }\n        int_base! { Octal    for $Int as $Uint  -> Octal }\n        int_base! { LowerHex for $Int as $Uint  -> LowerHex }\n        int_base! { UpperHex for $Int as $Uint  -> UpperHex }\n        debug! { $Int }\n\n        int_base! { Binary   for $Uint as $Uint -> Binary }\n        int_base! { Octal    for $Uint as $Uint -> Octal }\n        int_base! { LowerHex for $Uint as $Uint -> LowerHex }\n        int_base! { UpperHex for $Uint as $Uint -> UpperHex }\n        debug! { $Uint }\n    }\n}\ninteger! { isize, usize }\ninteger! { i8, u8 }\ninteger! { i16, u16 }\ninteger! { i32, u32 }\ninteger! { i64, u64 }\ninteger! { i128, u128 }\n\nconst DEC_DIGITS_LUT: &'static[u8] =\n    b\"0001020304050607080910111213141516171819\\\n      2021222324252627282930313233343536373839\\\n      4041424344454647484950515253545556575859\\\n      6061626364656667686970717273747576777879\\\n      8081828384858687888990919293949596979899\";\n\nmacro_rules! impl_Display {\n    ($($t:ident),*: $conv_fn:ident) => ($(\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl fmt::Display for $t {\n        #[allow(unused_comparisons)]\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            let is_nonnegative = *self >= 0;\n            let mut n = if is_nonnegative {\n                self.$conv_fn()\n            } else {\n                // convert the negative num to positive by summing 1 to it's 2 complement\n                (!self.$conv_fn()).wrapping_add(1)\n            };\n            let mut buf: [u8; 39] = unsafe { mem::uninitialized() };\n            let mut curr = buf.len() as isize;\n            let buf_ptr = buf.as_mut_ptr();\n            let lut_ptr = DEC_DIGITS_LUT.as_ptr();\n\n            unsafe {\n                // need at least 16 bits for the 4-characters-at-a-time to work.\n                if ::mem::size_of::<$t>() >= 2 {\n                    // eagerly decode 4 characters at a time\n                    while n >= 10000 {\n                        let rem = (n % 10000) as isize;\n                        n /= 10000;\n\n                        let d1 = (rem / 100) << 1;\n                        let d2 = (rem % 100) << 1;\n                        curr -= 4;\n                        ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);\n                        ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);\n                    }\n                }\n\n                // if we reach here numbers are <= 9999, so at most 4 chars long\n                let mut n = n as isize; // possibly reduce 64bit math\n\n                // decode 2 more chars, if > 2 chars\n                if n >= 100 {\n                    let d1 = (n % 100) << 1;\n                    n /= 100;\n                    curr -= 2;\n                    ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);\n                }\n\n                // decode last 1 or 2 chars\n                if n < 10 {\n                    curr -= 1;\n                    *buf_ptr.offset(curr) = (n as u8) + b'0';\n                } else {\n                    let d1 = n << 1;\n                    curr -= 2;\n                    ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);\n                }\n            }\n\n            let buf_slice = unsafe {\n                str::from_utf8_unchecked(\n                    slice::from_raw_parts(buf_ptr.offset(curr), buf.len() - curr as usize))\n            };\n            f.pad_integral(is_nonnegative, \"\", buf_slice)\n        }\n    })*);\n}\n\nimpl_Display!(i8, u8, i16, u16, i32, u32: to_u32);\nimpl_Display!(i64, u64: to_u64);\nimpl_Display!(i128, u128: to_u128);\n#[cfg(target_pointer_width = \"16\")]\nimpl_Display!(isize, usize: to_u16);\n#[cfg(target_pointer_width = \"32\")]\nimpl_Display!(isize, usize: to_u32);\n#[cfg(target_pointer_width = \"64\")]\nimpl_Display!(isize, usize: to_u64);\n","// Copyright 2012 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse hash::{Hash, Hasher};\n\n/// An unbounded range (`..`).\n///\n/// `RangeFull` is primarily used as a [slicing index], its shorthand is `..`.\n/// It cannot serve as an [`Iterator`] because it doesn't have a starting point.\n///\n/// # Examples\n///\n/// The `..` syntax is a `RangeFull`:\n///\n/// ```\n/// assert_eq!((..), std::ops::RangeFull);\n/// ```\n///\n/// It does not have an [`IntoIterator`] implementation, so you can't use it in\n/// a `for` loop directly. This won't compile:\n///\n/// ```compile_fail,E0277\n/// for i in .. {\n///    // ...\n/// }\n/// ```\n///\n/// Used as a [slicing index], `RangeFull` produces the full array as a slice.\n///\n/// ```\n/// let arr = [0, 1, 2, 3];\n/// assert_eq!(arr[ .. ], [0,1,2,3]);  // RangeFull\n/// assert_eq!(arr[ ..3], [0,1,2  ]);\n/// assert_eq!(arr[1.. ], [  1,2,3]);\n/// assert_eq!(arr[1..3], [  1,2  ]);\n/// ```\n///\n/// [`IntoIterator`]: ../iter/trait.Iterator.html\n/// [`Iterator`]: ../iter/trait.IntoIterator.html\n/// [slicing index]: ../slice/trait.SliceIndex.html\n#[doc(alias = \"..\")]\n#[derive(Copy, Clone, PartialEq, Eq, Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RangeFull;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for RangeFull {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"..\")\n    }\n}\n\n/// A (half-open) range bounded inclusively below and exclusively above\n/// (`start..end`).\n///\n/// The `Range` `start..end` contains all values with `x >= start` and\n/// `x < end`.  It is empty unless `start < end`.\n///\n/// # Examples\n///\n/// ```\n/// assert_eq!((3..5), std::ops::Range { start: 3, end: 5 });\n/// assert_eq!(3 + 4 + 5, (3..6).sum());\n///\n/// let arr = ['a', 'b', 'c', 'd'];\n/// assert_eq!(arr[ .. ], ['a', 'b', 'c', 'd']);\n/// assert_eq!(arr[ ..3], ['a', 'b', 'c',    ]);\n/// assert_eq!(arr[1.. ], [     'b', 'c', 'd']);\n/// assert_eq!(arr[1..3], [     'b', 'c'     ]);  // Range\n/// ```\n#[doc(alias = \"..\")]\n#[derive(Clone, PartialEq, Eq, Hash)]  // not Copy -- see #27186\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Range<Idx> {\n    /// The lower bound of the range (inclusive).\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub start: Idx,\n    /// The upper bound of the range (exclusive).\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub end: Idx,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<Idx: fmt::Debug> fmt::Debug for Range<Idx> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"{:?}..{:?}\", self.start, self.end)\n    }\n}\n\nimpl<Idx: PartialOrd<Idx>> Range<Idx> {\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!(!(3..5).contains(&2));\n    /// assert!( (3..5).contains(&3));\n    /// assert!( (3..5).contains(&4));\n    /// assert!(!(3..5).contains(&5));\n    ///\n    /// assert!(!(3..3).contains(&3));\n    /// assert!(!(3..2).contains(&3));\n    ///\n    /// assert!( (0.0..1.0).contains(&0.5));\n    /// assert!(!(0.0..1.0).contains(&f32::NAN));\n    /// assert!(!(0.0..f32::NAN).contains(&0.5));\n    /// assert!(!(f32::NAN..1.0).contains(&0.5));\n    /// ```\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    pub fn contains<U>(&self, item: &U) -> bool\n    where\n        Idx: PartialOrd<U>,\n        U: ?Sized + PartialOrd<Idx>,\n    {\n        <Self as RangeBounds<Idx>>::contains(self, item)\n    }\n\n    /// Returns `true` if the range contains no items.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_is_empty)]\n    ///\n    /// assert!(!(3..5).is_empty());\n    /// assert!( (3..3).is_empty());\n    /// assert!( (3..2).is_empty());\n    /// ```\n    ///\n    /// The range is empty if either side is incomparable:\n    ///\n    /// ```\n    /// #![feature(range_is_empty)]\n    ///\n    /// use std::f32::NAN;\n    /// assert!(!(3.0..5.0).is_empty());\n    /// assert!( (3.0..NAN).is_empty());\n    /// assert!( (NAN..5.0).is_empty());\n    /// ```\n    #[unstable(feature = \"range_is_empty\", reason = \"recently added\", issue = \"48111\")]\n    pub fn is_empty(&self) -> bool {\n        !(self.start < self.end)\n    }\n}\n\n/// A range only bounded inclusively below (`start..`).\n///\n/// The `RangeFrom` `start..` contains all values with `x >= start`.\n///\n/// *Note*: Currently, no overflow checking is done for the [`Iterator`]\n/// implementation; if you use an integer range and the integer overflows, it\n/// might panic in debug mode or create an endless loop in release mode. **This\n/// overflow behavior might change in the future.**\n///\n/// # Examples\n///\n/// ```\n/// assert_eq!((2..), std::ops::RangeFrom { start: 2 });\n/// assert_eq!(2 + 3 + 4, (2..).take(3).sum());\n///\n/// let arr = [0, 1, 2, 3];\n/// assert_eq!(arr[ .. ], [0,1,2,3]);\n/// assert_eq!(arr[ ..3], [0,1,2  ]);\n/// assert_eq!(arr[1.. ], [  1,2,3]);  // RangeFrom\n/// assert_eq!(arr[1..3], [  1,2  ]);\n/// ```\n///\n/// [`Iterator`]: ../iter/trait.IntoIterator.html\n#[doc(alias = \"..\")]\n#[derive(Clone, PartialEq, Eq, Hash)]  // not Copy -- see #27186\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RangeFrom<Idx> {\n    /// The lower bound of the range (inclusive).\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub start: Idx,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<Idx: fmt::Debug> fmt::Debug for RangeFrom<Idx> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"{:?}..\", self.start)\n    }\n}\n\nimpl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!(!(3..).contains(&2));\n    /// assert!( (3..).contains(&3));\n    /// assert!( (3..).contains(&1_000_000_000));\n    ///\n    /// assert!( (0.0..).contains(&0.5));\n    /// assert!(!(0.0..).contains(&f32::NAN));\n    /// assert!(!(f32::NAN..).contains(&0.5));\n    /// ```\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    pub fn contains<U>(&self, item: &U) -> bool\n    where\n        Idx: PartialOrd<U>,\n        U: ?Sized + PartialOrd<Idx>,\n    {\n        <Self as RangeBounds<Idx>>::contains(self, item)\n    }\n}\n\n/// A range only bounded exclusively above (`..end`).\n///\n/// The `RangeTo` `..end` contains all values with `x < end`.\n/// It cannot serve as an [`Iterator`] because it doesn't have a starting point.\n///\n/// # Examples\n///\n/// The `..end` syntax is a `RangeTo`:\n///\n/// ```\n/// assert_eq!((..5), std::ops::RangeTo { end: 5 });\n/// ```\n///\n/// It does not have an [`IntoIterator`] implementation, so you can't use it in\n/// a `for` loop directly. This won't compile:\n///\n/// ```compile_fail,E0277\n/// // error[E0277]: the trait bound `std::ops::RangeTo<{integer}>:\n/// // std::iter::Iterator` is not satisfied\n/// for i in ..5 {\n///     // ...\n/// }\n/// ```\n///\n/// When used as a [slicing index], `RangeTo` produces a slice of all array\n/// elements before the index indicated by `end`.\n///\n/// ```\n/// let arr = [0, 1, 2, 3];\n/// assert_eq!(arr[ .. ], [0,1,2,3]);\n/// assert_eq!(arr[ ..3], [0,1,2  ]);  // RangeTo\n/// assert_eq!(arr[1.. ], [  1,2,3]);\n/// assert_eq!(arr[1..3], [  1,2  ]);\n/// ```\n///\n/// [`IntoIterator`]: ../iter/trait.Iterator.html\n/// [`Iterator`]: ../iter/trait.IntoIterator.html\n/// [slicing index]: ../slice/trait.SliceIndex.html\n#[doc(alias = \"..\")]\n#[derive(Copy, Clone, PartialEq, Eq, Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct RangeTo<Idx> {\n    /// The upper bound of the range (exclusive).\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub end: Idx,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<Idx: fmt::Debug> fmt::Debug for RangeTo<Idx> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"..{:?}\", self.end)\n    }\n}\n\nimpl<Idx: PartialOrd<Idx>> RangeTo<Idx> {\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!( (..5).contains(&-1_000_000_000));\n    /// assert!( (..5).contains(&4));\n    /// assert!(!(..5).contains(&5));\n    ///\n    /// assert!( (..1.0).contains(&0.5));\n    /// assert!(!(..1.0).contains(&f32::NAN));\n    /// assert!(!(..f32::NAN).contains(&0.5));\n    /// ```\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    pub fn contains<U>(&self, item: &U) -> bool\n    where\n        Idx: PartialOrd<U>,\n        U: ?Sized + PartialOrd<Idx>,\n    {\n        <Self as RangeBounds<Idx>>::contains(self, item)\n    }\n}\n\n/// A range bounded inclusively below and above (`start..=end`).\n///\n/// The `RangeInclusive` `start..=end` contains all values with `x >= start`\n/// and `x <= end`.  It is empty unless `start <= end`.\n///\n/// This iterator is [fused], but the specific values of `start` and `end` after\n/// iteration has finished are **unspecified** other than that [`.is_empty()`]\n/// will return `true` once no more values will be produced.\n///\n/// [fused]: ../iter/trait.FusedIterator.html\n/// [`.is_empty()`]: #method.is_empty\n///\n/// # Examples\n///\n/// ```\n/// assert_eq!((3..=5), std::ops::RangeInclusive::new(3, 5));\n/// assert_eq!(3 + 4 + 5, (3..=5).sum());\n///\n/// let arr = [0, 1, 2, 3];\n/// assert_eq!(arr[ ..=2], [0,1,2  ]);\n/// assert_eq!(arr[1..=2], [  1,2  ]);  // RangeInclusive\n/// ```\n#[doc(alias = \"..=\")]\n#[derive(Clone)]  // not Copy -- see #27186\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\npub struct RangeInclusive<Idx> {\n    pub(crate) start: Idx,\n    pub(crate) end: Idx,\n    pub(crate) is_empty: Option<bool>,\n    // This field is:\n    //  - `None` when next() or next_back() was never called\n    //  - `Some(false)` when `start <= end` assuming no overflow\n    //  - `Some(true)` otherwise\n    // The field cannot be a simple `bool` because the `..=` constructor can\n    // accept non-PartialOrd types, also we want the constructor to be const.\n}\n\ntrait RangeInclusiveEquality: Sized {\n    fn canonicalized_is_empty(range: &RangeInclusive<Self>) -> bool;\n}\nimpl<T> RangeInclusiveEquality for T {\n    #[inline]\n    default fn canonicalized_is_empty(range: &RangeInclusive<Self>) -> bool {\n        range.is_empty.unwrap_or_default()\n    }\n}\nimpl<T: PartialOrd> RangeInclusiveEquality for T {\n    #[inline]\n    fn canonicalized_is_empty(range: &RangeInclusive<Self>) -> bool {\n        range.is_empty()\n    }\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<Idx: PartialEq> PartialEq for RangeInclusive<Idx> {\n    #[inline]\n    fn eq(&self, other: &Self) -> bool {\n        self.start == other.start && self.end == other.end\n            && RangeInclusiveEquality::canonicalized_is_empty(self)\n                == RangeInclusiveEquality::canonicalized_is_empty(other)\n    }\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<Idx: Eq> Eq for RangeInclusive<Idx> {}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<Idx: Hash> Hash for RangeInclusive<Idx> {\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        self.start.hash(state);\n        self.end.hash(state);\n        RangeInclusiveEquality::canonicalized_is_empty(self).hash(state);\n    }\n}\n\nimpl<Idx> RangeInclusive<Idx> {\n    /// Creates a new inclusive range. Equivalent to writing `start..=end`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ops::RangeInclusive;\n    ///\n    /// assert_eq!(3..=5, RangeInclusive::new(3, 5));\n    /// ```\n    #[stable(feature = \"inclusive_range_methods\", since = \"1.27.0\")]\n    #[inline]\n    #[rustc_promotable]\n    pub const fn new(start: Idx, end: Idx) -> Self {\n        Self { start, end, is_empty: None }\n    }\n\n    /// Returns the lower bound of the range (inclusive).\n    ///\n    /// When using an inclusive range for iteration, the values of `start()` and\n    /// [`end()`] are unspecified after the iteration ended. To determine\n    /// whether the inclusive range is empty, use the [`is_empty()`] method\n    /// instead of comparing `start() > end()`.\n    ///\n    /// Note: the value returned by this method is unspecified after the range\n    /// has been iterated to exhaustion.\n    ///\n    /// [`end()`]: #method.end\n    /// [`is_empty()`]: #method.is_empty\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!((3..=5).start(), &3);\n    /// ```\n    #[stable(feature = \"inclusive_range_methods\", since = \"1.27.0\")]\n    #[inline]\n    pub fn start(&self) -> &Idx {\n        &self.start\n    }\n\n    /// Returns the upper bound of the range (inclusive).\n    ///\n    /// When using an inclusive range for iteration, the values of [`start()`]\n    /// and `end()` are unspecified after the iteration ended. To determine\n    /// whether the inclusive range is empty, use the [`is_empty()`] method\n    /// instead of comparing `start() > end()`.\n    ///\n    /// Note: the value returned by this method is unspecified after the range\n    /// has been iterated to exhaustion.\n    ///\n    /// [`start()`]: #method.start\n    /// [`is_empty()`]: #method.is_empty\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!((3..=5).end(), &5);\n    /// ```\n    #[stable(feature = \"inclusive_range_methods\", since = \"1.27.0\")]\n    #[inline]\n    pub fn end(&self) -> &Idx {\n        &self.end\n    }\n\n    /// Destructures the `RangeInclusive` into (lower bound, upper (inclusive) bound).\n    ///\n    /// Note: the value returned by this method is unspecified after the range\n    /// has been iterated to exhaustion.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!((3..=5).into_inner(), (3, 5));\n    /// ```\n    #[stable(feature = \"inclusive_range_methods\", since = \"1.27.0\")]\n    #[inline]\n    pub fn into_inner(self) -> (Idx, Idx) {\n        (self.start, self.end)\n    }\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<Idx: fmt::Debug> fmt::Debug for RangeInclusive<Idx> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"{:?}..={:?}\", self.start, self.end)\n    }\n}\n\nimpl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!(!(3..=5).contains(&2));\n    /// assert!( (3..=5).contains(&3));\n    /// assert!( (3..=5).contains(&4));\n    /// assert!( (3..=5).contains(&5));\n    /// assert!(!(3..=5).contains(&6));\n    ///\n    /// assert!( (3..=3).contains(&3));\n    /// assert!(!(3..=2).contains(&3));\n    ///\n    /// assert!( (0.0..=1.0).contains(&1.0));\n    /// assert!(!(0.0..=1.0).contains(&f32::NAN));\n    /// assert!(!(0.0..=f32::NAN).contains(&0.0));\n    /// assert!(!(f32::NAN..=1.0).contains(&1.0));\n    /// ```\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    pub fn contains<U>(&self, item: &U) -> bool\n    where\n        Idx: PartialOrd<U>,\n        U: ?Sized + PartialOrd<Idx>,\n    {\n        <Self as RangeBounds<Idx>>::contains(self, item)\n    }\n\n    /// Returns `true` if the range contains no items.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_is_empty)]\n    ///\n    /// assert!(!(3..=5).is_empty());\n    /// assert!(!(3..=3).is_empty());\n    /// assert!( (3..=2).is_empty());\n    /// ```\n    ///\n    /// The range is empty if either side is incomparable:\n    ///\n    /// ```\n    /// #![feature(range_is_empty)]\n    ///\n    /// use std::f32::NAN;\n    /// assert!(!(3.0..=5.0).is_empty());\n    /// assert!( (3.0..=NAN).is_empty());\n    /// assert!( (NAN..=5.0).is_empty());\n    /// ```\n    ///\n    /// This method returns `true` after iteration has finished:\n    ///\n    /// ```\n    /// #![feature(range_is_empty)]\n    ///\n    /// let mut r = 3..=5;\n    /// for _ in r.by_ref() {}\n    /// // Precise field values are unspecified here\n    /// assert!(r.is_empty());\n    /// ```\n    #[unstable(feature = \"range_is_empty\", reason = \"recently added\", issue = \"48111\")]\n    #[inline]\n    pub fn is_empty(&self) -> bool {\n        self.is_empty.unwrap_or_else(|| !(self.start <= self.end))\n    }\n\n    // If this range's `is_empty` is field is unknown (`None`), update it to be a concrete value.\n    #[inline]\n    pub(crate) fn compute_is_empty(&mut self) {\n        if self.is_empty.is_none() {\n            self.is_empty = Some(!(self.start <= self.end));\n        }\n    }\n}\n\n/// A range only bounded inclusively above (`..=end`).\n///\n/// The `RangeToInclusive` `..=end` contains all values with `x <= end`.\n/// It cannot serve as an [`Iterator`] because it doesn't have a starting point.\n///\n/// # Examples\n///\n/// The `..=end` syntax is a `RangeToInclusive`:\n///\n/// ```\n/// assert_eq!((..=5), std::ops::RangeToInclusive{ end: 5 });\n/// ```\n///\n/// It does not have an [`IntoIterator`] implementation, so you can't use it in a\n/// `for` loop directly. This won't compile:\n///\n/// ```compile_fail,E0277\n/// // error[E0277]: the trait bound `std::ops::RangeToInclusive<{integer}>:\n/// // std::iter::Iterator` is not satisfied\n/// for i in ..=5 {\n///     // ...\n/// }\n/// ```\n///\n/// When used as a [slicing index], `RangeToInclusive` produces a slice of all\n/// array elements up to and including the index indicated by `end`.\n///\n/// ```\n/// let arr = [0, 1, 2, 3];\n/// assert_eq!(arr[ ..=2], [0,1,2  ]);  // RangeToInclusive\n/// assert_eq!(arr[1..=2], [  1,2  ]);\n/// ```\n///\n/// [`IntoIterator`]: ../iter/trait.Iterator.html\n/// [`Iterator`]: ../iter/trait.IntoIterator.html\n/// [slicing index]: ../slice/trait.SliceIndex.html\n#[doc(alias = \"..=\")]\n#[derive(Copy, Clone, PartialEq, Eq, Hash)]\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\npub struct RangeToInclusive<Idx> {\n    /// The upper bound of the range (inclusive)\n    #[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\n    pub end: Idx,\n}\n\n#[stable(feature = \"inclusive_range\", since = \"1.26.0\")]\nimpl<Idx: fmt::Debug> fmt::Debug for RangeToInclusive<Idx> {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        write!(fmt, \"..={:?}\", self.end)\n    }\n}\n\n#[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\nimpl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!( (..=5).contains(&-1_000_000_000));\n    /// assert!( (..=5).contains(&5));\n    /// assert!(!(..=5).contains(&6));\n    ///\n    /// assert!( (..=1.0).contains(&1.0));\n    /// assert!(!(..=1.0).contains(&f32::NAN));\n    /// assert!(!(..=f32::NAN).contains(&0.5));\n    /// ```\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    pub fn contains<U>(&self, item: &U) -> bool\n    where\n        Idx: PartialOrd<U>,\n        U: ?Sized + PartialOrd<Idx>,\n    {\n        <Self as RangeBounds<Idx>>::contains(self, item)\n    }\n}\n\n// RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>\n// because underflow would be possible with (..0).into()\n\n/// An endpoint of a range of keys.\n///\n/// # Examples\n///\n/// `Bound`s are range endpoints:\n///\n/// ```\n/// use std::ops::Bound::*;\n/// use std::ops::RangeBounds;\n///\n/// assert_eq!((..100).start_bound(), Unbounded);\n/// assert_eq!((1..12).start_bound(), Included(&1));\n/// assert_eq!((1..12).end_bound(), Excluded(&12));\n/// ```\n///\n/// Using a tuple of `Bound`s as an argument to [`BTreeMap::range`].\n/// Note that in most cases, it's better to use range syntax (`1..5`) instead.\n///\n/// ```\n/// use std::collections::BTreeMap;\n/// use std::ops::Bound::{Excluded, Included, Unbounded};\n///\n/// let mut map = BTreeMap::new();\n/// map.insert(3, \"a\");\n/// map.insert(5, \"b\");\n/// map.insert(8, \"c\");\n///\n/// for (key, value) in map.range((Excluded(3), Included(8))) {\n///     println!(\"{}: {}\", key, value);\n/// }\n///\n/// assert_eq!(Some((&3, &\"a\")), map.range((Unbounded, Included(5))).next());\n/// ```\n///\n/// [`BTreeMap::range`]: ../../std/collections/btree_map/struct.BTreeMap.html#method.range\n#[stable(feature = \"collections_bound\", since = \"1.17.0\")]\n#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]\npub enum Bound<T> {\n    /// An inclusive bound.\n    #[stable(feature = \"collections_bound\", since = \"1.17.0\")]\n    Included(#[stable(feature = \"collections_bound\", since = \"1.17.0\")] T),\n    /// An exclusive bound.\n    #[stable(feature = \"collections_bound\", since = \"1.17.0\")]\n    Excluded(#[stable(feature = \"collections_bound\", since = \"1.17.0\")] T),\n    /// An infinite endpoint. Indicates that there is no bound in this direction.\n    #[stable(feature = \"collections_bound\", since = \"1.17.0\")]\n    Unbounded,\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\n/// `RangeBounds` is implemented by Rust's built-in range types, produced\n/// by range syntax like `..`, `a..`, `..b` or `c..d`.\npub trait RangeBounds<T: ?Sized> {\n    /// Start index bound.\n    ///\n    /// Returns the start value as a `Bound`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # fn main() {\n    /// use std::ops::Bound::*;\n    /// use std::ops::RangeBounds;\n    ///\n    /// assert_eq!((..10).start_bound(), Unbounded);\n    /// assert_eq!((3..10).start_bound(), Included(&3));\n    /// # }\n    /// ```\n    #[stable(feature = \"collections_range\", since = \"1.28.0\")]\n    fn start_bound(&self) -> Bound<&T>;\n\n    /// End index bound.\n    ///\n    /// Returns the end value as a `Bound`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # fn main() {\n    /// use std::ops::Bound::*;\n    /// use std::ops::RangeBounds;\n    ///\n    /// assert_eq!((3..).end_bound(), Unbounded);\n    /// assert_eq!((3..10).end_bound(), Excluded(&10));\n    /// # }\n    /// ```\n    #[stable(feature = \"collections_range\", since = \"1.28.0\")]\n    fn end_bound(&self) -> Bound<&T>;\n\n\n    /// Returns `true` if `item` is contained in the range.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(range_contains)]\n    ///\n    /// use std::f32;\n    ///\n    /// assert!( (3..5).contains(&4));\n    /// assert!(!(3..5).contains(&2));\n    ///\n    /// assert!( (0.0..1.0).contains(&0.5));\n    /// assert!(!(0.0..1.0).contains(&f32::NAN));\n    /// assert!(!(0.0..f32::NAN).contains(&0.5));\n    /// assert!(!(f32::NAN..1.0).contains(&0.5));\n    #[unstable(feature = \"range_contains\", reason = \"recently added as per RFC\", issue = \"32311\")]\n    fn contains<U>(&self, item: &U) -> bool\n    where\n        T: PartialOrd<U>,\n        U: ?Sized + PartialOrd<T>,\n    {\n        (match self.start_bound() {\n            Included(ref start) => *start <= item,\n            Excluded(ref start) => *start < item,\n            Unbounded => true,\n        })\n        &&\n        (match self.end_bound() {\n            Included(ref end) => item <= *end,\n            Excluded(ref end) => item < *end,\n            Unbounded => true,\n        })\n    }\n}\n\nuse self::Bound::{Excluded, Included, Unbounded};\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T: ?Sized> RangeBounds<T> for RangeFull {\n    fn start_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeFrom<T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(&self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeTo<T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Excluded(&self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for Range<T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(&self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Excluded(&self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeInclusive<T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(&self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Included(&self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeToInclusive<T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Included(&self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for (Bound<T>, Bound<T>) {\n    fn start_bound(&self) -> Bound<&T> {\n        match *self {\n            (Included(ref start), _) => Included(start),\n            (Excluded(ref start), _) => Excluded(start),\n            (Unbounded, _)           => Unbounded,\n        }\n    }\n\n    fn end_bound(&self) -> Bound<&T> {\n        match *self {\n            (_, Included(ref end)) => Included(end),\n            (_, Excluded(ref end)) => Excluded(end),\n            (_, Unbounded)         => Unbounded,\n        }\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<'a, T: ?Sized + 'a> RangeBounds<T> for (Bound<&'a T>, Bound<&'a T>) {\n    fn start_bound(&self) -> Bound<&T> {\n        self.0\n    }\n\n    fn end_bound(&self) -> Bound<&T> {\n        self.1\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeFrom<&T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeTo<&T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Excluded(self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for Range<&T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Excluded(self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeInclusive<&T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Included(self.start)\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Included(self.end)\n    }\n}\n\n#[stable(feature = \"collections_range\", since = \"1.28.0\")]\nimpl<T> RangeBounds<T> for RangeToInclusive<&T> {\n    fn start_bound(&self) -> Bound<&T> {\n        Unbounded\n    }\n    fn end_bound(&self) -> Bound<&T> {\n        Included(self.end)\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\n\nstruct PadAdapter<'a> {\n    buf: &'a mut (dyn fmt::Write + 'a),\n    on_newline: bool,\n}\n\nimpl<'a> PadAdapter<'a> {\n    fn wrap<'b, 'c: 'a+'b>(fmt: &'c mut fmt::Formatter, slot: &'b mut Option<Self>)\n                        -> fmt::Formatter<'b> {\n        fmt.wrap_buf(move |buf| {\n            *slot = Some(PadAdapter {\n                buf,\n                on_newline: false,\n            });\n            slot.as_mut().unwrap()\n        })\n    }\n}\n\nimpl fmt::Write for PadAdapter<'_> {\n    fn write_str(&mut self, mut s: &str) -> fmt::Result {\n        while !s.is_empty() {\n            if self.on_newline {\n                self.buf.write_str(\"    \")?;\n            }\n\n            let split = match s.find('\\n') {\n                Some(pos) => {\n                    self.on_newline = true;\n                    pos + 1\n                }\n                None => {\n                    self.on_newline = false;\n                    s.len()\n                }\n            };\n            self.buf.write_str(&s[..split])?;\n            s = &s[split..];\n        }\n\n        Ok(())\n    }\n}\n\n/// A struct to help with [`fmt::Debug`](trait.Debug.html) implementations.\n///\n/// This is useful when you wish to output a formatted struct as a part of your\n/// [`Debug::fmt`](trait.Debug.html#tymethod.fmt) implementation.\n///\n/// This can be constructed by the\n/// [`Formatter::debug_struct`](struct.Formatter.html#method.debug_struct)\n/// method.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Foo {\n///     bar: i32,\n///     baz: String,\n/// }\n///\n/// impl fmt::Debug for Foo {\n///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n///         fmt.debug_struct(\"Foo\")\n///            .field(\"bar\", &self.bar)\n///            .field(\"baz\", &self.baz)\n///            .finish()\n///     }\n/// }\n///\n/// // prints \"Foo { bar: 10, baz: \"Hello World\" }\"\n/// println!(\"{:?}\", Foo { bar: 10, baz: \"Hello World\".to_string() });\n/// ```\n#[must_use = \"must eventually call `finish()` on Debug builders\"]\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub struct DebugStruct<'a, 'b: 'a> {\n    fmt: &'a mut fmt::Formatter<'b>,\n    result: fmt::Result,\n    has_fields: bool,\n}\n\npub fn debug_struct_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>,\n                                name: &str)\n                                -> DebugStruct<'a, 'b> {\n    let result = fmt.write_str(name);\n    DebugStruct {\n        fmt,\n        result,\n        has_fields: false,\n    }\n}\n\nimpl<'a, 'b: 'a> DebugStruct<'a, 'b> {\n    /// Adds a new field to the generated struct output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn field(&mut self, name: &str, value: &dyn fmt::Debug) -> &mut DebugStruct<'a, 'b> {\n        self.result = self.result.and_then(|_| {\n            let prefix = if self.has_fields {\n                \",\"\n            } else {\n                \" {\"\n            };\n\n            if self.is_pretty() {\n                let mut slot = None;\n                let mut writer = PadAdapter::wrap(&mut self.fmt, &mut slot);\n                writer.write_str(prefix)?;\n                writer.write_str(\"\\n\")?;\n                writer.write_str(name)?;\n                writer.write_str(\": \")?;\n                value.fmt(&mut writer)\n            } else {\n                write!(self.fmt, \"{} {}: \", prefix, name)?;\n                value.fmt(self.fmt)\n            }\n        });\n\n        self.has_fields = true;\n        self\n    }\n\n    /// Finishes output and returns any error encountered.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn finish(&mut self) -> fmt::Result {\n        if self.has_fields {\n            self.result = self.result.and_then(|_| {\n                if self.is_pretty() {\n                    self.fmt.write_str(\"\\n}\")\n                } else {\n                    self.fmt.write_str(\" }\")\n                }\n            });\n        }\n        self.result\n    }\n\n    fn is_pretty(&self) -> bool {\n        self.fmt.alternate()\n    }\n}\n\n/// A struct to help with [`fmt::Debug`](trait.Debug.html) implementations.\n///\n/// This is useful when you wish to output a formatted tuple as a part of your\n/// [`Debug::fmt`](trait.Debug.html#tymethod.fmt) implementation.\n///\n/// This can be constructed by the\n/// [`Formatter::debug_tuple`](struct.Formatter.html#method.debug_tuple)\n/// method.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Foo(i32, String);\n///\n/// impl fmt::Debug for Foo {\n///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n///         fmt.debug_tuple(\"Foo\")\n///            .field(&self.0)\n///            .field(&self.1)\n///            .finish()\n///     }\n/// }\n///\n/// // prints \"Foo(10, \"Hello World\")\"\n/// println!(\"{:?}\", Foo(10, \"Hello World\".to_string()));\n/// ```\n#[must_use = \"must eventually call `finish()` on Debug builders\"]\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub struct DebugTuple<'a, 'b: 'a> {\n    fmt: &'a mut fmt::Formatter<'b>,\n    result: fmt::Result,\n    fields: usize,\n    empty_name: bool,\n}\n\npub fn debug_tuple_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>, name: &str) -> DebugTuple<'a, 'b> {\n    let result = fmt.write_str(name);\n    DebugTuple {\n        fmt,\n        result,\n        fields: 0,\n        empty_name: name.is_empty(),\n    }\n}\n\nimpl<'a, 'b: 'a> DebugTuple<'a, 'b> {\n    /// Adds a new field to the generated tuple struct output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn field(&mut self, value: &dyn fmt::Debug) -> &mut DebugTuple<'a, 'b> {\n        self.result = self.result.and_then(|_| {\n            let (prefix, space) = if self.fields > 0 {\n                (\",\", \" \")\n            } else {\n                (\"(\", \"\")\n            };\n\n            if self.is_pretty() {\n                let mut slot = None;\n                let mut writer = PadAdapter::wrap(&mut self.fmt, &mut slot);\n                writer.write_str(prefix)?;\n                writer.write_str(\"\\n\")?;\n                value.fmt(&mut writer)\n            } else {\n                self.fmt.write_str(prefix)?;\n                self.fmt.write_str(space)?;\n                value.fmt(self.fmt)\n            }\n        });\n\n        self.fields += 1;\n        self\n    }\n\n    /// Finishes output and returns any error encountered.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn finish(&mut self) -> fmt::Result {\n        if self.fields > 0 {\n            self.result = self.result.and_then(|_| {\n                if self.is_pretty() {\n                    self.fmt.write_str(\"\\n\")?;\n                }\n                if self.fields == 1 && self.empty_name {\n                    self.fmt.write_str(\",\")?;\n                }\n                self.fmt.write_str(\")\")\n            });\n        }\n        self.result\n    }\n\n    fn is_pretty(&self) -> bool {\n        self.fmt.alternate()\n    }\n}\n\nstruct DebugInner<'a, 'b: 'a> {\n    fmt: &'a mut fmt::Formatter<'b>,\n    result: fmt::Result,\n    has_fields: bool,\n}\n\nimpl<'a, 'b: 'a> DebugInner<'a, 'b> {\n    fn entry(&mut self, entry: &dyn fmt::Debug) {\n        self.result = self.result.and_then(|_| {\n            if self.is_pretty() {\n                let mut slot = None;\n                let mut writer = PadAdapter::wrap(&mut self.fmt, &mut slot);\n                writer.write_str(if self.has_fields {\n                    \",\\n\"\n                } else {\n                    \"\\n\"\n                })?;\n                entry.fmt(&mut writer)\n            } else {\n                if self.has_fields {\n                    self.fmt.write_str(\", \")?\n                }\n                entry.fmt(self.fmt)\n            }\n        });\n\n        self.has_fields = true;\n    }\n\n    pub fn finish(&mut self) {\n        let prefix = if self.is_pretty() && self.has_fields {\n            \"\\n\"\n        } else {\n            \"\"\n        };\n        self.result = self.result.and_then(|_| self.fmt.write_str(prefix));\n    }\n\n    fn is_pretty(&self) -> bool {\n        self.fmt.alternate()\n    }\n}\n\n/// A struct to help with [`fmt::Debug`](trait.Debug.html) implementations.\n///\n/// This is useful when you wish to output a formatted set of items as a part\n/// of your [`Debug::fmt`](trait.Debug.html#tymethod.fmt) implementation.\n///\n/// This can be constructed by the\n/// [`Formatter::debug_set`](struct.Formatter.html#method.debug_set)\n/// method.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Foo(Vec<i32>);\n///\n/// impl fmt::Debug for Foo {\n///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n///         fmt.debug_set().entries(self.0.iter()).finish()\n///     }\n/// }\n///\n/// // prints \"{10, 11}\"\n/// println!(\"{:?}\", Foo(vec![10, 11]));\n/// ```\n#[must_use = \"must eventually call `finish()` on Debug builders\"]\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub struct DebugSet<'a, 'b: 'a> {\n    inner: DebugInner<'a, 'b>,\n}\n\npub fn debug_set_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugSet<'a, 'b> {\n    let result = write!(fmt, \"{{\");\n    DebugSet {\n        inner: DebugInner {\n            fmt,\n            result,\n            has_fields: false,\n        },\n    }\n}\n\nimpl<'a, 'b: 'a> DebugSet<'a, 'b> {\n    /// Adds a new entry to the set output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut DebugSet<'a, 'b> {\n        self.inner.entry(entry);\n        self\n    }\n\n    /// Adds the contents of an iterator of entries to the set output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>\n        where D: fmt::Debug,\n              I: IntoIterator<Item = D>\n    {\n        for entry in entries {\n            self.entry(&entry);\n        }\n        self\n    }\n\n    /// Finishes output and returns any error encountered.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn finish(&mut self) -> fmt::Result {\n        self.inner.finish();\n        self.inner.result.and_then(|_| self.inner.fmt.write_str(\"}\"))\n    }\n}\n\n/// A struct to help with [`fmt::Debug`](trait.Debug.html) implementations.\n///\n/// This is useful when you wish to output a formatted list of items as a part\n/// of your [`Debug::fmt`](trait.Debug.html#tymethod.fmt) implementation.\n///\n/// This can be constructed by the\n/// [`Formatter::debug_list`](struct.Formatter.html#method.debug_list)\n/// method.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Foo(Vec<i32>);\n///\n/// impl fmt::Debug for Foo {\n///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n///         fmt.debug_list().entries(self.0.iter()).finish()\n///     }\n/// }\n///\n/// // prints \"[10, 11]\"\n/// println!(\"{:?}\", Foo(vec![10, 11]));\n/// ```\n#[must_use = \"must eventually call `finish()` on Debug builders\"]\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub struct DebugList<'a, 'b: 'a> {\n    inner: DebugInner<'a, 'b>,\n}\n\npub fn debug_list_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugList<'a, 'b> {\n    let result = write!(fmt, \"[\");\n    DebugList {\n        inner: DebugInner {\n            fmt,\n            result,\n            has_fields: false,\n        },\n    }\n}\n\nimpl<'a, 'b: 'a> DebugList<'a, 'b> {\n    /// Adds a new entry to the list output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entry(&mut self, entry: &dyn fmt::Debug) -> &mut DebugList<'a, 'b> {\n        self.inner.entry(entry);\n        self\n    }\n\n    /// Adds the contents of an iterator of entries to the list output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>\n        where D: fmt::Debug,\n              I: IntoIterator<Item = D>\n    {\n        for entry in entries {\n            self.entry(&entry);\n        }\n        self\n    }\n\n    /// Finishes output and returns any error encountered.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn finish(&mut self) -> fmt::Result {\n        self.inner.finish();\n        self.inner.result.and_then(|_| self.inner.fmt.write_str(\"]\"))\n    }\n}\n\n/// A struct to help with [`fmt::Debug`](trait.Debug.html) implementations.\n///\n/// This is useful when you wish to output a formatted map as a part of your\n/// [`Debug::fmt`](trait.Debug.html#tymethod.fmt) implementation.\n///\n/// This can be constructed by the\n/// [`Formatter::debug_map`](struct.Formatter.html#method.debug_map)\n/// method.\n///\n/// # Examples\n///\n/// ```\n/// use std::fmt;\n///\n/// struct Foo(Vec<(String, i32)>);\n///\n/// impl fmt::Debug for Foo {\n///     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n///         fmt.debug_map().entries(self.0.iter().map(|&(ref k, ref v)| (k, v))).finish()\n///     }\n/// }\n///\n/// // prints \"{\"A\": 10, \"B\": 11}\"\n/// println!(\"{:?}\", Foo(vec![(\"A\".to_string(), 10), (\"B\".to_string(), 11)]));\n/// ```\n#[must_use = \"must eventually call `finish()` on Debug builders\"]\n#[allow(missing_debug_implementations)]\n#[stable(feature = \"debug_builders\", since = \"1.2.0\")]\npub struct DebugMap<'a, 'b: 'a> {\n    fmt: &'a mut fmt::Formatter<'b>,\n    result: fmt::Result,\n    has_fields: bool,\n}\n\npub fn debug_map_new<'a, 'b>(fmt: &'a mut fmt::Formatter<'b>) -> DebugMap<'a, 'b> {\n    let result = write!(fmt, \"{{\");\n    DebugMap {\n        fmt,\n        result,\n        has_fields: false,\n    }\n}\n\nimpl<'a, 'b: 'a> DebugMap<'a, 'b> {\n    /// Adds a new entry to the map output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entry(&mut self, key: &dyn fmt::Debug, value: &dyn fmt::Debug) -> &mut DebugMap<'a, 'b> {\n        self.result = self.result.and_then(|_| {\n            if self.is_pretty() {\n                let mut slot = None;\n                let mut writer = PadAdapter::wrap(&mut self.fmt, &mut slot);\n                writer.write_str(if self.has_fields {\n                    \",\\n\"\n                } else {\n                    \"\\n\"\n                })?;\n                key.fmt(&mut writer)?;\n                writer.write_str(\": \")?;\n                value.fmt(&mut writer)\n            } else {\n                if self.has_fields {\n                    self.fmt.write_str(\", \")?\n                }\n                key.fmt(self.fmt)?;\n                self.fmt.write_str(\": \")?;\n                value.fmt(self.fmt)\n            }\n        });\n\n        self.has_fields = true;\n        self\n    }\n\n    /// Adds the contents of an iterator of entries to the map output.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>\n        where K: fmt::Debug,\n              V: fmt::Debug,\n              I: IntoIterator<Item = (K, V)>\n    {\n        for (k, v) in entries {\n            self.entry(&k, &v);\n        }\n        self\n    }\n\n    /// Finishes output and returns any error encountered.\n    #[stable(feature = \"debug_builders\", since = \"1.2.0\")]\n    pub fn finish(&mut self) -> fmt::Result {\n        let prefix = if self.is_pretty() && self.has_fields {\n            \"\\n\"\n        } else {\n            \"\"\n        };\n        self.result.and_then(|_| write!(self.fmt, \"{}}}\", prefix))\n    }\n\n    fn is_pretty(&self) -> bool {\n        self.fmt.alternate()\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n//\n// Original implementation taken from rust-memchr\n// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch\n\nuse cmp;\nuse mem;\n\nconst LO_U64: u64 = 0x0101010101010101;\nconst HI_U64: u64 = 0x8080808080808080;\n\n// use truncation\nconst LO_USIZE: usize = LO_U64 as usize;\nconst HI_USIZE: usize = HI_U64 as usize;\n\n/// Return `true` if `x` contains any zero byte.\n///\n/// From *Matters Computational*, J. Arndt\n///\n/// \"The idea is to subtract one from each of the bytes and then look for\n/// bytes where the borrow propagated all the way to the most significant\n/// bit.\"\n#[inline]\nfn contains_zero_byte(x: usize) -> bool {\n    x.wrapping_sub(LO_USIZE) & !x & HI_USIZE != 0\n}\n\n#[cfg(target_pointer_width = \"16\")]\n#[inline]\nfn repeat_byte(b: u8) -> usize {\n    (b as usize) << 8 | b as usize\n}\n\n#[cfg(not(target_pointer_width = \"16\"))]\n#[inline]\nfn repeat_byte(b: u8) -> usize {\n    (b as usize) * (::usize::MAX / 255)\n}\n\n/// Return the first index matching the byte `x` in `text`.\npub fn memchr(x: u8, text: &[u8]) -> Option<usize> {\n    // Scan for a single byte value by reading two `usize` words at a time.\n    //\n    // Split `text` in three parts\n    // - unaligned initial part, before the first word aligned address in text\n    // - body, scan by 2 words at a time\n    // - the last remaining part, < 2 word size\n    let len = text.len();\n    let ptr = text.as_ptr();\n    let usize_bytes = mem::size_of::<usize>();\n\n    // search up to an aligned boundary\n    let mut offset = ptr.align_offset(usize_bytes);\n    if offset > 0 {\n        offset = cmp::min(offset, len);\n        if let Some(index) = text[..offset].iter().position(|elt| *elt == x) {\n            return Some(index);\n        }\n    }\n\n    // search the body of the text\n    let repeated_x = repeat_byte(x);\n\n    if len >= 2 * usize_bytes {\n        while offset <= len - 2 * usize_bytes {\n            unsafe {\n                let u = *(ptr.add(offset) as *const usize);\n                let v = *(ptr.add(offset + usize_bytes) as *const usize);\n\n                // break if there is a matching byte\n                let zu = contains_zero_byte(u ^ repeated_x);\n                let zv = contains_zero_byte(v ^ repeated_x);\n                if zu || zv {\n                    break;\n                }\n            }\n            offset += usize_bytes * 2;\n        }\n    }\n\n    // find the byte after the point the body loop stopped\n    text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i)\n}\n\n/// Return the last index matching the byte `x` in `text`.\npub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {\n    // Scan for a single byte value by reading two `usize` words at a time.\n    //\n    // Split `text` in three parts\n    // - unaligned tail, after the last word aligned address in text\n    // - body, scan by 2 words at a time\n    // - the first remaining bytes, < 2 word size\n    let len = text.len();\n    let ptr = text.as_ptr();\n    type Chunk = usize;\n\n    let (min_aligned_offset, max_aligned_offset) = {\n        // We call this just to obtain the length of the prefix and suffix.\n        // In the middle we always process two chunks at once.\n        let (prefix, _, suffix) = unsafe { text.align_to::<(Chunk, Chunk)>() };\n        (prefix.len(), len - suffix.len())\n    };\n\n    let mut offset = max_aligned_offset;\n    if let Some(index) = text[offset..].iter().rposition(|elt| *elt == x) {\n        return Some(offset + index);\n    }\n\n    // search the body of the text, make sure we don't cross min_aligned_offset.\n    // offset is always aligned, so just testing `>` is sufficient and avoids possible\n    // overflow.\n    let repeated_x = repeat_byte(x);\n    let chunk_bytes = mem::size_of::<Chunk>();\n\n    while offset > min_aligned_offset {\n        unsafe {\n            let u = *(ptr.offset(offset as isize - 2 * chunk_bytes as isize) as *const Chunk);\n            let v = *(ptr.offset(offset as isize - chunk_bytes as isize) as *const Chunk);\n\n            // break if there is a matching byte\n            let zu = contains_zero_byte(u ^ repeated_x);\n            let zv = contains_zero_byte(v ^ repeated_x);\n            if zu || zv {\n                break;\n            }\n        }\n        offset -= 2 * chunk_bytes;\n    }\n\n    // find the byte before the point the body loop stopped\n    text[..offset].iter().rposition(|elt| *elt == x)\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// BoolTrie is a trie for representing a set of Unicode codepoints. It is\n/// implemented with postfix compression (sharing of identical child nodes),\n/// which gives both compact size and fast lookup.\n///\n/// The space of Unicode codepoints is divided into 3 subareas, each\n/// represented by a trie with different depth. In the first (0..0x800), there\n/// is no trie structure at all; each u64 entry corresponds to a bitvector\n/// effectively holding 64 bool values.\n///\n/// In the second (0x800..0x10000), each child of the root node represents a\n/// 64-wide subrange, but instead of storing the full 64-bit value of the leaf,\n/// the trie stores an 8-bit index into a shared table of leaf values. This\n/// exploits the fact that in reasonable sets, many such leaves can be shared.\n///\n/// In the third (0x10000..0x110000), each child of the root node represents a\n/// 4096-wide subrange, and the trie stores an 8-bit index into a 64-byte slice\n/// of a child tree. Each of these 64 bytes represents an index into the table\n/// of shared 64-bit leaf values. This exploits the sparse structure in the\n/// non-BMP range of most Unicode sets.\npub struct BoolTrie {\n    // 0..0x800 (corresponding to 1 and 2 byte utf-8 sequences)\n    pub r1: [u64; 32],   // leaves\n\n    // 0x800..0x10000 (corresponding to 3 byte utf-8 sequences)\n    pub r2: [u8; 992],      // first level\n    pub r3: &'static [u64],  // leaves\n\n    // 0x10000..0x110000 (corresponding to 4 byte utf-8 sequences)\n    pub r4: [u8; 256],       // first level\n    pub r5: &'static [u8],   // second level\n    pub r6: &'static [u64],  // leaves\n}\nimpl BoolTrie {\n    pub fn lookup(&self, c: char) -> bool {\n        let c = c as u32;\n        if c < 0x800 {\n            trie_range_leaf(c, self.r1[(c >> 6) as usize])\n        } else if c < 0x10000 {\n            let child = self.r2[(c >> 6) as usize - 0x20];\n            trie_range_leaf(c, self.r3[child as usize])\n        } else {\n            let child = self.r4[(c >> 12) as usize - 0x10];\n            let leaf = self.r5[((child as usize) << 6) + ((c >> 6) as usize & 0x3f)];\n            trie_range_leaf(c, self.r6[leaf as usize])\n        }\n    }\n}\n\npub struct SmallBoolTrie {\n    pub(crate) r1: &'static [u8],  // first level\n    pub(crate) r2: &'static [u64],  // leaves\n}\n\nimpl SmallBoolTrie {\n    pub fn lookup(&self, c: char) -> bool {\n        let c = c as u32;\n        match self.r1.get((c >> 6) as usize) {\n            Some(&child) => trie_range_leaf(c, self.r2[child as usize]),\n            None => false,\n        }\n    }\n}\n\nfn trie_range_leaf(c: u32, bitmap_chunk: u64) -> bool {\n    ((bitmap_chunk >> (c & 63)) & 1) != 0\n}\n","// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n// NOTE: The following code was generated by \"src/libcore/unicode/printable.py\",\n//       do not edit directly!\n\nfn check(x: u16, singletonuppers: &[(u8, u8)], singletonlowers: &[u8],\n         normal: &[u8]) -> bool {\n    let xupper = (x >> 8) as u8;\n    let mut lowerstart = 0;\n    for &(upper, lowercount) in singletonuppers {\n        let lowerend = lowerstart + lowercount as usize;\n        if xupper == upper {\n            for &lower in &singletonlowers[lowerstart..lowerend] {\n                if lower == x as u8 {\n                    return false;\n                }\n            }\n        } else if xupper < upper {\n            break;\n        }\n        lowerstart = lowerend;\n    }\n\n    let mut x = x as i32;\n    let mut normal = normal.iter().cloned();\n    let mut current = true;\n    while let Some(v) = normal.next() {\n        let len = if v & 0x80 != 0 {\n            ((v & 0x7f) as i32) << 8 | normal.next().unwrap() as i32\n        } else {\n            v as i32\n        };\n        x -= len;\n        if x < 0 {\n            break;\n        }\n        current = !current;\n    }\n    current\n}\n\npub(crate) fn is_printable(x: char) -> bool {\n    let x = x as u32;\n    let lower = x as u16;\n    if x < 0x10000 {\n        check(lower, SINGLETONS0U, SINGLETONS0L, NORMAL0)\n    } else if x < 0x20000 {\n        check(lower, SINGLETONS1U, SINGLETONS1L, NORMAL1)\n    } else {\n        if 0x2a6d7 <= x && x < 0x2a700 {\n            return false;\n        }\n        if 0x2b735 <= x && x < 0x2b740 {\n            return false;\n        }\n        if 0x2b81e <= x && x < 0x2b820 {\n            return false;\n        }\n        if 0x2cea2 <= x && x < 0x2ceb0 {\n            return false;\n        }\n        if 0x2ebe1 <= x && x < 0x2f800 {\n            return false;\n        }\n        if 0x2fa1e <= x && x < 0xe0100 {\n            return false;\n        }\n        if 0xe01f0 <= x && x < 0x110000 {\n            return false;\n        }\n        true\n    }\n}\n\nconst SINGLETONS0U: &'static [(u8, u8)] = &[\n    (0x00, 1),\n    (0x03, 5),\n    (0x05, 6),\n    (0x06, 3),\n    (0x07, 6),\n    (0x08, 8),\n    (0x09, 17),\n    (0x0a, 28),\n    (0x0b, 25),\n    (0x0c, 20),\n    (0x0d, 18),\n    (0x0e, 22),\n    (0x0f, 4),\n    (0x10, 3),\n    (0x12, 18),\n    (0x13, 9),\n    (0x16, 1),\n    (0x17, 5),\n    (0x18, 2),\n    (0x19, 3),\n    (0x1a, 7),\n    (0x1c, 2),\n    (0x1d, 1),\n    (0x1f, 22),\n    (0x20, 3),\n    (0x2b, 6),\n    (0x2c, 2),\n    (0x2d, 11),\n    (0x2e, 1),\n    (0x30, 3),\n    (0x31, 2),\n    (0x32, 2),\n    (0xa9, 2),\n    (0xaa, 4),\n    (0xab, 8),\n    (0xfa, 2),\n    (0xfb, 5),\n    (0xfd, 4),\n    (0xfe, 3),\n    (0xff, 9),\n];\nconst SINGLETONS0L: &'static [u8] = &[\n    0xad, 0x78, 0x79, 0x8b, 0x8d, 0xa2, 0x30, 0x57,\n    0x58, 0x8b, 0x8c, 0x90, 0x1c, 0x1d, 0xdd, 0x0e,\n    0x0f, 0x4b, 0x4c, 0xfb, 0xfc, 0x2e, 0x2f, 0x3f,\n    0x5c, 0x5d, 0x5f, 0xb5, 0xe2, 0x84, 0x8d, 0x8e,\n    0x91, 0x92, 0xa9, 0xb1, 0xba, 0xbb, 0xc5, 0xc6,\n    0xc9, 0xca, 0xde, 0xe4, 0xe5, 0xff, 0x00, 0x04,\n    0x11, 0x12, 0x29, 0x31, 0x34, 0x37, 0x3a, 0x3b,\n    0x3d, 0x49, 0x4a, 0x5d, 0x84, 0x8e, 0x92, 0xa9,\n    0xb1, 0xb4, 0xba, 0xbb, 0xc6, 0xca, 0xce, 0xcf,\n    0xe4, 0xe5, 0x00, 0x04, 0x0d, 0x0e, 0x11, 0x12,\n    0x29, 0x31, 0x34, 0x3a, 0x3b, 0x45, 0x46, 0x49,\n    0x4a, 0x5e, 0x64, 0x65, 0x84, 0x91, 0x9b, 0x9d,\n    0xc9, 0xce, 0xcf, 0x0d, 0x11, 0x29, 0x45, 0x49,\n    0x57, 0x64, 0x65, 0x8d, 0x91, 0xa9, 0xb4, 0xba,\n    0xbb, 0xc5, 0xc9, 0xdf, 0xe4, 0xe5, 0xf0, 0x04,\n    0x0d, 0x11, 0x45, 0x49, 0x64, 0x65, 0x80, 0x81,\n    0x84, 0xb2, 0xbc, 0xbe, 0xbf, 0xd5, 0xd7, 0xf0,\n    0xf1, 0x83, 0x85, 0x86, 0x89, 0x8b, 0x8c, 0x98,\n    0xa0, 0xa4, 0xa6, 0xa8, 0xa9, 0xac, 0xba, 0xbe,\n    0xbf, 0xc5, 0xc7, 0xce, 0xcf, 0xda, 0xdb, 0x48,\n    0x98, 0xbd, 0xcd, 0xc6, 0xce, 0xcf, 0x49, 0x4e,\n    0x4f, 0x57, 0x59, 0x5e, 0x5f, 0x89, 0x8e, 0x8f,\n    0xb1, 0xb6, 0xb7, 0xbf, 0xc1, 0xc6, 0xc7, 0xd7,\n    0x11, 0x16, 0x17, 0x5b, 0x5c, 0xf6, 0xf7, 0xfe,\n    0xff, 0x80, 0x0d, 0x6d, 0x71, 0xde, 0xdf, 0x0e,\n    0x0f, 0x1f, 0x6e, 0x6f, 0x1c, 0x1d, 0x5f, 0x7d,\n    0x7e, 0xae, 0xaf, 0xbb, 0xbc, 0xfa, 0x16, 0x17,\n    0x1e, 0x1f, 0x46, 0x47, 0x4e, 0x4f, 0x58, 0x5a,\n    0x5c, 0x5e, 0x7e, 0x7f, 0xb5, 0xc5, 0xd4, 0xd5,\n    0xdc, 0xf0, 0xf1, 0xf5, 0x72, 0x73, 0x8f, 0x74,\n    0x75, 0x96, 0x97, 0xc9, 0xff, 0x2f, 0x5f, 0x26,\n    0x2e, 0x2f, 0xa7, 0xaf, 0xb7, 0xbf, 0xc7, 0xcf,\n    0xd7, 0xdf, 0x9a, 0x40, 0x97, 0x98, 0x30, 0x8f,\n    0x1f, 0xff, 0xce, 0xff, 0x4e, 0x4f, 0x5a, 0x5b,\n    0x07, 0x08, 0x0f, 0x10, 0x27, 0x2f, 0xee, 0xef,\n    0x6e, 0x6f, 0x37, 0x3d, 0x3f, 0x42, 0x45, 0x90,\n    0x91, 0xfe, 0xff, 0x53, 0x67, 0x75, 0xc8, 0xc9,\n    0xd0, 0xd1, 0xd8, 0xd9, 0xe7, 0xfe, 0xff,\n];\nconst SINGLETONS1U: &'static [(u8, u8)] = &[\n    (0x00, 6),\n    (0x01, 1),\n    (0x03, 1),\n    (0x04, 2),\n    (0x08, 8),\n    (0x09, 2),\n    (0x0a, 5),\n    (0x0b, 2),\n    (0x10, 1),\n    (0x11, 4),\n    (0x12, 5),\n    (0x13, 17),\n    (0x14, 2),\n    (0x15, 2),\n    (0x17, 2),\n    (0x1a, 2),\n    (0x1c, 5),\n    (0x1d, 8),\n    (0x24, 1),\n    (0x6a, 3),\n    (0x6b, 2),\n    (0xbc, 2),\n    (0xd1, 2),\n    (0xd4, 12),\n    (0xd5, 9),\n    (0xd6, 2),\n    (0xd7, 2),\n    (0xda, 1),\n    (0xe0, 5),\n    (0xe8, 2),\n    (0xee, 32),\n    (0xf0, 4),\n    (0xf9, 4),\n];\nconst SINGLETONS1L: &'static [u8] = &[\n    0x0c, 0x27, 0x3b, 0x3e, 0x4e, 0x4f, 0x8f, 0x9e,\n    0x9e, 0x9f, 0x06, 0x07, 0x09, 0x36, 0x3d, 0x3e,\n    0x56, 0xf3, 0xd0, 0xd1, 0x04, 0x14, 0x18, 0x36,\n    0x37, 0x56, 0x57, 0xbd, 0x35, 0xce, 0xcf, 0xe0,\n    0x12, 0x87, 0x89, 0x8e, 0x9e, 0x04, 0x0d, 0x0e,\n    0x11, 0x12, 0x29, 0x31, 0x34, 0x3a, 0x45, 0x46,\n    0x49, 0x4a, 0x4e, 0x4f, 0x64, 0x65, 0x5a, 0x5c,\n    0xb6, 0xb7, 0x1b, 0x1c, 0x84, 0x85, 0x09, 0x37,\n    0x90, 0x91, 0xa8, 0x07, 0x0a, 0x3b, 0x3e, 0x66,\n    0x69, 0x8f, 0x92, 0x6f, 0x5f, 0xee, 0xef, 0x5a,\n    0x62, 0x9a, 0x9b, 0x27, 0x28, 0x55, 0x9d, 0xa0,\n    0xa1, 0xa3, 0xa4, 0xa7, 0xa8, 0xad, 0xba, 0xbc,\n    0xc4, 0x06, 0x0b, 0x0c, 0x15, 0x1d, 0x3a, 0x3f,\n    0x45, 0x51, 0xa6, 0xa7, 0xcc, 0xcd, 0xa0, 0x07,\n    0x19, 0x1a, 0x22, 0x25, 0xc5, 0xc6, 0x04, 0x20,\n    0x23, 0x25, 0x26, 0x28, 0x33, 0x38, 0x3a, 0x48,\n    0x4a, 0x4c, 0x50, 0x53, 0x55, 0x56, 0x58, 0x5a,\n    0x5c, 0x5e, 0x60, 0x63, 0x65, 0x66, 0x6b, 0x73,\n    0x78, 0x7d, 0x7f, 0x8a, 0xa4, 0xaa, 0xaf, 0xb0,\n    0xc0, 0xd0, 0x3f, 0x71, 0x72, 0x7b,\n];\nconst NORMAL0: &'static [u8] = &[\n    0x00, 0x20,\n    0x5f, 0x22,\n    0x82, 0xdf, 0x04,\n    0x82, 0x44, 0x08,\n    0x1b, 0x04,\n    0x06, 0x11,\n    0x81, 0xac, 0x0e,\n    0x80, 0xab, 0x35,\n    0x1e, 0x15,\n    0x80, 0xe0, 0x03,\n    0x19, 0x08,\n    0x01, 0x04,\n    0x2f, 0x04,\n    0x34, 0x04,\n    0x07, 0x03,\n    0x01, 0x07,\n    0x06, 0x07,\n    0x11, 0x0a,\n    0x50, 0x0f,\n    0x12, 0x07,\n    0x55, 0x08,\n    0x02, 0x04,\n    0x1c, 0x0a,\n    0x09, 0x03,\n    0x08, 0x03,\n    0x07, 0x03,\n    0x02, 0x03,\n    0x03, 0x03,\n    0x0c, 0x04,\n    0x05, 0x03,\n    0x0b, 0x06,\n    0x01, 0x0e,\n    0x15, 0x05,\n    0x3a, 0x03,\n    0x11, 0x07,\n    0x06, 0x05,\n    0x10, 0x08,\n    0x56, 0x07,\n    0x02, 0x07,\n    0x15, 0x0d,\n    0x50, 0x04,\n    0x43, 0x03,\n    0x2d, 0x03,\n    0x01, 0x04,\n    0x11, 0x06,\n    0x0f, 0x0c,\n    0x3a, 0x04,\n    0x1d, 0x25,\n    0x0d, 0x06,\n    0x4c, 0x20,\n    0x6d, 0x04,\n    0x6a, 0x25,\n    0x80, 0xc8, 0x05,\n    0x82, 0xb0, 0x03,\n    0x1a, 0x06,\n    0x82, 0xfd, 0x03,\n    0x59, 0x07,\n    0x15, 0x0b,\n    0x17, 0x09,\n    0x14, 0x0c,\n    0x14, 0x0c,\n    0x6a, 0x06,\n    0x0a, 0x06,\n    0x1a, 0x06,\n    0x59, 0x07,\n    0x2b, 0x05,\n    0x46, 0x0a,\n    0x2c, 0x04,\n    0x0c, 0x04,\n    0x01, 0x03,\n    0x31, 0x0b,\n    0x2c, 0x04,\n    0x1a, 0x06,\n    0x0b, 0x03,\n    0x80, 0xac, 0x06,\n    0x0a, 0x06,\n    0x1f, 0x41,\n    0x4c, 0x04,\n    0x2d, 0x03,\n    0x74, 0x08,\n    0x3c, 0x03,\n    0x0f, 0x03,\n    0x3c, 0x07,\n    0x38, 0x08,\n    0x2a, 0x06,\n    0x82, 0xff, 0x11,\n    0x18, 0x08,\n    0x2f, 0x11,\n    0x2d, 0x03,\n    0x20, 0x10,\n    0x21, 0x0f,\n    0x80, 0x8c, 0x04,\n    0x82, 0x97, 0x19,\n    0x0b, 0x15,\n    0x88, 0x94, 0x05,\n    0x2f, 0x05,\n    0x3b, 0x07,\n    0x02, 0x0e,\n    0x18, 0x09,\n    0x80, 0xaf, 0x31,\n    0x74, 0x0c,\n    0x80, 0xd6, 0x1a,\n    0x0c, 0x05,\n    0x80, 0xff, 0x05,\n    0x80, 0xb6, 0x05,\n    0x24, 0x0c,\n    0x9b, 0xc6, 0x0a,\n    0xd2, 0x30, 0x10,\n    0x84, 0x8d, 0x03,\n    0x37, 0x09,\n    0x81, 0x5c, 0x14,\n    0x80, 0xb8, 0x08,\n    0x80, 0xba, 0x3d,\n    0x35, 0x04,\n    0x0a, 0x06,\n    0x38, 0x08,\n    0x46, 0x08,\n    0x0c, 0x06,\n    0x74, 0x0b,\n    0x1e, 0x03,\n    0x5a, 0x04,\n    0x59, 0x09,\n    0x80, 0x83, 0x18,\n    0x1c, 0x0a,\n    0x16, 0x09,\n    0x46, 0x0a,\n    0x80, 0x8a, 0x06,\n    0xab, 0xa4, 0x0c,\n    0x17, 0x04,\n    0x31, 0xa1, 0x04,\n    0x81, 0xda, 0x26,\n    0x07, 0x0c,\n    0x05, 0x05,\n    0x80, 0xa5, 0x11,\n    0x81, 0x6d, 0x10,\n    0x78, 0x28,\n    0x2a, 0x06,\n    0x4c, 0x04,\n    0x80, 0x8d, 0x04,\n    0x80, 0xbe, 0x03,\n    0x1b, 0x03,\n    0x0f, 0x0d,\n];\nconst NORMAL1: &'static [u8] = &[\n    0x5e, 0x22,\n    0x7b, 0x05,\n    0x03, 0x04,\n    0x2d, 0x03,\n    0x65, 0x04,\n    0x01, 0x2f,\n    0x2e, 0x80, 0x82,\n    0x1d, 0x03,\n    0x31, 0x0f,\n    0x1c, 0x04,\n    0x24, 0x09,\n    0x1e, 0x05,\n    0x2b, 0x05,\n    0x44, 0x04,\n    0x0e, 0x2a,\n    0x80, 0xaa, 0x06,\n    0x24, 0x04,\n    0x24, 0x04,\n    0x28, 0x08,\n    0x34, 0x0b,\n    0x01, 0x80, 0x90,\n    0x81, 0x37, 0x09,\n    0x16, 0x0a,\n    0x08, 0x80, 0x98,\n    0x39, 0x03,\n    0x63, 0x08,\n    0x09, 0x30,\n    0x16, 0x05,\n    0x21, 0x03,\n    0x1b, 0x05,\n    0x01, 0x40,\n    0x38, 0x04,\n    0x4b, 0x05,\n    0x2f, 0x04,\n    0x0a, 0x07,\n    0x09, 0x07,\n    0x40, 0x20,\n    0x27, 0x04,\n    0x0c, 0x09,\n    0x36, 0x03,\n    0x3a, 0x05,\n    0x1a, 0x07,\n    0x04, 0x0c,\n    0x07, 0x50,\n    0x49, 0x37,\n    0x33, 0x0d,\n    0x33, 0x07,\n    0x2e, 0x08,\n    0x0a, 0x81, 0x26,\n    0x1f, 0x80, 0x81,\n    0x28, 0x08,\n    0x2a, 0x80, 0xa6,\n    0x4e, 0x04,\n    0x1e, 0x0f,\n    0x43, 0x0e,\n    0x19, 0x07,\n    0x0a, 0x06,\n    0x47, 0x09,\n    0x27, 0x09,\n    0x75, 0x0b,\n    0x3f, 0x41,\n    0x2a, 0x06,\n    0x3b, 0x05,\n    0x0a, 0x06,\n    0x51, 0x06,\n    0x01, 0x05,\n    0x10, 0x03,\n    0x05, 0x80, 0x8b,\n    0x5f, 0x21,\n    0x48, 0x08,\n    0x0a, 0x80, 0xa6,\n    0x5e, 0x22,\n    0x45, 0x0b,\n    0x0a, 0x06,\n    0x0d, 0x13,\n    0x38, 0x08,\n    0x0a, 0x36,\n    0x2c, 0x04,\n    0x10, 0x80, 0xc0,\n    0x3c, 0x64,\n    0x53, 0x0c,\n    0x01, 0x81, 0x00,\n    0x48, 0x08,\n    0x53, 0x1d,\n    0x39, 0x81, 0x07,\n    0x46, 0x0a,\n    0x1d, 0x03,\n    0x47, 0x49,\n    0x37, 0x03,\n    0x0e, 0x08,\n    0x0a, 0x06,\n    0x39, 0x07,\n    0x0a, 0x81, 0x36,\n    0x19, 0x81, 0x07,\n    0x83, 0x9a, 0x66,\n    0x75, 0x0b,\n    0x80, 0xc4, 0x8a, 0xbc,\n    0x84, 0x2f, 0x8f, 0xd1,\n    0x82, 0x47, 0xa1, 0xb9,\n    0x82, 0x39, 0x07,\n    0x2a, 0x04,\n    0x02, 0x60,\n    0x26, 0x0a,\n    0x46, 0x0a,\n    0x28, 0x05,\n    0x13, 0x82, 0xb0,\n    0x5b, 0x65,\n    0x45, 0x0b,\n    0x2f, 0x10,\n    0x11, 0x40,\n    0x02, 0x1e,\n    0x97, 0xf2, 0x0e,\n    0x82, 0xf3, 0xa5, 0x0d,\n    0x81, 0x1f, 0x51,\n    0x81, 0x8c, 0x89, 0x04,\n    0x6b, 0x05,\n    0x0d, 0x03,\n    0x09, 0x07,\n    0x10, 0x93, 0x60,\n    0x80, 0xf6, 0x0a,\n    0x73, 0x08,\n    0x6e, 0x17,\n    0x46, 0x80, 0x9a,\n    0x14, 0x0c,\n    0x57, 0x09,\n    0x19, 0x80, 0x87,\n    0x81, 0x47, 0x03,\n    0x85, 0x42, 0x0f,\n    0x15, 0x85, 0x50,\n    0x2b, 0x87, 0xd5,\n    0x80, 0xd7, 0x29,\n    0x4b, 0x05,\n    0x0a, 0x04,\n    0x02, 0x83, 0x11,\n    0x44, 0x81, 0x4b,\n    0x3c, 0x06,\n    0x01, 0x04,\n    0x55, 0x05,\n    0x1b, 0x34,\n    0x02, 0x81, 0x0e,\n    0x2c, 0x04,\n    0x64, 0x0c,\n    0x56, 0x0a,\n    0x0d, 0x03,\n    0x5c, 0x04,\n    0x3d, 0x39,\n    0x1d, 0x0d,\n    0x2c, 0x04,\n    0x09, 0x07,\n    0x02, 0x0e,\n    0x06, 0x80, 0x9a,\n    0x83, 0xd5, 0x0b,\n    0x0d, 0x03,\n    0x0a, 0x06,\n    0x74, 0x0c,\n    0x59, 0x27,\n    0x0c, 0x04,\n    0x38, 0x08,\n    0x0a, 0x06,\n    0x28, 0x08,\n    0x1e, 0x52,\n    0x0c, 0x04,\n    0x67, 0x03,\n    0x29, 0x0d,\n    0x0a, 0x06,\n    0x03, 0x0d,\n    0x30, 0x60,\n    0x0e, 0x85, 0x92,\n];\n","// Copyright 2012-2018 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n// NOTE: The following code was generated by \"./unicode.py\", do not edit directly\n\n#![allow(missing_docs, non_upper_case_globals, non_snake_case)]\n\nuse unicode::version::UnicodeVersion;\nuse unicode::bool_trie::{BoolTrie, SmallBoolTrie};\n\n/// The version of [Unicode](http://www.unicode.org/) that the Unicode parts of\n/// `char` and `str` methods are based on.\n#[unstable(feature = \"unicode_version\", issue = \"49726\")]\npub const UNICODE_VERSION: UnicodeVersion = UnicodeVersion {\n    major: 11,\n    minor: 0,\n    micro: 0,\n    _priv: (),\n};\npub mod general_category {\n    pub const Cc_table: &super::SmallBoolTrie = &super::SmallBoolTrie {\n        r1: &[\n            0, 1, 0\n        ],\n        r2: &[\n            0x00000000ffffffff, 0x8000000000000000\n        ],\n    };\n\n    pub fn Cc(c: char) -> bool {\n        Cc_table.lookup(c)\n    }\n\n    pub const N_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x03ff000000000000, 0x0000000000000000, 0x720c000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x000003ff00000000, 0x0000000000000000, 0x03ff000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000000000003ff\n        ],\n        r2: [\n            0, 0, 0, 0, 0, 1, 0, 2, 0, 1, 0, 1, 0, 3, 0, 4, 0, 5, 0, 1, 0, 6, 0, 1, 0, 7, 0, 7, 8,\n            0, 0, 0, 0, 9, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 11, 0, 0, 0, 12, 7, 0, 0, 0, 0, 13, 0, 14, 0, 0, 15, 0, 0, 7, 16, 0, 0, 15, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 9, 0, 0, 18, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            20, 21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 0, 0, 27, 0, 28,\n            29, 30, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28,\n            0, 0, 1, 0, 0, 0, 0, 31, 0, 0, 7, 9, 0, 0, 32, 0, 7, 0, 0, 0, 0, 0, 16, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0\n        ],\n        r3: &[\n            0x0000000000000000, 0x0000ffc000000000, 0x03f0ffc000000000, 0x00fcffc000000000,\n            0x0007ffc000000000, 0x7f00ffc000000000, 0x01ffffc07f000000, 0x0000000003ff0000,\n            0x000fffff00000000, 0x00000000000003ff, 0x1ffffe0000000000, 0x0001c00000000000,\n            0x03ff03ff00000000, 0x000000000000ffc0, 0x0000000007ff0000, 0x0000000003ff03ff,\n            0x03ff000000000000, 0x03f1000000000000, 0xffffffffffff0000, 0x00000000000003e7,\n            0xffffffff00000000, 0x000000000fffffff, 0xfffffc0000000000, 0xffc0000000000000,\n            0x00000000000fffff, 0x2000000000000000, 0x070003fe00000080, 0x00000000003c0000,\n            0x000003ff00000000, 0x00000000fffeff00, 0xfffe0000000003ff, 0x003f000000000000,\n            0x03ff000003ff0000\n        ],\n        r4: [\n            0, 1, 2, 3, 3, 3, 4, 3, 3, 3, 3, 3, 3, 5, 6, 7, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3\n        ],\n        r5: &[\n            0, 0, 0, 0, 1, 2, 3, 0, 0, 0, 0, 4, 5, 6, 0, 7, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 9, 10, 11, 12, 0, 13, 14, 0, 15, 16, 17, 0, 18, 19, 0, 0, 0, 0, 20, 21, 0,\n            0, 0, 0, 22, 0, 0, 23, 24, 0, 0, 0, 25, 0, 21, 26, 0, 0, 27, 0, 0, 0, 21, 0, 0, 0, 0, 0,\n            28, 0, 28, 0, 0, 0, 0, 0, 28, 0, 29, 30, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 32, 0, 0, 0, 28, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 33, 34, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 35, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 37, 0, 38, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 0, 28, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0x000fffffffffff80, 0x01ffffffffffffff, 0x0000000000000c00,\n            0x0ffffffe00000000, 0x0000000f00000000, 0x0000000000000402, 0x00000000003e0000,\n            0x000003ff00000000, 0xfe000000ff000000, 0x0000ff8000000000, 0xf800000000000000,\n            0x000000000fc00000, 0x3000000000000000, 0xfffffffffffcffff, 0x60000000000001ff,\n            0x00000000e0000000, 0x0000f80000000000, 0xff000000ff000000, 0x0000fe0000000000,\n            0xfc00000000000000, 0x03ff000000000000, 0x7fffffff00000000, 0x0000007fe0000000,\n            0x00000000001e0000, 0x0000fffffffc0000, 0xffc0000000000000, 0x001ffffe03ff0000,\n            0x0000000003ff0000, 0x00000000000003ff, 0x0fff000000000000, 0x0007ffff00000000,\n            0x00001fffffff0000, 0xffffffffffffffff, 0x00007fffffffffff, 0x00000003fbff0000,\n            0x00000000007fffff, 0x000fffff00000000, 0x01ffffff00000000, 0xffffffffffffc000,\n            0x000000000000ff80, 0xfffe000000000000, 0x001eefffffffffff, 0x0000000000001fff\n        ],\n    };\n\n    pub fn N(c: char) -> bool {\n        N_table.lookup(c)\n    }\n\n}\n\npub mod derived_property {\n    pub const Alphabetic_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x07fffffe07fffffe, 0x0420040000000000, 0xff7fffffff7fffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000501f0003ffc3,\n            0x0000000000000000, 0xbcdf000000000020, 0xfffffffbffffd740, 0xffbfffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffc03, 0xffffffffffffffff,\n            0xfffeffffffffffff, 0xffffffff027fffff, 0xbfff0000000001ff, 0x000787ffffff00b6,\n            0xffffffff07ff0000, 0xffffc000feffffff, 0xffffffffffffffff, 0x9c00e1fe1fefffff,\n            0xffffffffffff0000, 0xffffffffffffe000, 0x0003ffffffffffff, 0x043007fffffffc00\n        ],\n        r2: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n            24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 36, 36, 36, 36, 37, 38, 39, 40, 41,\n            42, 43, 44, 36, 36, 36, 36, 36, 36, 36, 36, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,\n            56, 57, 58, 59, 60, 61, 62, 31, 63, 64, 65, 66, 55, 67, 68, 69, 36, 36, 36, 70, 36, 36,\n            36, 36, 71, 72, 73, 74, 31, 75, 76, 31, 77, 78, 79, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 80, 81, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 82, 83, 36, 84, 85, 86, 87, 88, 89, 31, 31, 31,\n            31, 31, 31, 31, 90, 44, 91, 92, 93, 36, 94, 95, 31, 31, 31, 31, 31, 31, 31, 31, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 55, 31, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 96, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 97, 98, 36, 36, 36, 36, 99, 100, 36, 96, 101, 36, 102,\n            103, 104, 105, 36, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 36, 117, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,\n            36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 118, 119,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31,\n            36, 36, 36, 36, 36, 120, 36, 121, 122, 123, 124, 125, 36, 36, 36, 36, 126, 127, 128,\n            129, 31, 130, 36, 131, 132, 133, 113, 134\n        ],\n        r3: &[\n            0x00001ffffcffffff, 0x000007ff01ffffff, 0x3fdfffff00000000, 0xffff03f8fff00000,\n            0xefffffffffffffff, 0xfffe000fffe1dfff, 0xe3c5fdfffff99fef, 0x1003000fb080599f,\n            0xc36dfdfffff987ee, 0x003f00005e021987, 0xe3edfdfffffbbfee, 0x1e00000f00011bbf,\n            0xe3edfdfffff99fee, 0x0002000fb0c0199f, 0xc3ffc718d63dc7ec, 0x0000000000811dc7,\n            0xe3fffdfffffddfef, 0x0000000f07601ddf, 0xe3effdfffffddfef, 0x0006000f40601ddf,\n            0xe7fffffffffddfef, 0xfc00000f80f05ddf, 0x2ffbfffffc7fffec, 0x000c0000ff5f807f,\n            0x07fffffffffffffe, 0x000000000000207f, 0x3bffecaefef02596, 0x00000000f000205f,\n            0x0000000000000001, 0xfffe1ffffffffeff, 0x1ffffffffeffff03, 0x0000000000000000,\n            0xf97fffffffffffff, 0xffffc1e7ffff0000, 0xffffffff3000407f, 0xf7ffffffffff20bf,\n            0xffffffffffffffff, 0xffffffff3d7f3dff, 0x7f3dffffffff3dff, 0xffffffffff7fff3d,\n            0xffffffffff3dffff, 0x0000000087ffffff, 0xffffffff0000ffff, 0x3f3fffffffffffff,\n            0xfffffffffffffffe, 0xffff9fffffffffff, 0xffffffff07fffffe, 0x01ffc7ffffffffff,\n            0x000fffff000fdfff, 0x000ddfff000fffff, 0xffcfffffffffffff, 0x00000000108001ff,\n            0xffffffff00000000, 0x01ffffffffffffff, 0xffff07ffffffffff, 0x003fffffffffffff,\n            0x01ff0fff7fffffff, 0x001f3fffffff0000, 0xffff0fffffffffff, 0x00000000000003ff,\n            0xffffffff0fffffff, 0x001ffffe7fffffff, 0x0000008000000000, 0xffefffffffffffff,\n            0x0000000000000fef, 0xfc00f3ffffffffff, 0x0003ffbfffffffff, 0x3ffffffffc00e000,\n            0xe7ffffffffff01ff, 0x006fde0000000000, 0x001fff8000000000, 0xffffffff3f3fffff,\n            0x3fffffffaaff3f3f, 0x5fdfffffffffffff, 0x1fdc1fff0fcf1fdc, 0x8002000000000000,\n            0x000000001fff0000, 0xf3ffbd503e2ffc84, 0xffffffff000043e0, 0x00000000000001ff,\n            0xffc0000000000000, 0x000003ffffffffff, 0xffff7fffffffffff, 0xffffffff7fffffff,\n            0x000c781fffffffff, 0xffff20bfffffffff, 0x000080ffffffffff, 0x7f7f7f7f007fffff,\n            0xffffffff7f7f7f7f, 0x0000800000000000, 0x1f3e03fe000000e0, 0xfffffffee07fffff,\n            0xf7ffffffffffffff, 0xfffeffffffffffe0, 0x07ffffff00007fff, 0xffff000000000000,\n            0x0000ffffffffffff, 0x0000000000001fff, 0x3fffffffffff0000, 0x00000c00ffff1fff,\n            0x8ff07fffffffffff, 0xfffffffcff800000, 0x03fffffffffff9ff, 0xff80000000000000,\n            0x000000fffffff7bb, 0x000fffffffffffff, 0x68fc00000000002f, 0xffff07fffffffc00,\n            0x1fffffff0007ffff, 0xfff7ffffffffffff, 0x7c00ffdf00008000, 0x007fffffffffffff,\n            0xc47fffff00003fff, 0x7fffffffffffffff, 0x003cffff38000005, 0xffff7f7f007e7e7e,\n            0xffff003ff7ffffff, 0x000007ffffffffff, 0xffff000fffffffff, 0x0ffffffffffff87f,\n            0xffff3fffffffffff, 0x0000000003ffffff, 0x5f7ffdffe0f8007f, 0xffffffffffffffdb,\n            0x0003ffffffffffff, 0xfffffffffff80000, 0x3fffffffffffffff, 0xffffffffffff0000,\n            0xfffffffffffcffff, 0x0fff0000000000ff, 0xffdf000000000000, 0x1fffffffffffffff,\n            0x07fffffe00000000, 0xffffffc007fffffe, 0x000000001cfcfcfc\n        ],\n        r4: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 12, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 13, 14,\n            15, 7, 16, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n        ],\n        r5: &[\n            0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, 4, 2, 2, 2,\n            2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, 28, 29, 30, 4, 2, 31, 32,\n            32, 33, 4, 4, 4, 4, 4, 4, 4, 34, 35, 4, 4, 2, 35, 36, 37, 32, 38, 2, 39, 40, 4, 41, 42,\n            43, 44, 4, 4, 2, 45, 2, 46, 4, 4, 47, 48, 49, 50, 28, 4, 51, 4, 4, 4, 52, 4, 53, 54, 4,\n            4, 4, 4, 55, 56, 57, 52, 4, 4, 4, 4, 58, 59, 60, 4, 61, 62, 63, 4, 4, 4, 4, 64, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 65, 4, 2, 66, 2, 2, 2, 67, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 66, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            2, 2, 2, 2, 2, 2, 2, 2, 52, 20, 4, 69, 16, 70, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4,\n            4, 2, 72, 73, 74, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 76, 2, 2, 2, 2, 2,\n            77, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 78, 79, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 80, 81, 82, 83, 84, 2, 2, 2, 2, 85, 86, 87, 88, 89,\n            90, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 92, 2, 93, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 94, 95, 96, 4, 4, 4, 4, 4, 4, 4, 4, 4, 76, 97, 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 99, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 10, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 100, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 101, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 102, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4\n        ],\n        r6: &[\n            0xb7ffff7fffffefff, 0x000000003fff3fff, 0xffffffffffffffff, 0x07ffffffffffffff,\n            0x0000000000000000, 0x001fffffffffffff, 0xffffffff1fffffff, 0x000000000001ffff,\n            0xffffe000ffffffff, 0x07ffffffffff07ff, 0xffffffff3fffffff, 0x00000000003eff0f,\n            0xffff00003fffffff, 0x0fffffffff0fffff, 0xffff00ffffffffff, 0x0000000fffffffff,\n            0x007fffffffffffff, 0x000000ff003fffff, 0x91bffffffffffd3f, 0x007fffff003fffff,\n            0x000000007fffffff, 0x0037ffff00000000, 0x03ffffff003fffff, 0xc0ffffffffffffff,\n            0x003ffffffeeff06f, 0x1fffffff00000000, 0x000000001fffffff, 0x0000001ffffffeff,\n            0x003fffffffffffff, 0x0007ffff003fffff, 0x000000000003ffff, 0x00000000000001ff,\n            0x0007ffffffffffff, 0x000000ffffffffff, 0xffff00801fffffff, 0x000000000000003f,\n            0x01fffffffffffffc, 0x000001ffffff0000, 0x0047ffffffff0070, 0x000000001400001e,\n            0x409ffffffffbffff, 0xffff01ffbfffbd7f, 0x000001ffffffffff, 0xe3edfdfffff99fef,\n            0x0000000fe081199f, 0x00000000000007bb, 0x00000000000000b3, 0x7f3fffffffffffff,\n            0x000000003f000000, 0x7fffffffffffffff, 0x0000000000000011, 0x000007ffe7ffffff,\n            0x01ffffffffffffff, 0xffffffff00000000, 0x80000000ffffffff, 0x7fe7ffffffffffff,\n            0xffffffffffff0000, 0x0000000020ffffcf, 0x7f7ffffffffffdff, 0xfffc000000000001,\n            0x007ffefffffcffff, 0xb47ffffffffffb7f, 0xfffffdbf000000cb, 0x00000000017b7fff,\n            0x007fffff00000000, 0x0000000003ffffff, 0x00007fffffffffff, 0x000000000000000f,\n            0x000000000000007f, 0x00003fffffff0000, 0xe0fffff80000000f, 0x000000000000ffff,\n            0x7fffffffffff001f, 0x00000000fff80000, 0x0000000300000000, 0x0003ffffffffffff,\n            0xffff000000000000, 0x0fffffffffffffff, 0x1fff07ffffffffff, 0x0000000043ff01ff,\n            0xffffffffffdfffff, 0xebffde64dfffffff, 0xffffffffffffffef, 0x7bffffffdfdfe7bf,\n            0xfffffffffffdfc5f, 0xffffff3fffffffff, 0xf7fffffff7fffffd, 0xffdfffffffdfffff,\n            0xffff7fffffff7fff, 0xfffffdfffffffdff, 0x0000000000000ff7, 0x000007dbf9ffff7f,\n            0x000000000000001f, 0x000000000000008f, 0x0af7fe96ffffffef, 0x5ef7f796aa96ea84,\n            0x0ffffbee0ffffbff, 0xffff03ffffff03ff, 0x00000000000003ff, 0x00000000007fffff,\n            0xffff0003ffffffff, 0x00000001ffffffff, 0x000000003fffffff\n        ],\n    };\n\n    pub fn Alphabetic(c: char) -> bool {\n        Alphabetic_table.lookup(c)\n    }\n\n    pub const Case_Ignorable_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0400408000000000, 0x0000000140000000, 0x0190a10000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0xffff000000000000, 0xffffffffffffffff,\n            0xffffffffffffffff, 0x0430ffffffffffff, 0x00000000000000b0, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x00000000000003f8, 0x0000000000000000,\n            0x0000000000000000, 0x0000000002000000, 0xbffffffffffe0000, 0x00100000000000b6,\n            0x0000000017ff003f, 0x00010000fffff801, 0x0000000000000000, 0x00003dffbfc00000,\n            0xffff000000028000, 0x00000000000007ff, 0x0001ffc000000000, 0x243ff80000000000\n        ],\n        r2: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 10, 11, 12, 13, 14, 15, 16, 11, 17, 18, 19, 2, 20, 21,\n            22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 35, 36, 37, 38, 39, 40, 2, 41, 2, 2, 2, 42, 43, 44, 2,\n            45, 46, 47, 48, 49, 50, 2, 51, 52, 53, 54, 55, 2, 2, 2, 2, 2, 2, 56, 57, 58, 59, 60, 61,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 62, 2, 63, 2, 64, 2, 65, 66, 2, 2, 2, 2,\n            2, 2, 2, 67, 2, 68, 69, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 70, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 50, 2, 2, 2, 2, 71, 72, 73, 74, 75, 76, 77, 78, 79, 2, 2, 80, 81,\n            82, 83, 84, 85, 86, 87, 88, 2, 89, 2, 90, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 91, 2, 92, 93, 2, 2, 2, 2, 2, 2, 2, 2, 94, 95, 2, 96,\n            97, 98, 99, 100\n        ],\n        r3: &[\n            0x00003fffffc00000, 0x000000000e000000, 0x0000000000000000, 0xfffffffffff80000,\n            0x1400000000000007, 0x0002000c00fe21fe, 0x1000000000000002, 0x4000000c0000201e,\n            0x1000000000000006, 0x0023000000023986, 0xfc00000c000021be, 0x9000000000000002,\n            0x0000000c0040201e, 0x0000000000000004, 0x0000000000002001, 0xc000000000000011,\n            0x0000000c00603dc1, 0x0000000c00003040, 0x1800000000000003, 0x0000000c0000201e,\n            0x00000000005c0400, 0x07f2000000000000, 0x0000000000007fc0, 0x1bf2000000000000,\n            0x0000000000003f40, 0x02a0000003000000, 0x7ffe000000000000, 0x1ffffffffeffe0df,\n            0x0000000000000040, 0x66fde00000000000, 0x001e0001c3000000, 0x0000000020002064,\n            0x1000000000000000, 0x00000000e0000000, 0x001c0000001c0000, 0x000c0000000c0000,\n            0x3fb0000000000000, 0x00000000208ffe40, 0x0000000000007800, 0x0000000000000008,\n            0x0000020000000060, 0x0e04018700000000, 0x0000000009800000, 0x9ff81fe57f400000,\n            0x7fff008000000000, 0x17d000000000000f, 0x000ff80000000004, 0x00003b3c00000003,\n            0x0003a34000000000, 0x00cff00000000000, 0x3f00000000000000, 0x031021fdfff70000,\n            0xfffff00000000000, 0x010007ffffffffff, 0xfffffffff8000000, 0xfbffffffffffffff,\n            0xa000000000000000, 0x6000e000e000e003, 0x00007c900300f800, 0x8002ffdf00000000,\n            0x000000001fff0000, 0x0001ffffffff0000, 0x3000000000000000, 0x0003800000000000,\n            0x8000800000000000, 0xffffffff00000000, 0x0000800000000000, 0x083e3c0000000020,\n            0x000000007e000000, 0x7000000000000000, 0x0000000000200000, 0x0000000000001000,\n            0xbff7800000000000, 0x00000000f0000000, 0x0003000000000000, 0x00000003ffffffff,\n            0x0001000000000000, 0x0000000000000700, 0x0300000000000000, 0x0000006000000844,\n            0x8003ffff00000030, 0x00003fc000000000, 0x000000000003ff80, 0x13c8000000000007,\n            0x0000006000008000, 0x00667e0000000000, 0x1001000000001008, 0xc19d000000000000,\n            0x0058300020000002, 0x00000000f8000000, 0x0000212000000000, 0x0000000040000000,\n            0xfffc000000000000, 0x0000000000000003, 0x0000ffff0008ffff, 0x0000000000240000,\n            0x8000000000000000, 0x4000000004004080, 0x0001000000000001, 0x00000000c0000000,\n            0x0e00000800000000\n        ],\n        r4: [\n            0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n        ],\n        r5: &[\n            0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0,\n            0, 0, 0, 7, 0, 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 0, 0, 17, 18, 19, 0, 0, 20, 21, 22,\n            23, 0, 0, 24, 25, 26, 27, 28, 0, 29, 0, 0, 0, 30, 0, 0, 0, 0, 0, 0, 0, 31, 32, 33, 0, 0,\n            0, 0, 0, 34, 0, 35, 0, 36, 37, 38, 0, 0, 0, 0, 39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 40, 41, 42, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 43, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 47, 0, 0, 48, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 50, 51, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 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, 0, 54, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 56, 57, 0, 0, 57, 57, 57, 58, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0x2000000000000000, 0x0000000100000000, 0x07c0000000000000,\n            0x870000000000f06e, 0x0000006000000000, 0x000000f000000000, 0x000000000001ffc0,\n            0xff00000000000002, 0x800000000000007f, 0x2678000000000003, 0x0000000000002000,\n            0x001fef8000000007, 0x0008000000000000, 0x7fc0000000000003, 0x0000000000001e00,\n            0x40d3800000000000, 0x000007f880000000, 0x1800000000000003, 0x001f1fc000000001,\n            0xff00000000000000, 0x000000004000005c, 0x85f8000000000000, 0x000000000000000d,\n            0xb03c000000000000, 0x0000000030000001, 0xa7f8000000000000, 0x0000000000000001,\n            0x00bf280000000000, 0x00000fbce0000000, 0x06ff800000000000, 0x79f80000000007fe,\n            0x000000000e7e0080, 0x00000000037ffc00, 0xbf7f000000000000, 0x006dfcfffffc0000,\n            0xb47e000000000000, 0x00000000000000bf, 0x0000000000a30000, 0x0018000000000000,\n            0x001f000000000000, 0x007f000000000000, 0x000000000000000f, 0x00000000ffff8000,\n            0x0000000300000000, 0x0000000f60000000, 0xfff8038000000000, 0x00003c0000000fe7,\n            0x000000000000001c, 0xf87fffffffffffff, 0x00201fffffffffff, 0x0000fffef8000010,\n            0x000007dbf9ffff7f, 0x00000000007f0000, 0x00000000000007f0, 0xf800000000000000,\n            0xffffffff00000002, 0xffffffffffffffff, 0x0000ffffffffffff\n        ],\n    };\n\n    pub fn Case_Ignorable(c: char) -> bool {\n        Case_Ignorable_table.lookup(c)\n    }\n\n    pub const Cased_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x07fffffe07fffffe, 0x0420040000000000, 0xff7fffffff7fffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xf7ffffffffffffff, 0xfffffffffffffff0,\n            0xffffffffffffffff, 0xffffffffffffffff, 0x01ffffffffefffff, 0x0000001f00000003,\n            0x0000000000000000, 0xbccf000000000020, 0xfffffffbffffd740, 0xffbfffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffc03, 0xffffffffffffffff,\n            0xfffeffffffffffff, 0xffffffff007fffff, 0x00000000000001ff, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000\n        ],\n        r2: [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 5, 5,\n            0, 5, 5, 5, 5, 6, 7, 8, 9, 0, 10, 11, 0, 12, 13, 14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            15, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 17, 18, 5, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22,\n            0, 23, 5, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 26, 27, 5, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 29, 30, 0, 0\n        ],\n        r3: &[\n            0x0000000000000000, 0xffffffff00000000, 0xe7ffffffffff20bf, 0x3f3fffffffffffff,\n            0xe7ffffffffff01ff, 0xffffffffffffffff, 0xffffffff3f3fffff, 0x3fffffffaaff3f3f,\n            0x5fdfffffffffffff, 0x1fdc1fff0fcf1fdc, 0x8002000000000000, 0x000000001fff0000,\n            0xf21fbd503e2ffc84, 0xffffffff000043e0, 0x0000000000000018, 0xffc0000000000000,\n            0x000003ffffffffff, 0xffff7fffffffffff, 0xffffffff7fffffff, 0x000c781fffffffff,\n            0x000020bfffffffff, 0x00003fffffffffff, 0x000000003fffffff, 0xfffffffc00000000,\n            0x03ffffffffff78ff, 0x0700000000000000, 0xffff000000000000, 0xffff003ff7ffffff,\n            0x0000000000f8007f, 0x07fffffe00000000, 0x0000000007fffffe\n        ],\n        r4: [\n            0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n        ],\n        r5: &[\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 5, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 8, 9, 10, 11, 12, 1, 1, 1, 1, 13, 14, 15, 16, 17,\n            18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 20, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0xffffffffffffffff, 0x000000000000ffff, 0xffff000000000000,\n            0x0fffffffff0fffff, 0x0007ffffffffffff, 0xffffffff00000000, 0x00000000ffffffff,\n            0xffffffffffdfffff, 0xebffde64dfffffff, 0xffffffffffffffef, 0x7bffffffdfdfe7bf,\n            0xfffffffffffdfc5f, 0xffffff3fffffffff, 0xf7fffffff7fffffd, 0xffdfffffffdfffff,\n            0xffff7fffffff7fff, 0xfffffdfffffffdff, 0x0000000000000ff7, 0x000000000000000f,\n            0xffff03ffffff03ff, 0x00000000000003ff\n        ],\n    };\n\n    pub fn Cased(c: char) -> bool {\n        Cased_table.lookup(c)\n    }\n\n    pub const Grapheme_Extend_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0xffffffffffffffff, 0x0000ffffffffffff, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x00000000000003f8, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0xbffffffffffe0000, 0x00000000000000b6,\n            0x0000000007ff0000, 0x00010000fffff800, 0x0000000000000000, 0x00003d9f9fc00000,\n            0xffff000000020000, 0x00000000000007ff, 0x0001ffc000000000, 0x200ff80000000000\n        ],\n        r2: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 2, 21, 22,\n            23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 34, 35, 36, 37, 38, 2, 39, 2, 40, 2, 2, 2, 41, 42, 43, 2, 44,\n            45, 46, 47, 48, 2, 2, 49, 2, 2, 2, 50, 2, 2, 2, 2, 2, 2, 2, 2, 51, 2, 2, 52, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 53, 2, 54, 2, 55, 2, 2, 2, 2, 2, 2, 2, 2, 56,\n            2, 57, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 58, 59, 60, 2, 2, 2, 2, 61, 2, 2, 62, 63, 64, 65, 66, 67, 68,\n            69, 70, 2, 2, 2, 71, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 72, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 73, 2, 2, 2, 2, 2, 59, 2\n        ],\n        r3: &[\n            0x00003eeffbc00000, 0x000000000e000000, 0x0000000000000000, 0xfffffffbfff80000,\n            0x1400000000000007, 0x0000000c00fe21fe, 0x5000000000000002, 0x4000000c0080201e,\n            0x1000000000000006, 0x0023000000023986, 0xfc00000c000021be, 0xd000000000000002,\n            0x0000000c00c0201e, 0x4000000000000004, 0x0000000000802001, 0xc000000000000011,\n            0x0000000c00603dc1, 0x9000000000000002, 0x0000000c00603044, 0x5800000000000003,\n            0x0000000c0080201e, 0x00000000805c8400, 0x07f2000000000000, 0x0000000000007f80,\n            0x1bf2000000000000, 0x0000000000003f00, 0x02a0000003000000, 0x7ffe000000000000,\n            0x1ffffffffeffe0df, 0x0000000000000040, 0x66fde00000000000, 0x001e0001c3000000,\n            0x0000000020002064, 0x00000000e0000000, 0x001c0000001c0000, 0x000c0000000c0000,\n            0x3fb0000000000000, 0x00000000200ffe40, 0x0000000000003800, 0x0000020000000060,\n            0x0e04018700000000, 0x0000000009800000, 0x9ff81fe57f400000, 0x7fff000000000000,\n            0x17d000000000000f, 0x000ff80000000004, 0x00003b3c00000003, 0x0003a34000000000,\n            0x00cff00000000000, 0x031021fdfff70000, 0xfbffffffffffffff, 0x0000000000001000,\n            0x0001ffffffff0000, 0x0003800000000000, 0x8000000000000000, 0xffffffff00000000,\n            0x0000fc0000000000, 0x0000000006000000, 0x3ff7800000000000, 0x00000000c0000000,\n            0x0003000000000000, 0x0000006000000844, 0x8003ffff00000030, 0x00003fc000000000,\n            0x000000000003ff80, 0x13c8000000000007, 0x0000002000000000, 0x00667e0000000000,\n            0x1000000000001008, 0xc19d000000000000, 0x0040300000000002, 0x0000212000000000,\n            0x0000000040000000, 0x0000ffff0000ffff\n        ],\n        r4: [\n            0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 4, 2, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 7, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n        ],\n        r5: &[\n            0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0,\n            0, 0, 0, 7, 0, 0, 8, 9, 10, 0, 11, 12, 13, 14, 15, 0, 0, 16, 17, 18, 0, 0, 19, 20, 21,\n            22, 0, 0, 23, 24, 25, 26, 27, 0, 28, 0, 0, 0, 29, 0, 0, 0, 0, 0, 0, 0, 30, 31, 32, 0, 0,\n            0, 0, 0, 33, 0, 34, 0, 35, 36, 37, 0, 0, 0, 0, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 41, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 43, 44, 0, 0, 45, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 47, 48, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 51, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 52, 53, 0, 0,\n            53, 53, 53, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0x2000000000000000, 0x0000000100000000, 0x07c0000000000000,\n            0x870000000000f06e, 0x0000006000000000, 0x000000f000000000, 0x000000000001ffc0,\n            0xff00000000000002, 0x800000000000007f, 0x0678000000000003, 0x001fef8000000007,\n            0x0008000000000000, 0x7fc0000000000003, 0x0000000000001e00, 0x40d3800000000000,\n            0x000007f880000000, 0x5800000000000003, 0x001f1fc000800001, 0xff00000000000000,\n            0x000000004000005c, 0xa5f9000000000000, 0x000000000000000d, 0xb03c800000000000,\n            0x0000000030000001, 0xa7f8000000000000, 0x0000000000000001, 0x00bf280000000000,\n            0x00000fbce0000000, 0x06ff800000000000, 0x79f80000000007fe, 0x000000000e7e0080,\n            0x00000000037ffc00, 0xbf7f000000000000, 0x006dfcfffffc0000, 0xb47e000000000000,\n            0x00000000000000bf, 0x0000000000a30000, 0x0018000000000000, 0x001f000000000000,\n            0x007f000000000000, 0x0000000000078000, 0x0000000060000000, 0xf807c3a000000000,\n            0x00003c0000000fe7, 0x000000000000001c, 0xf87fffffffffffff, 0x00201fffffffffff,\n            0x0000fffef8000010, 0x000007dbf9ffff7f, 0x00000000007f0000, 0x00000000000007f0,\n            0xffffffff00000000, 0xffffffffffffffff, 0x0000ffffffffffff\n        ],\n    };\n\n    pub fn Grapheme_Extend(c: char) -> bool {\n        Grapheme_Extend_table.lookup(c)\n    }\n\n    pub const Lowercase_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x07fffffe00000000, 0x0420040000000000, 0xff7fffff80000000,\n            0x55aaaaaaaaaaaaaa, 0xd4aaaaaaaaaaab55, 0xe6512d2a4e243129, 0xaa29aaaab5555240,\n            0x93faaaaaaaaaaaaa, 0xffffffffffffaa85, 0x01ffffffffefffff, 0x0000001f00000003,\n            0x0000000000000000, 0x3c8a000000000020, 0xfffff00000010000, 0x192faaaaaae37fff,\n            0xffff000000000000, 0xaaaaaaaaffffffff, 0xaaaaaaaaaaaaa802, 0xaaaaaaaaaaaad554,\n            0x0000aaaaaaaaaaaa, 0xffffffff00000000, 0x00000000000001ff, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000\n        ],\n        r2: [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 4, 4, 4,\n            0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 11, 12, 0, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 17, 18, 5, 19, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 22,\n            0, 23, 24, 25, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 27, 4, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 29, 0, 0\n        ],\n        r3: &[\n            0x0000000000000000, 0xe7ffffffffff0000, 0x3f00000000000000, 0x00000000000001ff,\n            0xffffffffffffffff, 0xaaaaaaaaaaaaaaaa, 0xaaaaaaaabfeaaaaa, 0x00ff00ff003f00ff,\n            0x3fff00ff00ff003f, 0x40df00ff00ff00ff, 0x00dc00ff00cf00dc, 0x8002000000000000,\n            0x000000001fff0000, 0x321080000008c400, 0xffff0000000043c0, 0x0000000000000010,\n            0x000003ffffff0000, 0xffff000000000000, 0x3fda15627fffffff, 0x0008501aaaaaaaaa,\n            0x000020bfffffffff, 0x00002aaaaaaaaaaa, 0x000000003aaaaaaa, 0xaaabaaa800000000,\n            0x95ffaaaaaaaaaaaa, 0x02a082aaaaba50aa, 0x0700000000000000, 0xffff003ff7ffffff,\n            0x0000000000f8007f, 0x0000000007fffffe\n        ],\n        r4: [\n            0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n        ],\n        r5: &[\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,\n            21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0xffffff0000000000, 0x000000000000ffff, 0x0fffffffff000000,\n            0x0007ffffffffffff, 0x00000000ffffffff, 0xffffffff00000000, 0x000ffffffc000000,\n            0x000000ffffdfc000, 0xebc000000ffffffc, 0xfffffc000000ffef, 0x00ffffffc000000f,\n            0x00000ffffffc0000, 0xfc000000ffffffc0, 0xffffc000000fffff, 0x0ffffffc000000ff,\n            0x0000ffffffc00000, 0x0000003ffffffc00, 0xf0000003f7fffffc, 0xffc000000fdfffff,\n            0xffff0000003f7fff, 0xfffffc000000fdff, 0x0000000000000bf7, 0xfffffffc00000000,\n            0x000000000000000f\n        ],\n    };\n\n    pub fn Lowercase(c: char) -> bool {\n        Lowercase_table.lookup(c)\n    }\n\n    pub const Uppercase_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x0000000007fffffe, 0x0000000000000000, 0x000000007f7fffff,\n            0xaa55555555555555, 0x2b555555555554aa, 0x11aed2d5b1dbced6, 0x55d255554aaaa490,\n            0x6c05555555555555, 0x000000000000557a, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x8045000000000000, 0x00000ffbfffed740, 0xe6905555551c8000,\n            0x0000ffffffffffff, 0x5555555500000000, 0x5555555555555401, 0x5555555555552aab,\n            0xfffe555555555555, 0x00000000007fffff, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000,\n            0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000\n        ],\n        r2: [\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0,\n            0, 5, 5, 6, 5, 7, 8, 9, 10, 0, 0, 0, 0, 11, 12, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14,\n            15, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            16, 17, 5, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 20, 0,\n            21, 22, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 24, 0, 0, 0\n        ],\n        r3: &[\n            0x0000000000000000, 0xffffffff00000000, 0x00000000000020bf, 0x003fffffffffffff,\n            0xe7ffffffffff0000, 0x5555555555555555, 0x5555555540155555, 0xff00ff003f00ff00,\n            0x0000ff00aa003f00, 0x0f00000000000000, 0x0f001f000f000f00, 0xc00f3d503e273884,\n            0x0000ffff00000020, 0x0000000000000008, 0xffc0000000000000, 0x000000000000ffff,\n            0x00007fffffffffff, 0xc025ea9d00000000, 0x0004280555555555, 0x0000155555555555,\n            0x0000000005555555, 0x5554555400000000, 0x6a00555555555555, 0x015f7d5555452855,\n            0x07fffffe00000000\n        ],\n        r4: [\n            0, 1, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 4, 5, 6, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2\n        ],\n        r5: &[\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,\n            21, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 24, 25, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n        ],\n        r6: &[\n            0x0000000000000000, 0x000000ffffffffff, 0xffff000000000000, 0x00000000000fffff,\n            0x0007ffffffffffff, 0xffffffff00000000, 0x00000000ffffffff, 0xfff0000003ffffff,\n            0xffffff0000003fff, 0x003fde64d0000003, 0x000003ffffff0000, 0x7b0000001fdfe7b0,\n            0xfffff0000001fc5f, 0x03ffffff0000003f, 0x00003ffffff00000, 0xf0000003ffffff00,\n            0xffff0000003fffff, 0xffffff00000003ff, 0x07fffffc00000001, 0x001ffffff0000000,\n            0x00007fffffc00000, 0x000001ffffff0000, 0x0000000000000400, 0x00000003ffffffff,\n            0xffff03ffffff03ff, 0x00000000000003ff\n        ],\n    };\n\n    pub fn Uppercase(c: char) -> bool {\n        Uppercase_table.lookup(c)\n    }\n\n    pub const XID_Continue_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x03ff000000000000, 0x07fffffe87fffffe, 0x04a0040000000000, 0xff7fffffff7fffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000501f0003ffc3,\n            0xffffffffffffffff, 0xb8dfffffffffffff, 0xfffffffbffffd7c0, 0xffbfffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffcfb, 0xffffffffffffffff,\n            0xfffeffffffffffff, 0xffffffff027fffff, 0xbffffffffffe01ff, 0x000787ffffff00b6,\n            0xffffffff07ff0000, 0xffffc3ffffffffff, 0xffffffffffffffff, 0x9ffffdff9fefffff,\n            0xffffffffffff0000, 0xffffffffffffe7ff, 0x0003ffffffffffff, 0x243fffffffffffff\n        ],\n        r2: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n            24, 25, 26, 27, 28, 29, 30, 31, 4, 32, 33, 34, 4, 4, 4, 4, 4, 35, 36, 37, 38, 39, 40,\n            41, 42, 4, 4, 4, 4, 4, 4, 4, 4, 43, 44, 45, 46, 47, 4, 48, 49, 50, 51, 52, 53, 54, 55,\n            56, 57, 58, 59, 60, 4, 61, 4, 62, 63, 64, 65, 66, 4, 4, 4, 67, 4, 4, 4, 4, 68, 69, 70,\n            71, 72, 73, 74, 75, 76, 77, 78, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 79, 80, 4, 81, 82, 83, 84, 85, 60, 60, 60, 60, 60, 60, 60, 60, 86,\n            42, 87, 88, 89, 4, 90, 91, 60, 60, 60, 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 52, 60, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 92, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 93, 94, 4, 4, 4, 4, 95, 96, 4, 97, 98, 4, 99, 100, 101, 62, 4, 102, 103,\n            104, 4, 105, 106, 107, 4, 108, 109, 110, 4, 111, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 112, 113, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,\n            60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 60, 4, 4, 4, 4, 4, 103, 4, 114,\n            115, 116, 97, 117, 4, 118, 4, 4, 119, 120, 121, 122, 123, 124, 4, 125, 126, 127, 128,\n            129\n        ],\n        r3: &[\n            0x00003fffffffffff, 0x000007ff0fffffff, 0x3fdfffff00000000, 0xfffffffbfff80000,\n            0xffffffffffffffff, 0xfffeffcfffffffff, 0xf3c5fdfffff99fef, 0x5003ffcfb080799f,\n            0xd36dfdfffff987ee, 0x003fffc05e023987, 0xf3edfdfffffbbfee, 0xfe00ffcf00013bbf,\n            0xf3edfdfffff99fee, 0x0002ffcfb0c0399f, 0xc3ffc718d63dc7ec, 0x0000ffc000813dc7,\n            0xe3fffdfffffddfff, 0x0000ffcf07603ddf, 0xf3effdfffffddfef, 0x0006ffcf40603ddf,\n            0xfffffffffffddfef, 0xfc00ffcf80f07ddf, 0x2ffbfffffc7fffec, 0x000cffc0ff5f847f,\n            0x07fffffffffffffe, 0x0000000003ff7fff, 0x3bffecaefef02596, 0x00000000f3ff3f5f,\n            0xc2a003ff03000001, 0xfffe1ffffffffeff, 0x1ffffffffeffffdf, 0x0000000000000040,\n            0xffffffffffff03ff, 0xffffffff3fffffff, 0xf7ffffffffff20bf, 0xffffffff3d7f3dff,\n            0x7f3dffffffff3dff, 0xffffffffff7fff3d, 0xffffffffff3dffff, 0x0003fe00e7ffffff,\n            0xffffffff0000ffff, 0x3f3fffffffffffff, 0xfffffffffffffffe, 0xffff9fffffffffff,\n            0xffffffff07fffffe, 0x01ffc7ffffffffff, 0x001fffff001fdfff, 0x000ddfff000fffff,\n            0x000003ff308fffff, 0xffffffff03ff3800, 0x01ffffffffffffff, 0xffff07ffffffffff,\n            0x003fffffffffffff, 0x0fff0fff7fffffff, 0x001f3fffffffffc0, 0xffff0fffffffffff,\n            0x0000000007ff03ff, 0xffffffff0fffffff, 0x9fffffff7fffffff, 0x3fff008003ff03ff,\n            0x0000000000000000, 0x000ff80003ff0fff, 0x000fffffffffffff, 0x00ffffffffffffff,\n            0x3fffffffffffe3ff, 0xe7ffffffffff01ff, 0x03fffffffff70000, 0xfbffffffffffffff,\n            0xffffffff3f3fffff, 0x3fffffffaaff3f3f, 0x5fdfffffffffffff, 0x1fdc1fff0fcf1fdc,\n            0x8000000000000000, 0x8002000000100001, 0x000000001fff0000, 0x0001ffe21fff0000,\n            0xf3fffd503f2ffc84, 0xffffffff000043e0, 0x00000000000001ff, 0xffff7fffffffffff,\n            0xffffffff7fffffff, 0x000ff81fffffffff, 0xffff20bfffffffff, 0x800080ffffffffff,\n            0x7f7f7f7f007fffff, 0xffffffff7f7f7f7f, 0x1f3efffe000000e0, 0xfffffffee67fffff,\n            0xf7ffffffffffffff, 0xfffeffffffffffe0, 0x07ffffff00007fff, 0xffff000000000000,\n            0x0000ffffffffffff, 0x0000000000001fff, 0x3fffffffffff0000, 0x00000fffffff1fff,\n            0xbff0ffffffffffff, 0x0003ffffffffffff, 0xfffffffcff800000, 0x03fffffffffff9ff,\n            0xff80000000000000, 0x000000ffffffffff, 0xe8ffffff03ff003f, 0xffff3fffffffffff,\n            0x1fffffff000fffff, 0x7fffffff03ff8001, 0x007fffffffffffff, 0xfc7fffff03ff3fff,\n            0x007cffff38000007, 0xffff7f7f007e7e7e, 0xffff003ff7ffffff, 0x03ff37ffffffffff,\n            0xffff000fffffffff, 0x0ffffffffffff87f, 0x0000000003ffffff, 0x5f7ffdffe0f8007f,\n            0xffffffffffffffdb, 0xfffffffffff80000, 0xfffffff03fffffff, 0x3fffffffffffffff,\n            0xffffffffffff0000, 0xfffffffffffcffff, 0x03ff0000000000ff, 0x0018ffff0000ffff,\n            0xaa8a00000000e000, 0x1fffffffffffffff, 0x87fffffe03ff0000, 0xffffffc007fffffe,\n            0x7fffffffffffffff, 0x000000001cfcfcfc\n        ],\n        r4: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 12, 13,\n            14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 17, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n        ],\n        r5: &[\n            0, 1, 2, 3, 4, 5, 4, 6, 4, 4, 7, 8, 9, 10, 11, 12, 2, 2, 13, 14, 15, 16, 4, 4, 2, 2, 2,\n            2, 17, 18, 4, 4, 19, 20, 21, 22, 23, 4, 24, 4, 25, 26, 27, 28, 29, 30, 31, 4, 2, 32, 33,\n            33, 34, 4, 4, 4, 4, 4, 4, 4, 35, 36, 4, 4, 2, 37, 3, 38, 39, 40, 2, 41, 42, 4, 43, 44,\n            45, 46, 4, 4, 2, 47, 2, 48, 4, 4, 49, 50, 2, 51, 52, 53, 54, 4, 4, 4, 3, 4, 55, 56, 4,\n            4, 4, 4, 57, 58, 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 69, 2, 2, 2, 70, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 69, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 71, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            2, 2, 2, 2, 2, 2, 2, 2, 60, 72, 4, 73, 17, 74, 75, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4,\n            4, 2, 76, 77, 78, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 79, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 33, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 21, 80, 2, 2, 2, 2, 2,\n            81, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 82, 83, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            84, 85, 4, 4, 86, 4, 4, 4, 4, 4, 4, 2, 87, 88, 89, 90, 91, 2, 2, 2, 2, 92, 93, 94, 95,\n            96, 97, 4, 4, 4, 4, 4, 4, 4, 4, 98, 99, 100, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 101, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 102, 2, 103, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 104, 105, 106, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 107, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 11, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 108,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 109, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 110, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 111, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4\n        ],\n        r6: &[\n            0xb7ffff7fffffefff, 0x000000003fff3fff, 0xffffffffffffffff, 0x07ffffffffffffff,\n            0x0000000000000000, 0x001fffffffffffff, 0x2000000000000000, 0xffffffff1fffffff,\n            0x000000010001ffff, 0xffffe000ffffffff, 0x07ffffffffff07ff, 0xffffffff3fffffff,\n            0x00000000003eff0f, 0xffff03ff3fffffff, 0x0fffffffff0fffff, 0xffff00ffffffffff,\n            0x0000000fffffffff, 0x007fffffffffffff, 0x000000ff003fffff, 0x91bffffffffffd3f,\n            0x007fffff003fffff, 0x000000007fffffff, 0x0037ffff00000000, 0x03ffffff003fffff,\n            0xc0ffffffffffffff, 0x873ffffffeeff06f, 0x1fffffff00000000, 0x000000001fffffff,\n            0x0000007ffffffeff, 0x003fffffffffffff, 0x0007ffff003fffff, 0x000000000003ffff,\n            0x00000000000001ff, 0x0007ffffffffffff, 0x03ff00ffffffffff, 0xffff00801fffffff,\n            0x000000000001ffff, 0x8000ffc00000007f, 0x03ff01ffffff0000, 0xffdfffffffffffff,\n            0x004fffffffff0070, 0x0000000017ff1e1f, 0x40fffffffffbffff, 0xffff01ffbfffbd7f,\n            0x03ff07ffffffffff, 0xfbedfdfffff99fef, 0x001f1fcfe081399f, 0x0000000043ff07ff,\n            0x0000000003ff00bf, 0xff3fffffffffffff, 0x000000003f000001, 0x0000000003ff0011,\n            0x00ffffffffffffff, 0x00000000000003ff, 0x03ff0fffe7ffffff, 0xffffffff00000000,\n            0x800003ffffffffff, 0x7fffffffffffffff, 0xffffffffffff0080, 0x0000000023ffffcf,\n            0x01ffffffffffffff, 0xff7ffffffffffdff, 0xfffc000003ff0001, 0x007ffefffffcffff,\n            0xb47ffffffffffb7f, 0xfffffdbf03ff00ff, 0x000003ff01fb7fff, 0x007fffff00000000,\n            0x0000000003ffffff, 0x00007fffffffffff, 0x000000000000000f, 0x000000000000007f,\n            0x000003ff7fffffff, 0x001f3fffffff0000, 0xe0fffff803ff000f, 0x000000000000ffff,\n            0x7fffffffffff001f, 0x00000000ffff8000, 0x0000000300000000, 0x0003ffffffffffff,\n            0xffff000000000000, 0x0fffffffffffffff, 0x1fff07ffffffffff, 0x0000000063ff01ff,\n            0xf807e3e000000000, 0x00003c0000000fe7, 0x000000000000001c, 0xffffffffffdfffff,\n            0xebffde64dfffffff, 0xffffffffffffffef, 0x7bffffffdfdfe7bf, 0xfffffffffffdfc5f,\n            0xffffff3fffffffff, 0xf7fffffff7fffffd, 0xffdfffffffdfffff, 0xffff7fffffff7fff,\n            0xfffffdfffffffdff, 0xffffffffffffcff7, 0xf87fffffffffffff, 0x00201fffffffffff,\n            0x0000fffef8000010, 0x000007dbf9ffff7f, 0x00000000007f001f, 0x0000000003ff07ff,\n            0x0af7fe96ffffffef, 0x5ef7f796aa96ea84, 0x0ffffbee0ffffbff, 0x00000000007fffff,\n            0xffff0003ffffffff, 0x00000001ffffffff, 0x000000003fffffff, 0x0000ffffffffffff\n        ],\n    };\n\n    pub fn XID_Continue(c: char) -> bool {\n        XID_Continue_table.lookup(c)\n    }\n\n    pub const XID_Start_table: &super::BoolTrie = &super::BoolTrie {\n        r1: [\n            0x0000000000000000, 0x07fffffe07fffffe, 0x0420040000000000, 0xff7fffffff7fffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff, 0x0000501f0003ffc3,\n            0x0000000000000000, 0xb8df000000000000, 0xfffffffbffffd740, 0xffbfffffffffffff,\n            0xffffffffffffffff, 0xffffffffffffffff, 0xfffffffffffffc03, 0xffffffffffffffff,\n            0xfffeffffffffffff, 0xffffffff027fffff, 0x00000000000001ff, 0x000787ffffff0000,\n            0xffffffff00000000, 0xfffec000000007ff, 0xffffffffffffffff, 0x9c00c060002fffff,\n            0x0000fffffffd0000, 0xffffffffffffe000, 0x0002003fffffffff, 0x043007fffffffc00\n        ],\n        r2: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,\n            24, 23, 25, 26, 27, 28, 29, 3, 30, 31, 32, 33, 34, 34, 34, 34, 34, 35, 36, 37, 38, 39,\n            40, 41, 42, 34, 34, 34, 34, 34, 34, 34, 34, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,\n            54, 55, 56, 57, 58, 59, 60, 3, 61, 62, 63, 64, 65, 66, 67, 68, 34, 34, 34, 3, 34, 34,\n            34, 34, 69, 70, 71, 72, 3, 73, 74, 3, 75, 76, 77, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 78,\n            79, 34, 80, 81, 82, 83, 84, 3, 3, 3, 3, 3, 3, 3, 3, 85, 42, 86, 87, 88, 34, 89, 90, 3,\n            3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 53, 3, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 91, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 92, 93, 34, 34, 34, 34, 94,\n            95, 96, 91, 97, 34, 98, 99, 100, 48, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110,\n            111, 112, 34, 113, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34,\n            34, 34, 34, 114, 115, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n            3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 34, 34, 34, 34, 34,\n            116, 34, 117, 118, 119, 120, 121, 34, 122, 34, 34, 123, 124, 125, 126, 3, 127, 34, 128,\n            129, 130, 131, 132\n        ],\n        r3: &[\n            0x00000110043fffff, 0x000007ff01ffffff, 0x3fdfffff00000000, 0x0000000000000000,\n            0x23fffffffffffff0, 0xfffe0003ff010000, 0x23c5fdfffff99fe1, 0x10030003b0004000,\n            0x036dfdfffff987e0, 0x001c00005e000000, 0x23edfdfffffbbfe0, 0x0200000300010000,\n            0x23edfdfffff99fe0, 0x00020003b0000000, 0x03ffc718d63dc7e8, 0x0000000000010000,\n            0x23fffdfffffddfe0, 0x0000000307000000, 0x23effdfffffddfe1, 0x0006000340000000,\n            0x27fffffffffddfe0, 0xfc00000380704000, 0x2ffbfffffc7fffe0, 0x000000000000007f,\n            0x0005fffffffffffe, 0x2005ecaefef02596, 0x00000000f000005f, 0x0000000000000001,\n            0x00001ffffffffeff, 0x0000000000001f00, 0x800007ffffffffff, 0xffe1c0623c3f0000,\n            0xffffffff00004003, 0xf7ffffffffff20bf, 0xffffffffffffffff, 0xffffffff3d7f3dff,\n            0x7f3dffffffff3dff, 0xffffffffff7fff3d, 0xffffffffff3dffff, 0x0000000007ffffff,\n            0xffffffff0000ffff, 0x3f3fffffffffffff, 0xfffffffffffffffe, 0xffff9fffffffffff,\n            0xffffffff07fffffe, 0x01ffc7ffffffffff, 0x0003ffff0003dfff, 0x0001dfff0003ffff,\n            0x000fffffffffffff, 0x0000000010800000, 0xffffffff00000000, 0x01ffffffffffffff,\n            0xffff05ffffffffff, 0x003fffffffffffff, 0x000000007fffffff, 0x001f3fffffff0000,\n            0xffff0fffffffffff, 0x00000000000003ff, 0xffffffff007fffff, 0x00000000001fffff,\n            0x0000008000000000, 0x000fffffffffffe0, 0x0000000000000fe0, 0xfc00c001fffffff8,\n            0x0000003fffffffff, 0x0000000fffffffff, 0x3ffffffffc00e000, 0xe7ffffffffff01ff,\n            0x0063de0000000000, 0xffffffff3f3fffff, 0x3fffffffaaff3f3f, 0x5fdfffffffffffff,\n            0x1fdc1fff0fcf1fdc, 0x8002000000000000, 0x000000001fff0000, 0xf3fffd503f2ffc84,\n            0xffffffff000043e0, 0x00000000000001ff, 0xffff7fffffffffff, 0xffffffff7fffffff,\n            0x000c781fffffffff, 0xffff20bfffffffff, 0x000080ffffffffff, 0x7f7f7f7f007fffff,\n            0x000000007f7f7f7f, 0x1f3e03fe000000e0, 0xfffffffee07fffff, 0xf7ffffffffffffff,\n            0xfffeffffffffffe0, 0x07ffffff00007fff, 0xffff000000000000, 0x0000ffffffffffff,\n            0x0000000000001fff, 0x3fffffffffff0000, 0x00000c00ffff1fff, 0x80007fffffffffff,\n            0xffffffff3fffffff, 0xfffffffcff800000, 0x03fffffffffff9ff, 0xff80000000000000,\n            0x00000007fffff7bb, 0x000ffffffffffffc, 0x68fc000000000000, 0xffff003ffffffc00,\n            0x1fffffff0000007f, 0x0007fffffffffff0, 0x7c00ffdf00008000, 0x000001ffffffffff,\n            0xc47fffff00000ff7, 0x3e62ffffffffffff, 0x001c07ff38000005, 0xffff7f7f007e7e7e,\n            0xffff003ff7ffffff, 0x00000007ffffffff, 0xffff000fffffffff, 0x0ffffffffffff87f,\n            0xffff3fffffffffff, 0x0000000003ffffff, 0x5f7ffdffa0f8007f, 0xffffffffffffffdb,\n            0x0003ffffffffffff, 0xfffffffffff80000, 0xfffffff03fffffff, 0x3fffffffffffffff,\n            0xffffffffffff0000, 0xfffffffffffcffff, 0x03ff0000000000ff, 0xaa8a000000000000,\n            0x1fffffffffffffff, 0x07fffffe00000000, 0xffffffc007fffffe, 0x7fffffff3fffffff,\n            0x000000001cfcfcfc\n        ],\n        r4: [\n            0, 1, 2, 3, 4, 5, 6, 7, 8, 5, 5, 9, 5, 10, 11, 5, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 12, 13,\n            14, 7, 15, 16, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n            5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5\n        ],\n        r5: &[\n            0, 1, 2, 3, 4, 5, 4, 4, 4, 4, 6, 7, 8, 9, 10, 11, 2, 2, 12, 13, 14, 15, 4, 4, 2, 2, 2,\n            2, 16, 17, 4, 4, 18, 19, 20, 21, 22, 4, 23, 4, 24, 25, 26, 27, 28, 29, 30, 4, 2, 31, 32,\n            32, 15, 4, 4, 4, 4, 4, 4, 4, 33, 34, 4, 4, 35, 4, 36, 37, 38, 39, 40, 41, 42, 4, 43, 20,\n            44, 45, 4, 4, 5, 46, 47, 48, 4, 4, 49, 50, 47, 51, 52, 4, 53, 4, 4, 4, 54, 4, 55, 56, 4,\n            4, 4, 4, 57, 58, 59, 60, 4, 4, 4, 4, 61, 62, 63, 4, 64, 65, 66, 4, 4, 4, 4, 67, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 68, 4, 2, 49, 2, 2, 2, 69, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 49, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 70, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            2, 2, 2, 2, 2, 2, 2, 2, 60, 20, 4, 71, 47, 72, 63, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4,\n            4, 2, 73, 74, 75, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 76, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 32, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 20, 77, 2, 2, 2, 2, 2,\n            78, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 2, 79, 80, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 81, 82, 83, 84, 85, 2, 2, 2, 2, 86, 87, 88, 89, 90,\n            91, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 92, 2, 69, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 93, 94, 95, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 96, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 2, 2, 2, 10, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 97, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 98, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 2, 99, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4\n        ],\n        r6: &[\n            0xb7ffff7fffffefff, 0x000000003fff3fff, 0xffffffffffffffff, 0x07ffffffffffffff,\n            0x0000000000000000, 0x001fffffffffffff, 0xffffffff1fffffff, 0x000000000001ffff,\n            0xffffe000ffffffff, 0x003fffffffff07ff, 0xffffffff3fffffff, 0x00000000003eff0f,\n            0xffff00003fffffff, 0x0fffffffff0fffff, 0xffff00ffffffffff, 0x0000000fffffffff,\n            0x007fffffffffffff, 0x000000ff003fffff, 0x91bffffffffffd3f, 0x007fffff003fffff,\n            0x000000007fffffff, 0x0037ffff00000000, 0x03ffffff003fffff, 0xc0ffffffffffffff,\n            0x003ffffffeef0001, 0x1fffffff00000000, 0x000000001fffffff, 0x0000001ffffffeff,\n            0x003fffffffffffff, 0x0007ffff003fffff, 0x000000000003ffff, 0x00000000000001ff,\n            0x0007ffffffffffff, 0xffff00801fffffff, 0x000000000000003f, 0x00fffffffffffff8,\n            0x0000fffffffffff8, 0x000001ffffff0000, 0x0000007ffffffff8, 0x0047ffffffff0010,\n            0x0007fffffffffff8, 0x000000001400001e, 0x00000ffffffbffff, 0xffff01ffbfffbd7f,\n            0x23edfdfffff99fe0, 0x00000003e0010000, 0x0000000000000780, 0x0000ffffffffffff,\n            0x00000000000000b0, 0x00007fffffffffff, 0x000000000f000000, 0x0000000000000010,\n            0x000007ffffffffff, 0x0000000007ffffff, 0x00000fffffffffff, 0xffffffff00000000,\n            0x80000000ffffffff, 0x0407fffffffff801, 0xfffffffff0010000, 0x00000000200003cf,\n            0x01ffffffffffffff, 0x00007ffffffffdff, 0xfffc000000000001, 0x000000000000ffff,\n            0x0001fffffffffb7f, 0xfffffdbf00000040, 0x00000000010003ff, 0x0007ffff00000000,\n            0x0000000003ffffff, 0x000000000000000f, 0x000000000000007f, 0x00003fffffff0000,\n            0xe0fffff80000000f, 0x000000000001001f, 0x00000000fff80000, 0x0000000300000000,\n            0x0003ffffffffffff, 0xffff000000000000, 0x0fffffffffffffff, 0x1fff07ffffffffff,\n            0x0000000003ff01ff, 0xffffffffffdfffff, 0xebffde64dfffffff, 0xffffffffffffffef,\n            0x7bffffffdfdfe7bf, 0xfffffffffffdfc5f, 0xffffff3fffffffff, 0xf7fffffff7fffffd,\n            0xffdfffffffdfffff, 0xffff7fffffff7fff, 0xfffffdfffffffdff, 0x0000000000000ff7,\n            0x000000000000001f, 0x0af7fe96ffffffef, 0x5ef7f796aa96ea84, 0x0ffffbee0ffffbff,\n            0x00000000007fffff, 0xffff0003ffffffff, 0x00000001ffffffff, 0x000000003fffffff\n        ],\n    };\n\n    pub fn XID_Start(c: char) -> bool {\n        XID_Start_table.lookup(c)\n    }\n\n}\n\npub mod property {\n    pub const Pattern_White_Space_table: &super::SmallBoolTrie = &super::SmallBoolTrie {\n        r1: &[\n            0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3\n        ],\n        r2: &[\n            0x0000000100003e00, 0x0000000000000000, 0x0000000000000020, 0x000003000000c000\n        ],\n    };\n\n    pub fn Pattern_White_Space(c: char) -> bool {\n        Pattern_White_Space_table.lookup(c)\n    }\n\n    pub const White_Space_table: &super::SmallBoolTrie = &super::SmallBoolTrie {\n        r1: &[\n            0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 5, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3\n        ],\n        r2: &[\n            0x0000000100003e00, 0x0000000000000000, 0x0000000100000020, 0x0000000000000001,\n            0x00008300000007ff, 0x0000000080000000\n        ],\n    };\n\n    pub fn White_Space(c: char) -> bool {\n        White_Space_table.lookup(c)\n    }\n\n}\n\npub mod conversions {\n    pub fn to_lower(c: char) -> [char; 3] {\n        match bsearch_case_table(c, to_lowercase_table) {\n            None        => [c, '\\0', '\\0'],\n            Some(index) => to_lowercase_table[index].1,\n        }\n    }\n\n    pub fn to_upper(c: char) -> [char; 3] {\n        match bsearch_case_table(c, to_uppercase_table) {\n            None        => [c, '\\0', '\\0'],\n            Some(index) => to_uppercase_table[index].1,\n        }\n    }\n\n    fn bsearch_case_table(c: char, table: &[(char, [char; 3])]) -> Option<usize> {\n        table.binary_search_by(|&(key, _)| key.cmp(&c)).ok()\n    }\n\n    const to_lowercase_table: &[(char, [char; 3])] = &[\n        ('\\u{41}', ['\\u{61}', '\\0', '\\0']), ('\\u{42}', ['\\u{62}', '\\0', '\\0']), ('\\u{43}',\n        ['\\u{63}', '\\0', '\\0']), ('\\u{44}', ['\\u{64}', '\\0', '\\0']), ('\\u{45}', ['\\u{65}', '\\0',\n        '\\0']), ('\\u{46}', ['\\u{66}', '\\0', '\\0']), ('\\u{47}', ['\\u{67}', '\\0', '\\0']), ('\\u{48}',\n        ['\\u{68}', '\\0', '\\0']), ('\\u{49}', ['\\u{69}', '\\0', '\\0']), ('\\u{4a}', ['\\u{6a}', '\\0',\n        '\\0']), ('\\u{4b}', ['\\u{6b}', '\\0', '\\0']), ('\\u{4c}', ['\\u{6c}', '\\0', '\\0']), ('\\u{4d}',\n        ['\\u{6d}', '\\0', '\\0']), ('\\u{4e}', ['\\u{6e}', '\\0', '\\0']), ('\\u{4f}', ['\\u{6f}', '\\0',\n        '\\0']), ('\\u{50}', ['\\u{70}', '\\0', '\\0']), ('\\u{51}', ['\\u{71}', '\\0', '\\0']), ('\\u{52}',\n        ['\\u{72}', '\\0', '\\0']), ('\\u{53}', ['\\u{73}', '\\0', '\\0']), ('\\u{54}', ['\\u{74}', '\\0',\n        '\\0']), ('\\u{55}', ['\\u{75}', '\\0', '\\0']), ('\\u{56}', ['\\u{76}', '\\0', '\\0']), ('\\u{57}',\n        ['\\u{77}', '\\0', '\\0']), ('\\u{58}', ['\\u{78}', '\\0', '\\0']), ('\\u{59}', ['\\u{79}', '\\0',\n        '\\0']), ('\\u{5a}', ['\\u{7a}', '\\0', '\\0']), ('\\u{c0}', ['\\u{e0}', '\\0', '\\0']), ('\\u{c1}',\n        ['\\u{e1}', '\\0', '\\0']), ('\\u{c2}', ['\\u{e2}', '\\0', '\\0']), ('\\u{c3}', ['\\u{e3}', '\\0',\n        '\\0']), ('\\u{c4}', ['\\u{e4}', '\\0', '\\0']), ('\\u{c5}', ['\\u{e5}', '\\0', '\\0']), ('\\u{c6}',\n        ['\\u{e6}', '\\0', '\\0']), ('\\u{c7}', ['\\u{e7}', '\\0', '\\0']), ('\\u{c8}', ['\\u{e8}', '\\0',\n        '\\0']), ('\\u{c9}', ['\\u{e9}', '\\0', '\\0']), ('\\u{ca}', ['\\u{ea}', '\\0', '\\0']), ('\\u{cb}',\n        ['\\u{eb}', '\\0', '\\0']), ('\\u{cc}', ['\\u{ec}', '\\0', '\\0']), ('\\u{cd}', ['\\u{ed}', '\\0',\n        '\\0']), ('\\u{ce}', ['\\u{ee}', '\\0', '\\0']), ('\\u{cf}', ['\\u{ef}', '\\0', '\\0']), ('\\u{d0}',\n        ['\\u{f0}', '\\0', '\\0']), ('\\u{d1}', ['\\u{f1}', '\\0', '\\0']), ('\\u{d2}', ['\\u{f2}', '\\0',\n        '\\0']), ('\\u{d3}', ['\\u{f3}', '\\0', '\\0']), ('\\u{d4}', ['\\u{f4}', '\\0', '\\0']), ('\\u{d5}',\n        ['\\u{f5}', '\\0', '\\0']), ('\\u{d6}', ['\\u{f6}', '\\0', '\\0']), ('\\u{d8}', ['\\u{f8}', '\\0',\n        '\\0']), ('\\u{d9}', ['\\u{f9}', '\\0', '\\0']), ('\\u{da}', ['\\u{fa}', '\\0', '\\0']), ('\\u{db}',\n        ['\\u{fb}', '\\0', '\\0']), ('\\u{dc}', ['\\u{fc}', '\\0', '\\0']), ('\\u{dd}', ['\\u{fd}', '\\0',\n        '\\0']), ('\\u{de}', ['\\u{fe}', '\\0', '\\0']), ('\\u{100}', ['\\u{101}', '\\0', '\\0']),\n        ('\\u{102}', ['\\u{103}', '\\0', '\\0']), ('\\u{104}', ['\\u{105}', '\\0', '\\0']), ('\\u{106}',\n        ['\\u{107}', '\\0', '\\0']), ('\\u{108}', ['\\u{109}', '\\0', '\\0']), ('\\u{10a}', ['\\u{10b}',\n        '\\0', '\\0']), ('\\u{10c}', ['\\u{10d}', '\\0', '\\0']), ('\\u{10e}', ['\\u{10f}', '\\0', '\\0']),\n        ('\\u{110}', ['\\u{111}', '\\0', '\\0']), ('\\u{112}', ['\\u{113}', '\\0', '\\0']), ('\\u{114}',\n        ['\\u{115}', '\\0', '\\0']), ('\\u{116}', ['\\u{117}', '\\0', '\\0']), ('\\u{118}', ['\\u{119}',\n        '\\0', '\\0']), ('\\u{11a}', ['\\u{11b}', '\\0', '\\0']), ('\\u{11c}', ['\\u{11d}', '\\0', '\\0']),\n        ('\\u{11e}', ['\\u{11f}', '\\0', '\\0']), ('\\u{120}', ['\\u{121}', '\\0', '\\0']), ('\\u{122}',\n        ['\\u{123}', '\\0', '\\0']), ('\\u{124}', ['\\u{125}', '\\0', '\\0']), ('\\u{126}', ['\\u{127}',\n        '\\0', '\\0']), ('\\u{128}', ['\\u{129}', '\\0', '\\0']), ('\\u{12a}', ['\\u{12b}', '\\0', '\\0']),\n        ('\\u{12c}', ['\\u{12d}', '\\0', '\\0']), ('\\u{12e}', ['\\u{12f}', '\\0', '\\0']), ('\\u{130}',\n        ['\\u{69}', '\\u{307}', '\\0']), ('\\u{132}', ['\\u{133}', '\\0', '\\0']), ('\\u{134}', ['\\u{135}',\n        '\\0', '\\0']), ('\\u{136}', ['\\u{137}', '\\0', '\\0']), ('\\u{139}', ['\\u{13a}', '\\0', '\\0']),\n        ('\\u{13b}', ['\\u{13c}', '\\0', '\\0']), ('\\u{13d}', ['\\u{13e}', '\\0', '\\0']), ('\\u{13f}',\n        ['\\u{140}', '\\0', '\\0']), ('\\u{141}', ['\\u{142}', '\\0', '\\0']), ('\\u{143}', ['\\u{144}',\n        '\\0', '\\0']), ('\\u{145}', ['\\u{146}', '\\0', '\\0']), ('\\u{147}', ['\\u{148}', '\\0', '\\0']),\n        ('\\u{14a}', ['\\u{14b}', '\\0', '\\0']), ('\\u{14c}', ['\\u{14d}', '\\0', '\\0']), ('\\u{14e}',\n        ['\\u{14f}', '\\0', '\\0']), ('\\u{150}', ['\\u{151}', '\\0', '\\0']), ('\\u{152}', ['\\u{153}',\n        '\\0', '\\0']), ('\\u{154}', ['\\u{155}', '\\0', '\\0']), ('\\u{156}', ['\\u{157}', '\\0', '\\0']),\n        ('\\u{158}', ['\\u{159}', '\\0', '\\0']), ('\\u{15a}', ['\\u{15b}', '\\0', '\\0']), ('\\u{15c}',\n        ['\\u{15d}', '\\0', '\\0']), ('\\u{15e}', ['\\u{15f}', '\\0', '\\0']), ('\\u{160}', ['\\u{161}',\n        '\\0', '\\0']), ('\\u{162}', ['\\u{163}', '\\0', '\\0']), ('\\u{164}', ['\\u{165}', '\\0', '\\0']),\n        ('\\u{166}', ['\\u{167}', '\\0', '\\0']), ('\\u{168}', ['\\u{169}', '\\0', '\\0']), ('\\u{16a}',\n        ['\\u{16b}', '\\0', '\\0']), ('\\u{16c}', ['\\u{16d}', '\\0', '\\0']), ('\\u{16e}', ['\\u{16f}',\n        '\\0', '\\0']), ('\\u{170}', ['\\u{171}', '\\0', '\\0']), ('\\u{172}', ['\\u{173}', '\\0', '\\0']),\n        ('\\u{174}', ['\\u{175}', '\\0', '\\0']), ('\\u{176}', ['\\u{177}', '\\0', '\\0']), ('\\u{178}',\n        ['\\u{ff}', '\\0', '\\0']), ('\\u{179}', ['\\u{17a}', '\\0', '\\0']), ('\\u{17b}', ['\\u{17c}', '\\0',\n        '\\0']), ('\\u{17d}', ['\\u{17e}', '\\0', '\\0']), ('\\u{181}', ['\\u{253}', '\\0', '\\0']),\n        ('\\u{182}', ['\\u{183}', '\\0', '\\0']), ('\\u{184}', ['\\u{185}', '\\0', '\\0']), ('\\u{186}',\n        ['\\u{254}', '\\0', '\\0']), ('\\u{187}', ['\\u{188}', '\\0', '\\0']), ('\\u{189}', ['\\u{256}',\n        '\\0', '\\0']), ('\\u{18a}', ['\\u{257}', '\\0', '\\0']), ('\\u{18b}', ['\\u{18c}', '\\0', '\\0']),\n        ('\\u{18e}', ['\\u{1dd}', '\\0', '\\0']), ('\\u{18f}', ['\\u{259}', '\\0', '\\0']), ('\\u{190}',\n        ['\\u{25b}', '\\0', '\\0']), ('\\u{191}', ['\\u{192}', '\\0', '\\0']), ('\\u{193}', ['\\u{260}',\n        '\\0', '\\0']), ('\\u{194}', ['\\u{263}', '\\0', '\\0']), ('\\u{196}', ['\\u{269}', '\\0', '\\0']),\n        ('\\u{197}', ['\\u{268}', '\\0', '\\0']), ('\\u{198}', ['\\u{199}', '\\0', '\\0']), ('\\u{19c}',\n        ['\\u{26f}', '\\0', '\\0']), ('\\u{19d}', ['\\u{272}', '\\0', '\\0']), ('\\u{19f}', ['\\u{275}',\n        '\\0', '\\0']), ('\\u{1a0}', ['\\u{1a1}', '\\0', '\\0']), ('\\u{1a2}', ['\\u{1a3}', '\\0', '\\0']),\n        ('\\u{1a4}', ['\\u{1a5}', '\\0', '\\0']), ('\\u{1a6}', ['\\u{280}', '\\0', '\\0']), ('\\u{1a7}',\n        ['\\u{1a8}', '\\0', '\\0']), ('\\u{1a9}', ['\\u{283}', '\\0', '\\0']), ('\\u{1ac}', ['\\u{1ad}',\n        '\\0', '\\0']), ('\\u{1ae}', ['\\u{288}', '\\0', '\\0']), ('\\u{1af}', ['\\u{1b0}', '\\0', '\\0']),\n        ('\\u{1b1}', ['\\u{28a}', '\\0', '\\0']), ('\\u{1b2}', ['\\u{28b}', '\\0', '\\0']), ('\\u{1b3}',\n        ['\\u{1b4}', '\\0', '\\0']), ('\\u{1b5}', ['\\u{1b6}', '\\0', '\\0']), ('\\u{1b7}', ['\\u{292}',\n        '\\0', '\\0']), ('\\u{1b8}', ['\\u{1b9}', '\\0', '\\0']), ('\\u{1bc}', ['\\u{1bd}', '\\0', '\\0']),\n        ('\\u{1c4}', ['\\u{1c6}', '\\0', '\\0']), ('\\u{1c5}', ['\\u{1c6}', '\\0', '\\0']), ('\\u{1c7}',\n        ['\\u{1c9}', '\\0', '\\0']), ('\\u{1c8}', ['\\u{1c9}', '\\0', '\\0']), ('\\u{1ca}', ['\\u{1cc}',\n        '\\0', '\\0']), ('\\u{1cb}', ['\\u{1cc}', '\\0', '\\0']), ('\\u{1cd}', ['\\u{1ce}', '\\0', '\\0']),\n        ('\\u{1cf}', ['\\u{1d0}', '\\0', '\\0']), ('\\u{1d1}', ['\\u{1d2}', '\\0', '\\0']), ('\\u{1d3}',\n        ['\\u{1d4}', '\\0', '\\0']), ('\\u{1d5}', ['\\u{1d6}', '\\0', '\\0']), ('\\u{1d7}', ['\\u{1d8}',\n        '\\0', '\\0']), ('\\u{1d9}', ['\\u{1da}', '\\0', '\\0']), ('\\u{1db}', ['\\u{1dc}', '\\0', '\\0']),\n        ('\\u{1de}', ['\\u{1df}', '\\0', '\\0']), ('\\u{1e0}', ['\\u{1e1}', '\\0', '\\0']), ('\\u{1e2}',\n        ['\\u{1e3}', '\\0', '\\0']), ('\\u{1e4}', ['\\u{1e5}', '\\0', '\\0']), ('\\u{1e6}', ['\\u{1e7}',\n        '\\0', '\\0']), ('\\u{1e8}', ['\\u{1e9}', '\\0', '\\0']), ('\\u{1ea}', ['\\u{1eb}', '\\0', '\\0']),\n        ('\\u{1ec}', ['\\u{1ed}', '\\0', '\\0']), ('\\u{1ee}', ['\\u{1ef}', '\\0', '\\0']), ('\\u{1f1}',\n        ['\\u{1f3}', '\\0', '\\0']), ('\\u{1f2}', ['\\u{1f3}', '\\0', '\\0']), ('\\u{1f4}', ['\\u{1f5}',\n        '\\0', '\\0']), ('\\u{1f6}', ['\\u{195}', '\\0', '\\0']), ('\\u{1f7}', ['\\u{1bf}', '\\0', '\\0']),\n        ('\\u{1f8}', ['\\u{1f9}', '\\0', '\\0']), ('\\u{1fa}', ['\\u{1fb}', '\\0', '\\0']), ('\\u{1fc}',\n        ['\\u{1fd}', '\\0', '\\0']), ('\\u{1fe}', ['\\u{1ff}', '\\0', '\\0']), ('\\u{200}', ['\\u{201}',\n        '\\0', '\\0']), ('\\u{202}', ['\\u{203}', '\\0', '\\0']), ('\\u{204}', ['\\u{205}', '\\0', '\\0']),\n        ('\\u{206}', ['\\u{207}', '\\0', '\\0']), ('\\u{208}', ['\\u{209}', '\\0', '\\0']), ('\\u{20a}',\n        ['\\u{20b}', '\\0', '\\0']), ('\\u{20c}', ['\\u{20d}', '\\0', '\\0']), ('\\u{20e}', ['\\u{20f}',\n        '\\0', '\\0']), ('\\u{210}', ['\\u{211}', '\\0', '\\0']), ('\\u{212}', ['\\u{213}', '\\0', '\\0']),\n        ('\\u{214}', ['\\u{215}', '\\0', '\\0']), ('\\u{216}', ['\\u{217}', '\\0', '\\0']), ('\\u{218}',\n        ['\\u{219}', '\\0', '\\0']), ('\\u{21a}', ['\\u{21b}', '\\0', '\\0']), ('\\u{21c}', ['\\u{21d}',\n        '\\0', '\\0']), ('\\u{21e}', ['\\u{21f}', '\\0', '\\0']), ('\\u{220}', ['\\u{19e}', '\\0', '\\0']),\n        ('\\u{222}', ['\\u{223}', '\\0', '\\0']), ('\\u{224}', ['\\u{225}', '\\0', '\\0']), ('\\u{226}',\n        ['\\u{227}', '\\0', '\\0']), ('\\u{228}', ['\\u{229}', '\\0', '\\0']), ('\\u{22a}', ['\\u{22b}',\n        '\\0', '\\0']), ('\\u{22c}', ['\\u{22d}', '\\0', '\\0']), ('\\u{22e}', ['\\u{22f}', '\\0', '\\0']),\n        ('\\u{230}', ['\\u{231}', '\\0', '\\0']), ('\\u{232}', ['\\u{233}', '\\0', '\\0']), ('\\u{23a}',\n        ['\\u{2c65}', '\\0', '\\0']), ('\\u{23b}', ['\\u{23c}', '\\0', '\\0']), ('\\u{23d}', ['\\u{19a}',\n        '\\0', '\\0']), ('\\u{23e}', ['\\u{2c66}', '\\0', '\\0']), ('\\u{241}', ['\\u{242}', '\\0', '\\0']),\n        ('\\u{243}', ['\\u{180}', '\\0', '\\0']), ('\\u{244}', ['\\u{289}', '\\0', '\\0']), ('\\u{245}',\n        ['\\u{28c}', '\\0', '\\0']), ('\\u{246}', ['\\u{247}', '\\0', '\\0']), ('\\u{248}', ['\\u{249}',\n        '\\0', '\\0']), ('\\u{24a}', ['\\u{24b}', '\\0', '\\0']), ('\\u{24c}', ['\\u{24d}', '\\0', '\\0']),\n        ('\\u{24e}', ['\\u{24f}', '\\0', '\\0']), ('\\u{370}', ['\\u{371}', '\\0', '\\0']), ('\\u{372}',\n        ['\\u{373}', '\\0', '\\0']), ('\\u{376}', ['\\u{377}', '\\0', '\\0']), ('\\u{37f}', ['\\u{3f3}',\n        '\\0', '\\0']), ('\\u{386}', ['\\u{3ac}', '\\0', '\\0']), ('\\u{388}', ['\\u{3ad}', '\\0', '\\0']),\n        ('\\u{389}', ['\\u{3ae}', '\\0', '\\0']), ('\\u{38a}', ['\\u{3af}', '\\0', '\\0']), ('\\u{38c}',\n        ['\\u{3cc}', '\\0', '\\0']), ('\\u{38e}', ['\\u{3cd}', '\\0', '\\0']), ('\\u{38f}', ['\\u{3ce}',\n        '\\0', '\\0']), ('\\u{391}', ['\\u{3b1}', '\\0', '\\0']), ('\\u{392}', ['\\u{3b2}', '\\0', '\\0']),\n        ('\\u{393}', ['\\u{3b3}', '\\0', '\\0']), ('\\u{394}', ['\\u{3b4}', '\\0', '\\0']), ('\\u{395}',\n        ['\\u{3b5}', '\\0', '\\0']), ('\\u{396}', ['\\u{3b6}', '\\0', '\\0']), ('\\u{397}', ['\\u{3b7}',\n        '\\0', '\\0']), ('\\u{398}', ['\\u{3b8}', '\\0', '\\0']), ('\\u{399}', ['\\u{3b9}', '\\0', '\\0']),\n        ('\\u{39a}', ['\\u{3ba}', '\\0', '\\0']), ('\\u{39b}', ['\\u{3bb}', '\\0', '\\0']), ('\\u{39c}',\n        ['\\u{3bc}', '\\0', '\\0']), ('\\u{39d}', ['\\u{3bd}', '\\0', '\\0']), ('\\u{39e}', ['\\u{3be}',\n        '\\0', '\\0']), ('\\u{39f}', ['\\u{3bf}', '\\0', '\\0']), ('\\u{3a0}', ['\\u{3c0}', '\\0', '\\0']),\n        ('\\u{3a1}', ['\\u{3c1}', '\\0', '\\0']), ('\\u{3a3}', ['\\u{3c3}', '\\0', '\\0']), ('\\u{3a4}',\n        ['\\u{3c4}', '\\0', '\\0']), ('\\u{3a5}', ['\\u{3c5}', '\\0', '\\0']), ('\\u{3a6}', ['\\u{3c6}',\n        '\\0', '\\0']), ('\\u{3a7}', ['\\u{3c7}', '\\0', '\\0']), ('\\u{3a8}', ['\\u{3c8}', '\\0', '\\0']),\n        ('\\u{3a9}', ['\\u{3c9}', '\\0', '\\0']), ('\\u{3aa}', ['\\u{3ca}', '\\0', '\\0']), ('\\u{3ab}',\n        ['\\u{3cb}', '\\0', '\\0']), ('\\u{3cf}', ['\\u{3d7}', '\\0', '\\0']), ('\\u{3d8}', ['\\u{3d9}',\n        '\\0', '\\0']), ('\\u{3da}', ['\\u{3db}', '\\0', '\\0']), ('\\u{3dc}', ['\\u{3dd}', '\\0', '\\0']),\n        ('\\u{3de}', ['\\u{3df}', '\\0', '\\0']), ('\\u{3e0}', ['\\u{3e1}', '\\0', '\\0']), ('\\u{3e2}',\n        ['\\u{3e3}', '\\0', '\\0']), ('\\u{3e4}', ['\\u{3e5}', '\\0', '\\0']), ('\\u{3e6}', ['\\u{3e7}',\n        '\\0', '\\0']), ('\\u{3e8}', ['\\u{3e9}', '\\0', '\\0']), ('\\u{3ea}', ['\\u{3eb}', '\\0', '\\0']),\n        ('\\u{3ec}', ['\\u{3ed}', '\\0', '\\0']), ('\\u{3ee}', ['\\u{3ef}', '\\0', '\\0']), ('\\u{3f4}',\n        ['\\u{3b8}', '\\0', '\\0']), ('\\u{3f7}', ['\\u{3f8}', '\\0', '\\0']), ('\\u{3f9}', ['\\u{3f2}',\n        '\\0', '\\0']), ('\\u{3fa}', ['\\u{3fb}', '\\0', '\\0']), ('\\u{3fd}', ['\\u{37b}', '\\0', '\\0']),\n        ('\\u{3fe}', ['\\u{37c}', '\\0', '\\0']), ('\\u{3ff}', ['\\u{37d}', '\\0', '\\0']), ('\\u{400}',\n        ['\\u{450}', '\\0', '\\0']), ('\\u{401}', ['\\u{451}', '\\0', '\\0']), ('\\u{402}', ['\\u{452}',\n        '\\0', '\\0']), ('\\u{403}', ['\\u{453}', '\\0', '\\0']), ('\\u{404}', ['\\u{454}', '\\0', '\\0']),\n        ('\\u{405}', ['\\u{455}', '\\0', '\\0']), ('\\u{406}', ['\\u{456}', '\\0', '\\0']), ('\\u{407}',\n        ['\\u{457}', '\\0', '\\0']), ('\\u{408}', ['\\u{458}', '\\0', '\\0']), ('\\u{409}', ['\\u{459}',\n        '\\0', '\\0']), ('\\u{40a}', ['\\u{45a}', '\\0', '\\0']), ('\\u{40b}', ['\\u{45b}', '\\0', '\\0']),\n        ('\\u{40c}', ['\\u{45c}', '\\0', '\\0']), ('\\u{40d}', ['\\u{45d}', '\\0', '\\0']), ('\\u{40e}',\n        ['\\u{45e}', '\\0', '\\0']), ('\\u{40f}', ['\\u{45f}', '\\0', '\\0']), ('\\u{410}', ['\\u{430}',\n        '\\0', '\\0']), ('\\u{411}', ['\\u{431}', '\\0', '\\0']), ('\\u{412}', ['\\u{432}', '\\0', '\\0']),\n        ('\\u{413}', ['\\u{433}', '\\0', '\\0']), ('\\u{414}', ['\\u{434}', '\\0', '\\0']), ('\\u{415}',\n        ['\\u{435}', '\\0', '\\0']), ('\\u{416}', ['\\u{436}', '\\0', '\\0']), ('\\u{417}', ['\\u{437}',\n        '\\0', '\\0']), ('\\u{418}', ['\\u{438}', '\\0', '\\0']), ('\\u{419}', ['\\u{439}', '\\0', '\\0']),\n        ('\\u{41a}', ['\\u{43a}', '\\0', '\\0']), ('\\u{41b}', ['\\u{43b}', '\\0', '\\0']), ('\\u{41c}',\n        ['\\u{43c}', '\\0', '\\0']), ('\\u{41d}', ['\\u{43d}', '\\0', '\\0']), ('\\u{41e}', ['\\u{43e}',\n        '\\0', '\\0']), ('\\u{41f}', ['\\u{43f}', '\\0', '\\0']), ('\\u{420}', ['\\u{440}', '\\0', '\\0']),\n        ('\\u{421}', ['\\u{441}', '\\0', '\\0']), ('\\u{422}', ['\\u{442}', '\\0', '\\0']), ('\\u{423}',\n        ['\\u{443}', '\\0', '\\0']), ('\\u{424}', ['\\u{444}', '\\0', '\\0']), ('\\u{425}', ['\\u{445}',\n        '\\0', '\\0']), ('\\u{426}', ['\\u{446}', '\\0', '\\0']), ('\\u{427}', ['\\u{447}', '\\0', '\\0']),\n        ('\\u{428}', ['\\u{448}', '\\0', '\\0']), ('\\u{429}', ['\\u{449}', '\\0', '\\0']), ('\\u{42a}',\n        ['\\u{44a}', '\\0', '\\0']), ('\\u{42b}', ['\\u{44b}', '\\0', '\\0']), ('\\u{42c}', ['\\u{44c}',\n        '\\0', '\\0']), ('\\u{42d}', ['\\u{44d}', '\\0', '\\0']), ('\\u{42e}', ['\\u{44e}', '\\0', '\\0']),\n        ('\\u{42f}', ['\\u{44f}', '\\0', '\\0']), ('\\u{460}', ['\\u{461}', '\\0', '\\0']), ('\\u{462}',\n        ['\\u{463}', '\\0', '\\0']), ('\\u{464}', ['\\u{465}', '\\0', '\\0']), ('\\u{466}', ['\\u{467}',\n        '\\0', '\\0']), ('\\u{468}', ['\\u{469}', '\\0', '\\0']), ('\\u{46a}', ['\\u{46b}', '\\0', '\\0']),\n        ('\\u{46c}', ['\\u{46d}', '\\0', '\\0']), ('\\u{46e}', ['\\u{46f}', '\\0', '\\0']), ('\\u{470}',\n        ['\\u{471}', '\\0', '\\0']), ('\\u{472}', ['\\u{473}', '\\0', '\\0']), ('\\u{474}', ['\\u{475}',\n        '\\0', '\\0']), ('\\u{476}', ['\\u{477}', '\\0', '\\0']), ('\\u{478}', ['\\u{479}', '\\0', '\\0']),\n        ('\\u{47a}', ['\\u{47b}', '\\0', '\\0']), ('\\u{47c}', ['\\u{47d}', '\\0', '\\0']), ('\\u{47e}',\n        ['\\u{47f}', '\\0', '\\0']), ('\\u{480}', ['\\u{481}', '\\0', '\\0']), ('\\u{48a}', ['\\u{48b}',\n        '\\0', '\\0']), ('\\u{48c}', ['\\u{48d}', '\\0', '\\0']), ('\\u{48e}', ['\\u{48f}', '\\0', '\\0']),\n        ('\\u{490}', ['\\u{491}', '\\0', '\\0']), ('\\u{492}', ['\\u{493}', '\\0', '\\0']), ('\\u{494}',\n        ['\\u{495}', '\\0', '\\0']), ('\\u{496}', ['\\u{497}', '\\0', '\\0']), ('\\u{498}', ['\\u{499}',\n        '\\0', '\\0']), ('\\u{49a}', ['\\u{49b}', '\\0', '\\0']), ('\\u{49c}', ['\\u{49d}', '\\0', '\\0']),\n        ('\\u{49e}', ['\\u{49f}', '\\0', '\\0']), ('\\u{4a0}', ['\\u{4a1}', '\\0', '\\0']), ('\\u{4a2}',\n        ['\\u{4a3}', '\\0', '\\0']), ('\\u{4a4}', ['\\u{4a5}', '\\0', '\\0']), ('\\u{4a6}', ['\\u{4a7}',\n        '\\0', '\\0']), ('\\u{4a8}', ['\\u{4a9}', '\\0', '\\0']), ('\\u{4aa}', ['\\u{4ab}', '\\0', '\\0']),\n        ('\\u{4ac}', ['\\u{4ad}', '\\0', '\\0']), ('\\u{4ae}', ['\\u{4af}', '\\0', '\\0']), ('\\u{4b0}',\n        ['\\u{4b1}', '\\0', '\\0']), ('\\u{4b2}', ['\\u{4b3}', '\\0', '\\0']), ('\\u{4b4}', ['\\u{4b5}',\n        '\\0', '\\0']), ('\\u{4b6}', ['\\u{4b7}', '\\0', '\\0']), ('\\u{4b8}', ['\\u{4b9}', '\\0', '\\0']),\n        ('\\u{4ba}', ['\\u{4bb}', '\\0', '\\0']), ('\\u{4bc}', ['\\u{4bd}', '\\0', '\\0']), ('\\u{4be}',\n        ['\\u{4bf}', '\\0', '\\0']), ('\\u{4c0}', ['\\u{4cf}', '\\0', '\\0']), ('\\u{4c1}', ['\\u{4c2}',\n        '\\0', '\\0']), ('\\u{4c3}', ['\\u{4c4}', '\\0', '\\0']), ('\\u{4c5}', ['\\u{4c6}', '\\0', '\\0']),\n        ('\\u{4c7}', ['\\u{4c8}', '\\0', '\\0']), ('\\u{4c9}', ['\\u{4ca}', '\\0', '\\0']), ('\\u{4cb}',\n        ['\\u{4cc}', '\\0', '\\0']), ('\\u{4cd}', ['\\u{4ce}', '\\0', '\\0']), ('\\u{4d0}', ['\\u{4d1}',\n        '\\0', '\\0']), ('\\u{4d2}', ['\\u{4d3}', '\\0', '\\0']), ('\\u{4d4}', ['\\u{4d5}', '\\0', '\\0']),\n        ('\\u{4d6}', ['\\u{4d7}', '\\0', '\\0']), ('\\u{4d8}', ['\\u{4d9}', '\\0', '\\0']), ('\\u{4da}',\n        ['\\u{4db}', '\\0', '\\0']), ('\\u{4dc}', ['\\u{4dd}', '\\0', '\\0']), ('\\u{4de}', ['\\u{4df}',\n        '\\0', '\\0']), ('\\u{4e0}', ['\\u{4e1}', '\\0', '\\0']), ('\\u{4e2}', ['\\u{4e3}', '\\0', '\\0']),\n        ('\\u{4e4}', ['\\u{4e5}', '\\0', '\\0']), ('\\u{4e6}', ['\\u{4e7}', '\\0', '\\0']), ('\\u{4e8}',\n        ['\\u{4e9}', '\\0', '\\0']), ('\\u{4ea}', ['\\u{4eb}', '\\0', '\\0']), ('\\u{4ec}', ['\\u{4ed}',\n        '\\0', '\\0']), ('\\u{4ee}', ['\\u{4ef}', '\\0', '\\0']), ('\\u{4f0}', ['\\u{4f1}', '\\0', '\\0']),\n        ('\\u{4f2}', ['\\u{4f3}', '\\0', '\\0']), ('\\u{4f4}', ['\\u{4f5}', '\\0', '\\0']), ('\\u{4f6}',\n        ['\\u{4f7}', '\\0', '\\0']), ('\\u{4f8}', ['\\u{4f9}', '\\0', '\\0']), ('\\u{4fa}', ['\\u{4fb}',\n        '\\0', '\\0']), ('\\u{4fc}', ['\\u{4fd}', '\\0', '\\0']), ('\\u{4fe}', ['\\u{4ff}', '\\0', '\\0']),\n        ('\\u{500}', ['\\u{501}', '\\0', '\\0']), ('\\u{502}', ['\\u{503}', '\\0', '\\0']), ('\\u{504}',\n        ['\\u{505}', '\\0', '\\0']), ('\\u{506}', ['\\u{507}', '\\0', '\\0']), ('\\u{508}', ['\\u{509}',\n        '\\0', '\\0']), ('\\u{50a}', ['\\u{50b}', '\\0', '\\0']), ('\\u{50c}', ['\\u{50d}', '\\0', '\\0']),\n        ('\\u{50e}', ['\\u{50f}', '\\0', '\\0']), ('\\u{510}', ['\\u{511}', '\\0', '\\0']), ('\\u{512}',\n        ['\\u{513}', '\\0', '\\0']), ('\\u{514}', ['\\u{515}', '\\0', '\\0']), ('\\u{516}', ['\\u{517}',\n        '\\0', '\\0']), ('\\u{518}', ['\\u{519}', '\\0', '\\0']), ('\\u{51a}', ['\\u{51b}', '\\0', '\\0']),\n        ('\\u{51c}', ['\\u{51d}', '\\0', '\\0']), ('\\u{51e}', ['\\u{51f}', '\\0', '\\0']), ('\\u{520}',\n        ['\\u{521}', '\\0', '\\0']), ('\\u{522}', ['\\u{523}', '\\0', '\\0']), ('\\u{524}', ['\\u{525}',\n        '\\0', '\\0']), ('\\u{526}', ['\\u{527}', '\\0', '\\0']), ('\\u{528}', ['\\u{529}', '\\0', '\\0']),\n        ('\\u{52a}', ['\\u{52b}', '\\0', '\\0']), ('\\u{52c}', ['\\u{52d}', '\\0', '\\0']), ('\\u{52e}',\n        ['\\u{52f}', '\\0', '\\0']), ('\\u{531}', ['\\u{561}', '\\0', '\\0']), ('\\u{532}', ['\\u{562}',\n        '\\0', '\\0']), ('\\u{533}', ['\\u{563}', '\\0', '\\0']), ('\\u{534}', ['\\u{564}', '\\0', '\\0']),\n        ('\\u{535}', ['\\u{565}', '\\0', '\\0']), ('\\u{536}', ['\\u{566}', '\\0', '\\0']), ('\\u{537}',\n        ['\\u{567}', '\\0', '\\0']), ('\\u{538}', ['\\u{568}', '\\0', '\\0']), ('\\u{539}', ['\\u{569}',\n        '\\0', '\\0']), ('\\u{53a}', ['\\u{56a}', '\\0', '\\0']), ('\\u{53b}', ['\\u{56b}', '\\0', '\\0']),\n        ('\\u{53c}', ['\\u{56c}', '\\0', '\\0']), ('\\u{53d}', ['\\u{56d}', '\\0', '\\0']), ('\\u{53e}',\n        ['\\u{56e}', '\\0', '\\0']), ('\\u{53f}', ['\\u{56f}', '\\0', '\\0']), ('\\u{540}', ['\\u{570}',\n        '\\0', '\\0']), ('\\u{541}', ['\\u{571}', '\\0', '\\0']), ('\\u{542}', ['\\u{572}', '\\0', '\\0']),\n        ('\\u{543}', ['\\u{573}', '\\0', '\\0']), ('\\u{544}', ['\\u{574}', '\\0', '\\0']), ('\\u{545}',\n        ['\\u{575}', '\\0', '\\0']), ('\\u{546}', ['\\u{576}', '\\0', '\\0']), ('\\u{547}', ['\\u{577}',\n        '\\0', '\\0']), ('\\u{548}', ['\\u{578}', '\\0', '\\0']), ('\\u{549}', ['\\u{579}', '\\0', '\\0']),\n        ('\\u{54a}', ['\\u{57a}', '\\0', '\\0']), ('\\u{54b}', ['\\u{57b}', '\\0', '\\0']), ('\\u{54c}',\n        ['\\u{57c}', '\\0', '\\0']), ('\\u{54d}', ['\\u{57d}', '\\0', '\\0']), ('\\u{54e}', ['\\u{57e}',\n        '\\0', '\\0']), ('\\u{54f}', ['\\u{57f}', '\\0', '\\0']), ('\\u{550}', ['\\u{580}', '\\0', '\\0']),\n        ('\\u{551}', ['\\u{581}', '\\0', '\\0']), ('\\u{552}', ['\\u{582}', '\\0', '\\0']), ('\\u{553}',\n        ['\\u{583}', '\\0', '\\0']), ('\\u{554}', ['\\u{584}', '\\0', '\\0']), ('\\u{555}', ['\\u{585}',\n        '\\0', '\\0']), ('\\u{556}', ['\\u{586}', '\\0', '\\0']), ('\\u{10a0}', ['\\u{2d00}', '\\0', '\\0']),\n        ('\\u{10a1}', ['\\u{2d01}', '\\0', '\\0']), ('\\u{10a2}', ['\\u{2d02}', '\\0', '\\0']), ('\\u{10a3}',\n        ['\\u{2d03}', '\\0', '\\0']), ('\\u{10a4}', ['\\u{2d04}', '\\0', '\\0']), ('\\u{10a5}', ['\\u{2d05}',\n        '\\0', '\\0']), ('\\u{10a6}', ['\\u{2d06}', '\\0', '\\0']), ('\\u{10a7}', ['\\u{2d07}', '\\0',\n        '\\0']), ('\\u{10a8}', ['\\u{2d08}', '\\0', '\\0']), ('\\u{10a9}', ['\\u{2d09}', '\\0', '\\0']),\n        ('\\u{10aa}', ['\\u{2d0a}', '\\0', '\\0']), ('\\u{10ab}', ['\\u{2d0b}', '\\0', '\\0']), ('\\u{10ac}',\n        ['\\u{2d0c}', '\\0', '\\0']), ('\\u{10ad}', ['\\u{2d0d}', '\\0', '\\0']), ('\\u{10ae}', ['\\u{2d0e}',\n        '\\0', '\\0']), ('\\u{10af}', ['\\u{2d0f}', '\\0', '\\0']), ('\\u{10b0}', ['\\u{2d10}', '\\0',\n        '\\0']), ('\\u{10b1}', ['\\u{2d11}', '\\0', '\\0']), ('\\u{10b2}', ['\\u{2d12}', '\\0', '\\0']),\n        ('\\u{10b3}', ['\\u{2d13}', '\\0', '\\0']), ('\\u{10b4}', ['\\u{2d14}', '\\0', '\\0']), ('\\u{10b5}',\n        ['\\u{2d15}', '\\0', '\\0']), ('\\u{10b6}', ['\\u{2d16}', '\\0', '\\0']), ('\\u{10b7}', ['\\u{2d17}',\n        '\\0', '\\0']), ('\\u{10b8}', ['\\u{2d18}', '\\0', '\\0']), ('\\u{10b9}', ['\\u{2d19}', '\\0',\n        '\\0']), ('\\u{10ba}', ['\\u{2d1a}', '\\0', '\\0']), ('\\u{10bb}', ['\\u{2d1b}', '\\0', '\\0']),\n        ('\\u{10bc}', ['\\u{2d1c}', '\\0', '\\0']), ('\\u{10bd}', ['\\u{2d1d}', '\\0', '\\0']), ('\\u{10be}',\n        ['\\u{2d1e}', '\\0', '\\0']), ('\\u{10bf}', ['\\u{2d1f}', '\\0', '\\0']), ('\\u{10c0}', ['\\u{2d20}',\n        '\\0', '\\0']), ('\\u{10c1}', ['\\u{2d21}', '\\0', '\\0']), ('\\u{10c2}', ['\\u{2d22}', '\\0',\n        '\\0']), ('\\u{10c3}', ['\\u{2d23}', '\\0', '\\0']), ('\\u{10c4}', ['\\u{2d24}', '\\0', '\\0']),\n        ('\\u{10c5}', ['\\u{2d25}', '\\0', '\\0']), ('\\u{10c7}', ['\\u{2d27}', '\\0', '\\0']), ('\\u{10cd}',\n        ['\\u{2d2d}', '\\0', '\\0']), ('\\u{13a0}', ['\\u{ab70}', '\\0', '\\0']), ('\\u{13a1}', ['\\u{ab71}',\n        '\\0', '\\0']), ('\\u{13a2}', ['\\u{ab72}', '\\0', '\\0']), ('\\u{13a3}', ['\\u{ab73}', '\\0',\n        '\\0']), ('\\u{13a4}', ['\\u{ab74}', '\\0', '\\0']), ('\\u{13a5}', ['\\u{ab75}', '\\0', '\\0']),\n        ('\\u{13a6}', ['\\u{ab76}', '\\0', '\\0']), ('\\u{13a7}', ['\\u{ab77}', '\\0', '\\0']), ('\\u{13a8}',\n        ['\\u{ab78}', '\\0', '\\0']), ('\\u{13a9}', ['\\u{ab79}', '\\0', '\\0']), ('\\u{13aa}', ['\\u{ab7a}',\n        '\\0', '\\0']), ('\\u{13ab}', ['\\u{ab7b}', '\\0', '\\0']), ('\\u{13ac}', ['\\u{ab7c}', '\\0',\n        '\\0']), ('\\u{13ad}', ['\\u{ab7d}', '\\0', '\\0']), ('\\u{13ae}', ['\\u{ab7e}', '\\0', '\\0']),\n        ('\\u{13af}', ['\\u{ab7f}', '\\0', '\\0']), ('\\u{13b0}', ['\\u{ab80}', '\\0', '\\0']), ('\\u{13b1}',\n        ['\\u{ab81}', '\\0', '\\0']), ('\\u{13b2}', ['\\u{ab82}', '\\0', '\\0']), ('\\u{13b3}', ['\\u{ab83}',\n        '\\0', '\\0']), ('\\u{13b4}', ['\\u{ab84}', '\\0', '\\0']), ('\\u{13b5}', ['\\u{ab85}', '\\0',\n        '\\0']), ('\\u{13b6}', ['\\u{ab86}', '\\0', '\\0']), ('\\u{13b7}', ['\\u{ab87}', '\\0', '\\0']),\n        ('\\u{13b8}', ['\\u{ab88}', '\\0', '\\0']), ('\\u{13b9}', ['\\u{ab89}', '\\0', '\\0']), ('\\u{13ba}',\n        ['\\u{ab8a}', '\\0', '\\0']), ('\\u{13bb}', ['\\u{ab8b}', '\\0', '\\0']), ('\\u{13bc}', ['\\u{ab8c}',\n        '\\0', '\\0']), ('\\u{13bd}', ['\\u{ab8d}', '\\0', '\\0']), ('\\u{13be}', ['\\u{ab8e}', '\\0',\n        '\\0']), ('\\u{13bf}', ['\\u{ab8f}', '\\0', '\\0']), ('\\u{13c0}', ['\\u{ab90}', '\\0', '\\0']),\n        ('\\u{13c1}', ['\\u{ab91}', '\\0', '\\0']), ('\\u{13c2}', ['\\u{ab92}', '\\0', '\\0']), ('\\u{13c3}',\n        ['\\u{ab93}', '\\0', '\\0']), ('\\u{13c4}', ['\\u{ab94}', '\\0', '\\0']), ('\\u{13c5}', ['\\u{ab95}',\n        '\\0', '\\0']), ('\\u{13c6}', ['\\u{ab96}', '\\0', '\\0']), ('\\u{13c7}', ['\\u{ab97}', '\\0',\n        '\\0']), ('\\u{13c8}', ['\\u{ab98}', '\\0', '\\0']), ('\\u{13c9}', ['\\u{ab99}', '\\0', '\\0']),\n        ('\\u{13ca}', ['\\u{ab9a}', '\\0', '\\0']), ('\\u{13cb}', ['\\u{ab9b}', '\\0', '\\0']), ('\\u{13cc}',\n        ['\\u{ab9c}', '\\0', '\\0']), ('\\u{13cd}', ['\\u{ab9d}', '\\0', '\\0']), ('\\u{13ce}', ['\\u{ab9e}',\n        '\\0', '\\0']), ('\\u{13cf}', ['\\u{ab9f}', '\\0', '\\0']), ('\\u{13d0}', ['\\u{aba0}', '\\0',\n        '\\0']), ('\\u{13d1}', ['\\u{aba1}', '\\0', '\\0']), ('\\u{13d2}', ['\\u{aba2}', '\\0', '\\0']),\n        ('\\u{13d3}', ['\\u{aba3}', '\\0', '\\0']), ('\\u{13d4}', ['\\u{aba4}', '\\0', '\\0']), ('\\u{13d5}',\n        ['\\u{aba5}', '\\0', '\\0']), ('\\u{13d6}', ['\\u{aba6}', '\\0', '\\0']), ('\\u{13d7}', ['\\u{aba7}',\n        '\\0', '\\0']), ('\\u{13d8}', ['\\u{aba8}', '\\0', '\\0']), ('\\u{13d9}', ['\\u{aba9}', '\\0',\n        '\\0']), ('\\u{13da}', ['\\u{abaa}', '\\0', '\\0']), ('\\u{13db}', ['\\u{abab}', '\\0', '\\0']),\n        ('\\u{13dc}', ['\\u{abac}', '\\0', '\\0']), ('\\u{13dd}', ['\\u{abad}', '\\0', '\\0']), ('\\u{13de}',\n        ['\\u{abae}', '\\0', '\\0']), ('\\u{13df}', ['\\u{abaf}', '\\0', '\\0']), ('\\u{13e0}', ['\\u{abb0}',\n        '\\0', '\\0']), ('\\u{13e1}', ['\\u{abb1}', '\\0', '\\0']), ('\\u{13e2}', ['\\u{abb2}', '\\0',\n        '\\0']), ('\\u{13e3}', ['\\u{abb3}', '\\0', '\\0']), ('\\u{13e4}', ['\\u{abb4}', '\\0', '\\0']),\n        ('\\u{13e5}', ['\\u{abb5}', '\\0', '\\0']), ('\\u{13e6}', ['\\u{abb6}', '\\0', '\\0']), ('\\u{13e7}',\n        ['\\u{abb7}', '\\0', '\\0']), ('\\u{13e8}', ['\\u{abb8}', '\\0', '\\0']), ('\\u{13e9}', ['\\u{abb9}',\n        '\\0', '\\0']), ('\\u{13ea}', ['\\u{abba}', '\\0', '\\0']), ('\\u{13eb}', ['\\u{abbb}', '\\0',\n        '\\0']), ('\\u{13ec}', ['\\u{abbc}', '\\0', '\\0']), ('\\u{13ed}', ['\\u{abbd}', '\\0', '\\0']),\n        ('\\u{13ee}', ['\\u{abbe}', '\\0', '\\0']), ('\\u{13ef}', ['\\u{abbf}', '\\0', '\\0']), ('\\u{13f0}',\n        ['\\u{13f8}', '\\0', '\\0']), ('\\u{13f1}', ['\\u{13f9}', '\\0', '\\0']), ('\\u{13f2}', ['\\u{13fa}',\n        '\\0', '\\0']), ('\\u{13f3}', ['\\u{13fb}', '\\0', '\\0']), ('\\u{13f4}', ['\\u{13fc}', '\\0',\n        '\\0']), ('\\u{13f5}', ['\\u{13fd}', '\\0', '\\0']), ('\\u{1c90}', ['\\u{10d0}', '\\0', '\\0']),\n        ('\\u{1c91}', ['\\u{10d1}', '\\0', '\\0']), ('\\u{1c92}', ['\\u{10d2}', '\\0', '\\0']), ('\\u{1c93}',\n        ['\\u{10d3}', '\\0', '\\0']), ('\\u{1c94}', ['\\u{10d4}', '\\0', '\\0']), ('\\u{1c95}', ['\\u{10d5}',\n        '\\0', '\\0']), ('\\u{1c96}', ['\\u{10d6}', '\\0', '\\0']), ('\\u{1c97}', ['\\u{10d7}', '\\0',\n        '\\0']), ('\\u{1c98}', ['\\u{10d8}', '\\0', '\\0']), ('\\u{1c99}', ['\\u{10d9}', '\\0', '\\0']),\n        ('\\u{1c9a}', ['\\u{10da}', '\\0', '\\0']), ('\\u{1c9b}', ['\\u{10db}', '\\0', '\\0']), ('\\u{1c9c}',\n        ['\\u{10dc}', '\\0', '\\0']), ('\\u{1c9d}', ['\\u{10dd}', '\\0', '\\0']), ('\\u{1c9e}', ['\\u{10de}',\n        '\\0', '\\0']), ('\\u{1c9f}', ['\\u{10df}', '\\0', '\\0']), ('\\u{1ca0}', ['\\u{10e0}', '\\0',\n        '\\0']), ('\\u{1ca1}', ['\\u{10e1}', '\\0', '\\0']), ('\\u{1ca2}', ['\\u{10e2}', '\\0', '\\0']),\n        ('\\u{1ca3}', ['\\u{10e3}', '\\0', '\\0']), ('\\u{1ca4}', ['\\u{10e4}', '\\0', '\\0']), ('\\u{1ca5}',\n        ['\\u{10e5}', '\\0', '\\0']), ('\\u{1ca6}', ['\\u{10e6}', '\\0', '\\0']), ('\\u{1ca7}', ['\\u{10e7}',\n        '\\0', '\\0']), ('\\u{1ca8}', ['\\u{10e8}', '\\0', '\\0']), ('\\u{1ca9}', ['\\u{10e9}', '\\0',\n        '\\0']), ('\\u{1caa}', ['\\u{10ea}', '\\0', '\\0']), ('\\u{1cab}', ['\\u{10eb}', '\\0', '\\0']),\n        ('\\u{1cac}', ['\\u{10ec}', '\\0', '\\0']), ('\\u{1cad}', ['\\u{10ed}', '\\0', '\\0']), ('\\u{1cae}',\n        ['\\u{10ee}', '\\0', '\\0']), ('\\u{1caf}', ['\\u{10ef}', '\\0', '\\0']), ('\\u{1cb0}', ['\\u{10f0}',\n        '\\0', '\\0']), ('\\u{1cb1}', ['\\u{10f1}', '\\0', '\\0']), ('\\u{1cb2}', ['\\u{10f2}', '\\0',\n        '\\0']), ('\\u{1cb3}', ['\\u{10f3}', '\\0', '\\0']), ('\\u{1cb4}', ['\\u{10f4}', '\\0', '\\0']),\n        ('\\u{1cb5}', ['\\u{10f5}', '\\0', '\\0']), ('\\u{1cb6}', ['\\u{10f6}', '\\0', '\\0']), ('\\u{1cb7}',\n        ['\\u{10f7}', '\\0', '\\0']), ('\\u{1cb8}', ['\\u{10f8}', '\\0', '\\0']), ('\\u{1cb9}', ['\\u{10f9}',\n        '\\0', '\\0']), ('\\u{1cba}', ['\\u{10fa}', '\\0', '\\0']), ('\\u{1cbd}', ['\\u{10fd}', '\\0',\n        '\\0']), ('\\u{1cbe}', ['\\u{10fe}', '\\0', '\\0']), ('\\u{1cbf}', ['\\u{10ff}', '\\0', '\\0']),\n        ('\\u{1e00}', ['\\u{1e01}', '\\0', '\\0']), ('\\u{1e02}', ['\\u{1e03}', '\\0', '\\0']), ('\\u{1e04}',\n        ['\\u{1e05}', '\\0', '\\0']), ('\\u{1e06}', ['\\u{1e07}', '\\0', '\\0']), ('\\u{1e08}', ['\\u{1e09}',\n        '\\0', '\\0']), ('\\u{1e0a}', ['\\u{1e0b}', '\\0', '\\0']), ('\\u{1e0c}', ['\\u{1e0d}', '\\0',\n        '\\0']), ('\\u{1e0e}', ['\\u{1e0f}', '\\0', '\\0']), ('\\u{1e10}', ['\\u{1e11}', '\\0', '\\0']),\n        ('\\u{1e12}', ['\\u{1e13}', '\\0', '\\0']), ('\\u{1e14}', ['\\u{1e15}', '\\0', '\\0']), ('\\u{1e16}',\n        ['\\u{1e17}', '\\0', '\\0']), ('\\u{1e18}', ['\\u{1e19}', '\\0', '\\0']), ('\\u{1e1a}', ['\\u{1e1b}',\n        '\\0', '\\0']), ('\\u{1e1c}', ['\\u{1e1d}', '\\0', '\\0']), ('\\u{1e1e}', ['\\u{1e1f}', '\\0',\n        '\\0']), ('\\u{1e20}', ['\\u{1e21}', '\\0', '\\0']), ('\\u{1e22}', ['\\u{1e23}', '\\0', '\\0']),\n        ('\\u{1e24}', ['\\u{1e25}', '\\0', '\\0']), ('\\u{1e26}', ['\\u{1e27}', '\\0', '\\0']), ('\\u{1e28}',\n        ['\\u{1e29}', '\\0', '\\0']), ('\\u{1e2a}', ['\\u{1e2b}', '\\0', '\\0']), ('\\u{1e2c}', ['\\u{1e2d}',\n        '\\0', '\\0']), ('\\u{1e2e}', ['\\u{1e2f}', '\\0', '\\0']), ('\\u{1e30}', ['\\u{1e31}', '\\0',\n        '\\0']), ('\\u{1e32}', ['\\u{1e33}', '\\0', '\\0']), ('\\u{1e34}', ['\\u{1e35}', '\\0', '\\0']),\n        ('\\u{1e36}', ['\\u{1e37}', '\\0', '\\0']), ('\\u{1e38}', ['\\u{1e39}', '\\0', '\\0']), ('\\u{1e3a}',\n        ['\\u{1e3b}', '\\0', '\\0']), ('\\u{1e3c}', ['\\u{1e3d}', '\\0', '\\0']), ('\\u{1e3e}', ['\\u{1e3f}',\n        '\\0', '\\0']), ('\\u{1e40}', ['\\u{1e41}', '\\0', '\\0']), ('\\u{1e42}', ['\\u{1e43}', '\\0',\n        '\\0']), ('\\u{1e44}', ['\\u{1e45}', '\\0', '\\0']), ('\\u{1e46}', ['\\u{1e47}', '\\0', '\\0']),\n        ('\\u{1e48}', ['\\u{1e49}', '\\0', '\\0']), ('\\u{1e4a}', ['\\u{1e4b}', '\\0', '\\0']), ('\\u{1e4c}',\n        ['\\u{1e4d}', '\\0', '\\0']), ('\\u{1e4e}', ['\\u{1e4f}', '\\0', '\\0']), ('\\u{1e50}', ['\\u{1e51}',\n        '\\0', '\\0']), ('\\u{1e52}', ['\\u{1e53}', '\\0', '\\0']), ('\\u{1e54}', ['\\u{1e55}', '\\0',\n        '\\0']), ('\\u{1e56}', ['\\u{1e57}', '\\0', '\\0']), ('\\u{1e58}', ['\\u{1e59}', '\\0', '\\0']),\n        ('\\u{1e5a}', ['\\u{1e5b}', '\\0', '\\0']), ('\\u{1e5c}', ['\\u{1e5d}', '\\0', '\\0']), ('\\u{1e5e}',\n        ['\\u{1e5f}', '\\0', '\\0']), ('\\u{1e60}', ['\\u{1e61}', '\\0', '\\0']), ('\\u{1e62}', ['\\u{1e63}',\n        '\\0', '\\0']), ('\\u{1e64}', ['\\u{1e65}', '\\0', '\\0']), ('\\u{1e66}', ['\\u{1e67}', '\\0',\n        '\\0']), ('\\u{1e68}', ['\\u{1e69}', '\\0', '\\0']), ('\\u{1e6a}', ['\\u{1e6b}', '\\0', '\\0']),\n        ('\\u{1e6c}', ['\\u{1e6d}', '\\0', '\\0']), ('\\u{1e6e}', ['\\u{1e6f}', '\\0', '\\0']), ('\\u{1e70}',\n        ['\\u{1e71}', '\\0', '\\0']), ('\\u{1e72}', ['\\u{1e73}', '\\0', '\\0']), ('\\u{1e74}', ['\\u{1e75}',\n        '\\0', '\\0']), ('\\u{1e76}', ['\\u{1e77}', '\\0', '\\0']), ('\\u{1e78}', ['\\u{1e79}', '\\0',\n        '\\0']), ('\\u{1e7a}', ['\\u{1e7b}', '\\0', '\\0']), ('\\u{1e7c}', ['\\u{1e7d}', '\\0', '\\0']),\n        ('\\u{1e7e}', ['\\u{1e7f}', '\\0', '\\0']), ('\\u{1e80}', ['\\u{1e81}', '\\0', '\\0']), ('\\u{1e82}',\n        ['\\u{1e83}', '\\0', '\\0']), ('\\u{1e84}', ['\\u{1e85}', '\\0', '\\0']), ('\\u{1e86}', ['\\u{1e87}',\n        '\\0', '\\0']), ('\\u{1e88}', ['\\u{1e89}', '\\0', '\\0']), ('\\u{1e8a}', ['\\u{1e8b}', '\\0',\n        '\\0']), ('\\u{1e8c}', ['\\u{1e8d}', '\\0', '\\0']), ('\\u{1e8e}', ['\\u{1e8f}', '\\0', '\\0']),\n        ('\\u{1e90}', ['\\u{1e91}', '\\0', '\\0']), ('\\u{1e92}', ['\\u{1e93}', '\\0', '\\0']), ('\\u{1e94}',\n        ['\\u{1e95}', '\\0', '\\0']), ('\\u{1e9e}', ['\\u{df}', '\\0', '\\0']), ('\\u{1ea0}', ['\\u{1ea1}',\n        '\\0', '\\0']), ('\\u{1ea2}', ['\\u{1ea3}', '\\0', '\\0']), ('\\u{1ea4}', ['\\u{1ea5}', '\\0',\n        '\\0']), ('\\u{1ea6}', ['\\u{1ea7}', '\\0', '\\0']), ('\\u{1ea8}', ['\\u{1ea9}', '\\0', '\\0']),\n        ('\\u{1eaa}', ['\\u{1eab}', '\\0', '\\0']), ('\\u{1eac}', ['\\u{1ead}', '\\0', '\\0']), ('\\u{1eae}',\n        ['\\u{1eaf}', '\\0', '\\0']), ('\\u{1eb0}', ['\\u{1eb1}', '\\0', '\\0']), ('\\u{1eb2}', ['\\u{1eb3}',\n        '\\0', '\\0']), ('\\u{1eb4}', ['\\u{1eb5}', '\\0', '\\0']), ('\\u{1eb6}', ['\\u{1eb7}', '\\0',\n        '\\0']), ('\\u{1eb8}', ['\\u{1eb9}', '\\0', '\\0']), ('\\u{1eba}', ['\\u{1ebb}', '\\0', '\\0']),\n        ('\\u{1ebc}', ['\\u{1ebd}', '\\0', '\\0']), ('\\u{1ebe}', ['\\u{1ebf}', '\\0', '\\0']), ('\\u{1ec0}',\n        ['\\u{1ec1}', '\\0', '\\0']), ('\\u{1ec2}', ['\\u{1ec3}', '\\0', '\\0']), ('\\u{1ec4}', ['\\u{1ec5}',\n        '\\0', '\\0']), ('\\u{1ec6}', ['\\u{1ec7}', '\\0', '\\0']), ('\\u{1ec8}', ['\\u{1ec9}', '\\0',\n        '\\0']), ('\\u{1eca}', ['\\u{1ecb}', '\\0', '\\0']), ('\\u{1ecc}', ['\\u{1ecd}', '\\0', '\\0']),\n        ('\\u{1ece}', ['\\u{1ecf}', '\\0', '\\0']), ('\\u{1ed0}', ['\\u{1ed1}', '\\0', '\\0']), ('\\u{1ed2}',\n        ['\\u{1ed3}', '\\0', '\\0']), ('\\u{1ed4}', ['\\u{1ed5}', '\\0', '\\0']), ('\\u{1ed6}', ['\\u{1ed7}',\n        '\\0', '\\0']), ('\\u{1ed8}', ['\\u{1ed9}', '\\0', '\\0']), ('\\u{1eda}', ['\\u{1edb}', '\\0',\n        '\\0']), ('\\u{1edc}', ['\\u{1edd}', '\\0', '\\0']), ('\\u{1ede}', ['\\u{1edf}', '\\0', '\\0']),\n        ('\\u{1ee0}', ['\\u{1ee1}', '\\0', '\\0']), ('\\u{1ee2}', ['\\u{1ee3}', '\\0', '\\0']), ('\\u{1ee4}',\n        ['\\u{1ee5}', '\\0', '\\0']), ('\\u{1ee6}', ['\\u{1ee7}', '\\0', '\\0']), ('\\u{1ee8}', ['\\u{1ee9}',\n        '\\0', '\\0']), ('\\u{1eea}', ['\\u{1eeb}', '\\0', '\\0']), ('\\u{1eec}', ['\\u{1eed}', '\\0',\n        '\\0']), ('\\u{1eee}', ['\\u{1eef}', '\\0', '\\0']), ('\\u{1ef0}', ['\\u{1ef1}', '\\0', '\\0']),\n        ('\\u{1ef2}', ['\\u{1ef3}', '\\0', '\\0']), ('\\u{1ef4}', ['\\u{1ef5}', '\\0', '\\0']), ('\\u{1ef6}',\n        ['\\u{1ef7}', '\\0', '\\0']), ('\\u{1ef8}', ['\\u{1ef9}', '\\0', '\\0']), ('\\u{1efa}', ['\\u{1efb}',\n        '\\0', '\\0']), ('\\u{1efc}', ['\\u{1efd}', '\\0', '\\0']), ('\\u{1efe}', ['\\u{1eff}', '\\0',\n        '\\0']), ('\\u{1f08}', ['\\u{1f00}', '\\0', '\\0']), ('\\u{1f09}', ['\\u{1f01}', '\\0', '\\0']),\n        ('\\u{1f0a}', ['\\u{1f02}', '\\0', '\\0']), ('\\u{1f0b}', ['\\u{1f03}', '\\0', '\\0']), ('\\u{1f0c}',\n        ['\\u{1f04}', '\\0', '\\0']), ('\\u{1f0d}', ['\\u{1f05}', '\\0', '\\0']), ('\\u{1f0e}', ['\\u{1f06}',\n        '\\0', '\\0']), ('\\u{1f0f}', ['\\u{1f07}', '\\0', '\\0']), ('\\u{1f18}', ['\\u{1f10}', '\\0',\n        '\\0']), ('\\u{1f19}', ['\\u{1f11}', '\\0', '\\0']), ('\\u{1f1a}', ['\\u{1f12}', '\\0', '\\0']),\n        ('\\u{1f1b}', ['\\u{1f13}', '\\0', '\\0']), ('\\u{1f1c}', ['\\u{1f14}', '\\0', '\\0']), ('\\u{1f1d}',\n        ['\\u{1f15}', '\\0', '\\0']), ('\\u{1f28}', ['\\u{1f20}', '\\0', '\\0']), ('\\u{1f29}', ['\\u{1f21}',\n        '\\0', '\\0']), ('\\u{1f2a}', ['\\u{1f22}', '\\0', '\\0']), ('\\u{1f2b}', ['\\u{1f23}', '\\0',\n        '\\0']), ('\\u{1f2c}', ['\\u{1f24}', '\\0', '\\0']), ('\\u{1f2d}', ['\\u{1f25}', '\\0', '\\0']),\n        ('\\u{1f2e}', ['\\u{1f26}', '\\0', '\\0']), ('\\u{1f2f}', ['\\u{1f27}', '\\0', '\\0']), ('\\u{1f38}',\n        ['\\u{1f30}', '\\0', '\\0']), ('\\u{1f39}', ['\\u{1f31}', '\\0', '\\0']), ('\\u{1f3a}', ['\\u{1f32}',\n        '\\0', '\\0']), ('\\u{1f3b}', ['\\u{1f33}', '\\0', '\\0']), ('\\u{1f3c}', ['\\u{1f34}', '\\0',\n        '\\0']), ('\\u{1f3d}', ['\\u{1f35}', '\\0', '\\0']), ('\\u{1f3e}', ['\\u{1f36}', '\\0', '\\0']),\n        ('\\u{1f3f}', ['\\u{1f37}', '\\0', '\\0']), ('\\u{1f48}', ['\\u{1f40}', '\\0', '\\0']), ('\\u{1f49}',\n        ['\\u{1f41}', '\\0', '\\0']), ('\\u{1f4a}', ['\\u{1f42}', '\\0', '\\0']), ('\\u{1f4b}', ['\\u{1f43}',\n        '\\0', '\\0']), ('\\u{1f4c}', ['\\u{1f44}', '\\0', '\\0']), ('\\u{1f4d}', ['\\u{1f45}', '\\0',\n        '\\0']), ('\\u{1f59}', ['\\u{1f51}', '\\0', '\\0']), ('\\u{1f5b}', ['\\u{1f53}', '\\0', '\\0']),\n        ('\\u{1f5d}', ['\\u{1f55}', '\\0', '\\0']), ('\\u{1f5f}', ['\\u{1f57}', '\\0', '\\0']), ('\\u{1f68}',\n        ['\\u{1f60}', '\\0', '\\0']), ('\\u{1f69}', ['\\u{1f61}', '\\0', '\\0']), ('\\u{1f6a}', ['\\u{1f62}',\n        '\\0', '\\0']), ('\\u{1f6b}', ['\\u{1f63}', '\\0', '\\0']), ('\\u{1f6c}', ['\\u{1f64}', '\\0',\n        '\\0']), ('\\u{1f6d}', ['\\u{1f65}', '\\0', '\\0']), ('\\u{1f6e}', ['\\u{1f66}', '\\0', '\\0']),\n        ('\\u{1f6f}', ['\\u{1f67}', '\\0', '\\0']), ('\\u{1f88}', ['\\u{1f80}', '\\0', '\\0']), ('\\u{1f89}',\n        ['\\u{1f81}', '\\0', '\\0']), ('\\u{1f8a}', ['\\u{1f82}', '\\0', '\\0']), ('\\u{1f8b}', ['\\u{1f83}',\n        '\\0', '\\0']), ('\\u{1f8c}', ['\\u{1f84}', '\\0', '\\0']), ('\\u{1f8d}', ['\\u{1f85}', '\\0',\n        '\\0']), ('\\u{1f8e}', ['\\u{1f86}', '\\0', '\\0']), ('\\u{1f8f}', ['\\u{1f87}', '\\0', '\\0']),\n        ('\\u{1f98}', ['\\u{1f90}', '\\0', '\\0']), ('\\u{1f99}', ['\\u{1f91}', '\\0', '\\0']), ('\\u{1f9a}',\n        ['\\u{1f92}', '\\0', '\\0']), ('\\u{1f9b}', ['\\u{1f93}', '\\0', '\\0']), ('\\u{1f9c}', ['\\u{1f94}',\n        '\\0', '\\0']), ('\\u{1f9d}', ['\\u{1f95}', '\\0', '\\0']), ('\\u{1f9e}', ['\\u{1f96}', '\\0',\n        '\\0']), ('\\u{1f9f}', ['\\u{1f97}', '\\0', '\\0']), ('\\u{1fa8}', ['\\u{1fa0}', '\\0', '\\0']),\n        ('\\u{1fa9}', ['\\u{1fa1}', '\\0', '\\0']), ('\\u{1faa}', ['\\u{1fa2}', '\\0', '\\0']), ('\\u{1fab}',\n        ['\\u{1fa3}', '\\0', '\\0']), ('\\u{1fac}', ['\\u{1fa4}', '\\0', '\\0']), ('\\u{1fad}', ['\\u{1fa5}',\n        '\\0', '\\0']), ('\\u{1fae}', ['\\u{1fa6}', '\\0', '\\0']), ('\\u{1faf}', ['\\u{1fa7}', '\\0',\n        '\\0']), ('\\u{1fb8}', ['\\u{1fb0}', '\\0', '\\0']), ('\\u{1fb9}', ['\\u{1fb1}', '\\0', '\\0']),\n        ('\\u{1fba}', ['\\u{1f70}', '\\0', '\\0']), ('\\u{1fbb}', ['\\u{1f71}', '\\0', '\\0']), ('\\u{1fbc}',\n        ['\\u{1fb3}', '\\0', '\\0']), ('\\u{1fc8}', ['\\u{1f72}', '\\0', '\\0']), ('\\u{1fc9}', ['\\u{1f73}',\n        '\\0', '\\0']), ('\\u{1fca}', ['\\u{1f74}', '\\0', '\\0']), ('\\u{1fcb}', ['\\u{1f75}', '\\0',\n        '\\0']), ('\\u{1fcc}', ['\\u{1fc3}', '\\0', '\\0']), ('\\u{1fd8}', ['\\u{1fd0}', '\\0', '\\0']),\n        ('\\u{1fd9}', ['\\u{1fd1}', '\\0', '\\0']), ('\\u{1fda}', ['\\u{1f76}', '\\0', '\\0']), ('\\u{1fdb}',\n        ['\\u{1f77}', '\\0', '\\0']), ('\\u{1fe8}', ['\\u{1fe0}', '\\0', '\\0']), ('\\u{1fe9}', ['\\u{1fe1}',\n        '\\0', '\\0']), ('\\u{1fea}', ['\\u{1f7a}', '\\0', '\\0']), ('\\u{1feb}', ['\\u{1f7b}', '\\0',\n        '\\0']), ('\\u{1fec}', ['\\u{1fe5}', '\\0', '\\0']), ('\\u{1ff8}', ['\\u{1f78}', '\\0', '\\0']),\n        ('\\u{1ff9}', ['\\u{1f79}', '\\0', '\\0']), ('\\u{1ffa}', ['\\u{1f7c}', '\\0', '\\0']), ('\\u{1ffb}',\n        ['\\u{1f7d}', '\\0', '\\0']), ('\\u{1ffc}', ['\\u{1ff3}', '\\0', '\\0']), ('\\u{2126}', ['\\u{3c9}',\n        '\\0', '\\0']), ('\\u{212a}', ['\\u{6b}', '\\0', '\\0']), ('\\u{212b}', ['\\u{e5}', '\\0', '\\0']),\n        ('\\u{2132}', ['\\u{214e}', '\\0', '\\0']), ('\\u{2160}', ['\\u{2170}', '\\0', '\\0']), ('\\u{2161}',\n        ['\\u{2171}', '\\0', '\\0']), ('\\u{2162}', ['\\u{2172}', '\\0', '\\0']), ('\\u{2163}', ['\\u{2173}',\n        '\\0', '\\0']), ('\\u{2164}', ['\\u{2174}', '\\0', '\\0']), ('\\u{2165}', ['\\u{2175}', '\\0',\n        '\\0']), ('\\u{2166}', ['\\u{2176}', '\\0', '\\0']), ('\\u{2167}', ['\\u{2177}', '\\0', '\\0']),\n        ('\\u{2168}', ['\\u{2178}', '\\0', '\\0']), ('\\u{2169}', ['\\u{2179}', '\\0', '\\0']), ('\\u{216a}',\n        ['\\u{217a}', '\\0', '\\0']), ('\\u{216b}', ['\\u{217b}', '\\0', '\\0']), ('\\u{216c}', ['\\u{217c}',\n        '\\0', '\\0']), ('\\u{216d}', ['\\u{217d}', '\\0', '\\0']), ('\\u{216e}', ['\\u{217e}', '\\0',\n        '\\0']), ('\\u{216f}', ['\\u{217f}', '\\0', '\\0']), ('\\u{2183}', ['\\u{2184}', '\\0', '\\0']),\n        ('\\u{24b6}', ['\\u{24d0}', '\\0', '\\0']), ('\\u{24b7}', ['\\u{24d1}', '\\0', '\\0']), ('\\u{24b8}',\n        ['\\u{24d2}', '\\0', '\\0']), ('\\u{24b9}', ['\\u{24d3}', '\\0', '\\0']), ('\\u{24ba}', ['\\u{24d4}',\n        '\\0', '\\0']), ('\\u{24bb}', ['\\u{24d5}', '\\0', '\\0']), ('\\u{24bc}', ['\\u{24d6}', '\\0',\n        '\\0']), ('\\u{24bd}', ['\\u{24d7}', '\\0', '\\0']), ('\\u{24be}', ['\\u{24d8}', '\\0', '\\0']),\n        ('\\u{24bf}', ['\\u{24d9}', '\\0', '\\0']), ('\\u{24c0}', ['\\u{24da}', '\\0', '\\0']), ('\\u{24c1}',\n        ['\\u{24db}', '\\0', '\\0']), ('\\u{24c2}', ['\\u{24dc}', '\\0', '\\0']), ('\\u{24c3}', ['\\u{24dd}',\n        '\\0', '\\0']), ('\\u{24c4}', ['\\u{24de}', '\\0', '\\0']), ('\\u{24c5}', ['\\u{24df}', '\\0',\n        '\\0']), ('\\u{24c6}', ['\\u{24e0}', '\\0', '\\0']), ('\\u{24c7}', ['\\u{24e1}', '\\0', '\\0']),\n        ('\\u{24c8}', ['\\u{24e2}', '\\0', '\\0']), ('\\u{24c9}', ['\\u{24e3}', '\\0', '\\0']), ('\\u{24ca}',\n        ['\\u{24e4}', '\\0', '\\0']), ('\\u{24cb}', ['\\u{24e5}', '\\0', '\\0']), ('\\u{24cc}', ['\\u{24e6}',\n        '\\0', '\\0']), ('\\u{24cd}', ['\\u{24e7}', '\\0', '\\0']), ('\\u{24ce}', ['\\u{24e8}', '\\0',\n        '\\0']), ('\\u{24cf}', ['\\u{24e9}', '\\0', '\\0']), ('\\u{2c00}', ['\\u{2c30}', '\\0', '\\0']),\n        ('\\u{2c01}', ['\\u{2c31}', '\\0', '\\0']), ('\\u{2c02}', ['\\u{2c32}', '\\0', '\\0']), ('\\u{2c03}',\n        ['\\u{2c33}', '\\0', '\\0']), ('\\u{2c04}', ['\\u{2c34}', '\\0', '\\0']), ('\\u{2c05}', ['\\u{2c35}',\n        '\\0', '\\0']), ('\\u{2c06}', ['\\u{2c36}', '\\0', '\\0']), ('\\u{2c07}', ['\\u{2c37}', '\\0',\n        '\\0']), ('\\u{2c08}', ['\\u{2c38}', '\\0', '\\0']), ('\\u{2c09}', ['\\u{2c39}', '\\0', '\\0']),\n        ('\\u{2c0a}', ['\\u{2c3a}', '\\0', '\\0']), ('\\u{2c0b}', ['\\u{2c3b}', '\\0', '\\0']), ('\\u{2c0c}',\n        ['\\u{2c3c}', '\\0', '\\0']), ('\\u{2c0d}', ['\\u{2c3d}', '\\0', '\\0']), ('\\u{2c0e}', ['\\u{2c3e}',\n        '\\0', '\\0']), ('\\u{2c0f}', ['\\u{2c3f}', '\\0', '\\0']), ('\\u{2c10}', ['\\u{2c40}', '\\0',\n        '\\0']), ('\\u{2c11}', ['\\u{2c41}', '\\0', '\\0']), ('\\u{2c12}', ['\\u{2c42}', '\\0', '\\0']),\n        ('\\u{2c13}', ['\\u{2c43}', '\\0', '\\0']), ('\\u{2c14}', ['\\u{2c44}', '\\0', '\\0']), ('\\u{2c15}',\n        ['\\u{2c45}', '\\0', '\\0']), ('\\u{2c16}', ['\\u{2c46}', '\\0', '\\0']), ('\\u{2c17}', ['\\u{2c47}',\n        '\\0', '\\0']), ('\\u{2c18}', ['\\u{2c48}', '\\0', '\\0']), ('\\u{2c19}', ['\\u{2c49}', '\\0',\n        '\\0']), ('\\u{2c1a}', ['\\u{2c4a}', '\\0', '\\0']), ('\\u{2c1b}', ['\\u{2c4b}', '\\0', '\\0']),\n        ('\\u{2c1c}', ['\\u{2c4c}', '\\0', '\\0']), ('\\u{2c1d}', ['\\u{2c4d}', '\\0', '\\0']), ('\\u{2c1e}',\n        ['\\u{2c4e}', '\\0', '\\0']), ('\\u{2c1f}', ['\\u{2c4f}', '\\0', '\\0']), ('\\u{2c20}', ['\\u{2c50}',\n        '\\0', '\\0']), ('\\u{2c21}', ['\\u{2c51}', '\\0', '\\0']), ('\\u{2c22}', ['\\u{2c52}', '\\0',\n        '\\0']), ('\\u{2c23}', ['\\u{2c53}', '\\0', '\\0']), ('\\u{2c24}', ['\\u{2c54}', '\\0', '\\0']),\n        ('\\u{2c25}', ['\\u{2c55}', '\\0', '\\0']), ('\\u{2c26}', ['\\u{2c56}', '\\0', '\\0']), ('\\u{2c27}',\n        ['\\u{2c57}', '\\0', '\\0']), ('\\u{2c28}', ['\\u{2c58}', '\\0', '\\0']), ('\\u{2c29}', ['\\u{2c59}',\n        '\\0', '\\0']), ('\\u{2c2a}', ['\\u{2c5a}', '\\0', '\\0']), ('\\u{2c2b}', ['\\u{2c5b}', '\\0',\n        '\\0']), ('\\u{2c2c}', ['\\u{2c5c}', '\\0', '\\0']), ('\\u{2c2d}', ['\\u{2c5d}', '\\0', '\\0']),\n        ('\\u{2c2e}', ['\\u{2c5e}', '\\0', '\\0']), ('\\u{2c60}', ['\\u{2c61}', '\\0', '\\0']), ('\\u{2c62}',\n        ['\\u{26b}', '\\0', '\\0']), ('\\u{2c63}', ['\\u{1d7d}', '\\0', '\\0']), ('\\u{2c64}', ['\\u{27d}',\n        '\\0', '\\0']), ('\\u{2c67}', ['\\u{2c68}', '\\0', '\\0']), ('\\u{2c69}', ['\\u{2c6a}', '\\0',\n        '\\0']), ('\\u{2c6b}', ['\\u{2c6c}', '\\0', '\\0']), ('\\u{2c6d}', ['\\u{251}', '\\0', '\\0']),\n        ('\\u{2c6e}', ['\\u{271}', '\\0', '\\0']), ('\\u{2c6f}', ['\\u{250}', '\\0', '\\0']), ('\\u{2c70}',\n        ['\\u{252}', '\\0', '\\0']), ('\\u{2c72}', ['\\u{2c73}', '\\0', '\\0']), ('\\u{2c75}', ['\\u{2c76}',\n        '\\0', '\\0']), ('\\u{2c7e}', ['\\u{23f}', '\\0', '\\0']), ('\\u{2c7f}', ['\\u{240}', '\\0', '\\0']),\n        ('\\u{2c80}', ['\\u{2c81}', '\\0', '\\0']), ('\\u{2c82}', ['\\u{2c83}', '\\0', '\\0']), ('\\u{2c84}',\n        ['\\u{2c85}', '\\0', '\\0']), ('\\u{2c86}', ['\\u{2c87}', '\\0', '\\0']), ('\\u{2c88}', ['\\u{2c89}',\n        '\\0', '\\0']), ('\\u{2c8a}', ['\\u{2c8b}', '\\0', '\\0']), ('\\u{2c8c}', ['\\u{2c8d}', '\\0',\n        '\\0']), ('\\u{2c8e}', ['\\u{2c8f}', '\\0', '\\0']), ('\\u{2c90}', ['\\u{2c91}', '\\0', '\\0']),\n        ('\\u{2c92}', ['\\u{2c93}', '\\0', '\\0']), ('\\u{2c94}', ['\\u{2c95}', '\\0', '\\0']), ('\\u{2c96}',\n        ['\\u{2c97}', '\\0', '\\0']), ('\\u{2c98}', ['\\u{2c99}', '\\0', '\\0']), ('\\u{2c9a}', ['\\u{2c9b}',\n        '\\0', '\\0']), ('\\u{2c9c}', ['\\u{2c9d}', '\\0', '\\0']), ('\\u{2c9e}', ['\\u{2c9f}', '\\0',\n        '\\0']), ('\\u{2ca0}', ['\\u{2ca1}', '\\0', '\\0']), ('\\u{2ca2}', ['\\u{2ca3}', '\\0', '\\0']),\n        ('\\u{2ca4}', ['\\u{2ca5}', '\\0', '\\0']), ('\\u{2ca6}', ['\\u{2ca7}', '\\0', '\\0']), ('\\u{2ca8}',\n        ['\\u{2ca9}', '\\0', '\\0']), ('\\u{2caa}', ['\\u{2cab}', '\\0', '\\0']), ('\\u{2cac}', ['\\u{2cad}',\n        '\\0', '\\0']), ('\\u{2cae}', ['\\u{2caf}', '\\0', '\\0']), ('\\u{2cb0}', ['\\u{2cb1}', '\\0',\n        '\\0']), ('\\u{2cb2}', ['\\u{2cb3}', '\\0', '\\0']), ('\\u{2cb4}', ['\\u{2cb5}', '\\0', '\\0']),\n        ('\\u{2cb6}', ['\\u{2cb7}', '\\0', '\\0']), ('\\u{2cb8}', ['\\u{2cb9}', '\\0', '\\0']), ('\\u{2cba}',\n        ['\\u{2cbb}', '\\0', '\\0']), ('\\u{2cbc}', ['\\u{2cbd}', '\\0', '\\0']), ('\\u{2cbe}', ['\\u{2cbf}',\n        '\\0', '\\0']), ('\\u{2cc0}', ['\\u{2cc1}', '\\0', '\\0']), ('\\u{2cc2}', ['\\u{2cc3}', '\\0',\n        '\\0']), ('\\u{2cc4}', ['\\u{2cc5}', '\\0', '\\0']), ('\\u{2cc6}', ['\\u{2cc7}', '\\0', '\\0']),\n        ('\\u{2cc8}', ['\\u{2cc9}', '\\0', '\\0']), ('\\u{2cca}', ['\\u{2ccb}', '\\0', '\\0']), ('\\u{2ccc}',\n        ['\\u{2ccd}', '\\0', '\\0']), ('\\u{2cce}', ['\\u{2ccf}', '\\0', '\\0']), ('\\u{2cd0}', ['\\u{2cd1}',\n        '\\0', '\\0']), ('\\u{2cd2}', ['\\u{2cd3}', '\\0', '\\0']), ('\\u{2cd4}', ['\\u{2cd5}', '\\0',\n        '\\0']), ('\\u{2cd6}', ['\\u{2cd7}', '\\0', '\\0']), ('\\u{2cd8}', ['\\u{2cd9}', '\\0', '\\0']),\n        ('\\u{2cda}', ['\\u{2cdb}', '\\0', '\\0']), ('\\u{2cdc}', ['\\u{2cdd}', '\\0', '\\0']), ('\\u{2cde}',\n        ['\\u{2cdf}', '\\0', '\\0']), ('\\u{2ce0}', ['\\u{2ce1}', '\\0', '\\0']), ('\\u{2ce2}', ['\\u{2ce3}',\n        '\\0', '\\0']), ('\\u{2ceb}', ['\\u{2cec}', '\\0', '\\0']), ('\\u{2ced}', ['\\u{2cee}', '\\0',\n        '\\0']), ('\\u{2cf2}', ['\\u{2cf3}', '\\0', '\\0']), ('\\u{a640}', ['\\u{a641}', '\\0', '\\0']),\n        ('\\u{a642}', ['\\u{a643}', '\\0', '\\0']), ('\\u{a644}', ['\\u{a645}', '\\0', '\\0']), ('\\u{a646}',\n        ['\\u{a647}', '\\0', '\\0']), ('\\u{a648}', ['\\u{a649}', '\\0', '\\0']), ('\\u{a64a}', ['\\u{a64b}',\n        '\\0', '\\0']), ('\\u{a64c}', ['\\u{a64d}', '\\0', '\\0']), ('\\u{a64e}', ['\\u{a64f}', '\\0',\n        '\\0']), ('\\u{a650}', ['\\u{a651}', '\\0', '\\0']), ('\\u{a652}', ['\\u{a653}', '\\0', '\\0']),\n        ('\\u{a654}', ['\\u{a655}', '\\0', '\\0']), ('\\u{a656}', ['\\u{a657}', '\\0', '\\0']), ('\\u{a658}',\n        ['\\u{a659}', '\\0', '\\0']), ('\\u{a65a}', ['\\u{a65b}', '\\0', '\\0']), ('\\u{a65c}', ['\\u{a65d}',\n        '\\0', '\\0']), ('\\u{a65e}', ['\\u{a65f}', '\\0', '\\0']), ('\\u{a660}', ['\\u{a661}', '\\0',\n        '\\0']), ('\\u{a662}', ['\\u{a663}', '\\0', '\\0']), ('\\u{a664}', ['\\u{a665}', '\\0', '\\0']),\n        ('\\u{a666}', ['\\u{a667}', '\\0', '\\0']), ('\\u{a668}', ['\\u{a669}', '\\0', '\\0']), ('\\u{a66a}',\n        ['\\u{a66b}', '\\0', '\\0']), ('\\u{a66c}', ['\\u{a66d}', '\\0', '\\0']), ('\\u{a680}', ['\\u{a681}',\n        '\\0', '\\0']), ('\\u{a682}', ['\\u{a683}', '\\0', '\\0']), ('\\u{a684}', ['\\u{a685}', '\\0',\n        '\\0']), ('\\u{a686}', ['\\u{a687}', '\\0', '\\0']), ('\\u{a688}', ['\\u{a689}', '\\0', '\\0']),\n        ('\\u{a68a}', ['\\u{a68b}', '\\0', '\\0']), ('\\u{a68c}', ['\\u{a68d}', '\\0', '\\0']), ('\\u{a68e}',\n        ['\\u{a68f}', '\\0', '\\0']), ('\\u{a690}', ['\\u{a691}', '\\0', '\\0']), ('\\u{a692}', ['\\u{a693}',\n        '\\0', '\\0']), ('\\u{a694}', ['\\u{a695}', '\\0', '\\0']), ('\\u{a696}', ['\\u{a697}', '\\0',\n        '\\0']), ('\\u{a698}', ['\\u{a699}', '\\0', '\\0']), ('\\u{a69a}', ['\\u{a69b}', '\\0', '\\0']),\n        ('\\u{a722}', ['\\u{a723}', '\\0', '\\0']), ('\\u{a724}', ['\\u{a725}', '\\0', '\\0']), ('\\u{a726}',\n        ['\\u{a727}', '\\0', '\\0']), ('\\u{a728}', ['\\u{a729}', '\\0', '\\0']), ('\\u{a72a}', ['\\u{a72b}',\n        '\\0', '\\0']), ('\\u{a72c}', ['\\u{a72d}', '\\0', '\\0']), ('\\u{a72e}', ['\\u{a72f}', '\\0',\n        '\\0']), ('\\u{a732}', ['\\u{a733}', '\\0', '\\0']), ('\\u{a734}', ['\\u{a735}', '\\0', '\\0']),\n        ('\\u{a736}', ['\\u{a737}', '\\0', '\\0']), ('\\u{a738}', ['\\u{a739}', '\\0', '\\0']), ('\\u{a73a}',\n        ['\\u{a73b}', '\\0', '\\0']), ('\\u{a73c}', ['\\u{a73d}', '\\0', '\\0']), ('\\u{a73e}', ['\\u{a73f}',\n        '\\0', '\\0']), ('\\u{a740}', ['\\u{a741}', '\\0', '\\0']), ('\\u{a742}', ['\\u{a743}', '\\0',\n        '\\0']), ('\\u{a744}', ['\\u{a745}', '\\0', '\\0']), ('\\u{a746}', ['\\u{a747}', '\\0', '\\0']),\n        ('\\u{a748}', ['\\u{a749}', '\\0', '\\0']), ('\\u{a74a}', ['\\u{a74b}', '\\0', '\\0']), ('\\u{a74c}',\n        ['\\u{a74d}', '\\0', '\\0']), ('\\u{a74e}', ['\\u{a74f}', '\\0', '\\0']), ('\\u{a750}', ['\\u{a751}',\n        '\\0', '\\0']), ('\\u{a752}', ['\\u{a753}', '\\0', '\\0']), ('\\u{a754}', ['\\u{a755}', '\\0',\n        '\\0']), ('\\u{a756}', ['\\u{a757}', '\\0', '\\0']), ('\\u{a758}', ['\\u{a759}', '\\0', '\\0']),\n        ('\\u{a75a}', ['\\u{a75b}', '\\0', '\\0']), ('\\u{a75c}', ['\\u{a75d}', '\\0', '\\0']), ('\\u{a75e}',\n        ['\\u{a75f}', '\\0', '\\0']), ('\\u{a760}', ['\\u{a761}', '\\0', '\\0']), ('\\u{a762}', ['\\u{a763}',\n        '\\0', '\\0']), ('\\u{a764}', ['\\u{a765}', '\\0', '\\0']), ('\\u{a766}', ['\\u{a767}', '\\0',\n        '\\0']), ('\\u{a768}', ['\\u{a769}', '\\0', '\\0']), ('\\u{a76a}', ['\\u{a76b}', '\\0', '\\0']),\n        ('\\u{a76c}', ['\\u{a76d}', '\\0', '\\0']), ('\\u{a76e}', ['\\u{a76f}', '\\0', '\\0']), ('\\u{a779}',\n        ['\\u{a77a}', '\\0', '\\0']), ('\\u{a77b}', ['\\u{a77c}', '\\0', '\\0']), ('\\u{a77d}', ['\\u{1d79}',\n        '\\0', '\\0']), ('\\u{a77e}', ['\\u{a77f}', '\\0', '\\0']), ('\\u{a780}', ['\\u{a781}', '\\0',\n        '\\0']), ('\\u{a782}', ['\\u{a783}', '\\0', '\\0']), ('\\u{a784}', ['\\u{a785}', '\\0', '\\0']),\n        ('\\u{a786}', ['\\u{a787}', '\\0', '\\0']), ('\\u{a78b}', ['\\u{a78c}', '\\0', '\\0']), ('\\u{a78d}',\n        ['\\u{265}', '\\0', '\\0']), ('\\u{a790}', ['\\u{a791}', '\\0', '\\0']), ('\\u{a792}', ['\\u{a793}',\n        '\\0', '\\0']), ('\\u{a796}', ['\\u{a797}', '\\0', '\\0']), ('\\u{a798}', ['\\u{a799}', '\\0',\n        '\\0']), ('\\u{a79a}', ['\\u{a79b}', '\\0', '\\0']), ('\\u{a79c}', ['\\u{a79d}', '\\0', '\\0']),\n        ('\\u{a79e}', ['\\u{a79f}', '\\0', '\\0']), ('\\u{a7a0}', ['\\u{a7a1}', '\\0', '\\0']), ('\\u{a7a2}',\n        ['\\u{a7a3}', '\\0', '\\0']), ('\\u{a7a4}', ['\\u{a7a5}', '\\0', '\\0']), ('\\u{a7a6}', ['\\u{a7a7}',\n        '\\0', '\\0']), ('\\u{a7a8}', ['\\u{a7a9}', '\\0', '\\0']), ('\\u{a7aa}', ['\\u{266}', '\\0', '\\0']),\n        ('\\u{a7ab}', ['\\u{25c}', '\\0', '\\0']), ('\\u{a7ac}', ['\\u{261}', '\\0', '\\0']), ('\\u{a7ad}',\n        ['\\u{26c}', '\\0', '\\0']), ('\\u{a7ae}', ['\\u{26a}', '\\0', '\\0']), ('\\u{a7b0}', ['\\u{29e}',\n        '\\0', '\\0']), ('\\u{a7b1}', ['\\u{287}', '\\0', '\\0']), ('\\u{a7b2}', ['\\u{29d}', '\\0', '\\0']),\n        ('\\u{a7b3}', ['\\u{ab53}', '\\0', '\\0']), ('\\u{a7b4}', ['\\u{a7b5}', '\\0', '\\0']), ('\\u{a7b6}',\n        ['\\u{a7b7}', '\\0', '\\0']), ('\\u{a7b8}', ['\\u{a7b9}', '\\0', '\\0']), ('\\u{ff21}', ['\\u{ff41}',\n        '\\0', '\\0']), ('\\u{ff22}', ['\\u{ff42}', '\\0', '\\0']), ('\\u{ff23}', ['\\u{ff43}', '\\0',\n        '\\0']), ('\\u{ff24}', ['\\u{ff44}', '\\0', '\\0']), ('\\u{ff25}', ['\\u{ff45}', '\\0', '\\0']),\n        ('\\u{ff26}', ['\\u{ff46}', '\\0', '\\0']), ('\\u{ff27}', ['\\u{ff47}', '\\0', '\\0']), ('\\u{ff28}',\n        ['\\u{ff48}', '\\0', '\\0']), ('\\u{ff29}', ['\\u{ff49}', '\\0', '\\0']), ('\\u{ff2a}', ['\\u{ff4a}',\n        '\\0', '\\0']), ('\\u{ff2b}', ['\\u{ff4b}', '\\0', '\\0']), ('\\u{ff2c}', ['\\u{ff4c}', '\\0',\n        '\\0']), ('\\u{ff2d}', ['\\u{ff4d}', '\\0', '\\0']), ('\\u{ff2e}', ['\\u{ff4e}', '\\0', '\\0']),\n        ('\\u{ff2f}', ['\\u{ff4f}', '\\0', '\\0']), ('\\u{ff30}', ['\\u{ff50}', '\\0', '\\0']), ('\\u{ff31}',\n        ['\\u{ff51}', '\\0', '\\0']), ('\\u{ff32}', ['\\u{ff52}', '\\0', '\\0']), ('\\u{ff33}', ['\\u{ff53}',\n        '\\0', '\\0']), ('\\u{ff34}', ['\\u{ff54}', '\\0', '\\0']), ('\\u{ff35}', ['\\u{ff55}', '\\0',\n        '\\0']), ('\\u{ff36}', ['\\u{ff56}', '\\0', '\\0']), ('\\u{ff37}', ['\\u{ff57}', '\\0', '\\0']),\n        ('\\u{ff38}', ['\\u{ff58}', '\\0', '\\0']), ('\\u{ff39}', ['\\u{ff59}', '\\0', '\\0']), ('\\u{ff3a}',\n        ['\\u{ff5a}', '\\0', '\\0']), ('\\u{10400}', ['\\u{10428}', '\\0', '\\0']), ('\\u{10401}',\n        ['\\u{10429}', '\\0', '\\0']), ('\\u{10402}', ['\\u{1042a}', '\\0', '\\0']), ('\\u{10403}',\n        ['\\u{1042b}', '\\0', '\\0']), ('\\u{10404}', ['\\u{1042c}', '\\0', '\\0']), ('\\u{10405}',\n        ['\\u{1042d}', '\\0', '\\0']), ('\\u{10406}', ['\\u{1042e}', '\\0', '\\0']), ('\\u{10407}',\n        ['\\u{1042f}', '\\0', '\\0']), ('\\u{10408}', ['\\u{10430}', '\\0', '\\0']), ('\\u{10409}',\n        ['\\u{10431}', '\\0', '\\0']), ('\\u{1040a}', ['\\u{10432}', '\\0', '\\0']), ('\\u{1040b}',\n        ['\\u{10433}', '\\0', '\\0']), ('\\u{1040c}', ['\\u{10434}', '\\0', '\\0']), ('\\u{1040d}',\n        ['\\u{10435}', '\\0', '\\0']), ('\\u{1040e}', ['\\u{10436}', '\\0', '\\0']), ('\\u{1040f}',\n        ['\\u{10437}', '\\0', '\\0']), ('\\u{10410}', ['\\u{10438}', '\\0', '\\0']), ('\\u{10411}',\n        ['\\u{10439}', '\\0', '\\0']), ('\\u{10412}', ['\\u{1043a}', '\\0', '\\0']), ('\\u{10413}',\n        ['\\u{1043b}', '\\0', '\\0']), ('\\u{10414}', ['\\u{1043c}', '\\0', '\\0']), ('\\u{10415}',\n        ['\\u{1043d}', '\\0', '\\0']), ('\\u{10416}', ['\\u{1043e}', '\\0', '\\0']), ('\\u{10417}',\n        ['\\u{1043f}', '\\0', '\\0']), ('\\u{10418}', ['\\u{10440}', '\\0', '\\0']), ('\\u{10419}',\n        ['\\u{10441}', '\\0', '\\0']), ('\\u{1041a}', ['\\u{10442}', '\\0', '\\0']), ('\\u{1041b}',\n        ['\\u{10443}', '\\0', '\\0']), ('\\u{1041c}', ['\\u{10444}', '\\0', '\\0']), ('\\u{1041d}',\n        ['\\u{10445}', '\\0', '\\0']), ('\\u{1041e}', ['\\u{10446}', '\\0', '\\0']), ('\\u{1041f}',\n        ['\\u{10447}', '\\0', '\\0']), ('\\u{10420}', ['\\u{10448}', '\\0', '\\0']), ('\\u{10421}',\n        ['\\u{10449}', '\\0', '\\0']), ('\\u{10422}', ['\\u{1044a}', '\\0', '\\0']), ('\\u{10423}',\n        ['\\u{1044b}', '\\0', '\\0']), ('\\u{10424}', ['\\u{1044c}', '\\0', '\\0']), ('\\u{10425}',\n        ['\\u{1044d}', '\\0', '\\0']), ('\\u{10426}', ['\\u{1044e}', '\\0', '\\0']), ('\\u{10427}',\n        ['\\u{1044f}', '\\0', '\\0']), ('\\u{104b0}', ['\\u{104d8}', '\\0', '\\0']), ('\\u{104b1}',\n        ['\\u{104d9}', '\\0', '\\0']), ('\\u{104b2}', ['\\u{104da}', '\\0', '\\0']), ('\\u{104b3}',\n        ['\\u{104db}', '\\0', '\\0']), ('\\u{104b4}', ['\\u{104dc}', '\\0', '\\0']), ('\\u{104b5}',\n        ['\\u{104dd}', '\\0', '\\0']), ('\\u{104b6}', ['\\u{104de}', '\\0', '\\0']), ('\\u{104b7}',\n        ['\\u{104df}', '\\0', '\\0']), ('\\u{104b8}', ['\\u{104e0}', '\\0', '\\0']), ('\\u{104b9}',\n        ['\\u{104e1}', '\\0', '\\0']), ('\\u{104ba}', ['\\u{104e2}', '\\0', '\\0']), ('\\u{104bb}',\n        ['\\u{104e3}', '\\0', '\\0']), ('\\u{104bc}', ['\\u{104e4}', '\\0', '\\0']), ('\\u{104bd}',\n        ['\\u{104e5}', '\\0', '\\0']), ('\\u{104be}', ['\\u{104e6}', '\\0', '\\0']), ('\\u{104bf}',\n        ['\\u{104e7}', '\\0', '\\0']), ('\\u{104c0}', ['\\u{104e8}', '\\0', '\\0']), ('\\u{104c1}',\n        ['\\u{104e9}', '\\0', '\\0']), ('\\u{104c2}', ['\\u{104ea}', '\\0', '\\0']), ('\\u{104c3}',\n        ['\\u{104eb}', '\\0', '\\0']), ('\\u{104c4}', ['\\u{104ec}', '\\0', '\\0']), ('\\u{104c5}',\n        ['\\u{104ed}', '\\0', '\\0']), ('\\u{104c6}', ['\\u{104ee}', '\\0', '\\0']), ('\\u{104c7}',\n        ['\\u{104ef}', '\\0', '\\0']), ('\\u{104c8}', ['\\u{104f0}', '\\0', '\\0']), ('\\u{104c9}',\n        ['\\u{104f1}', '\\0', '\\0']), ('\\u{104ca}', ['\\u{104f2}', '\\0', '\\0']), ('\\u{104cb}',\n        ['\\u{104f3}', '\\0', '\\0']), ('\\u{104cc}', ['\\u{104f4}', '\\0', '\\0']), ('\\u{104cd}',\n        ['\\u{104f5}', '\\0', '\\0']), ('\\u{104ce}', ['\\u{104f6}', '\\0', '\\0']), ('\\u{104cf}',\n        ['\\u{104f7}', '\\0', '\\0']), ('\\u{104d0}', ['\\u{104f8}', '\\0', '\\0']), ('\\u{104d1}',\n        ['\\u{104f9}', '\\0', '\\0']), ('\\u{104d2}', ['\\u{104fa}', '\\0', '\\0']), ('\\u{104d3}',\n        ['\\u{104fb}', '\\0', '\\0']), ('\\u{10c80}', ['\\u{10cc0}', '\\0', '\\0']), ('\\u{10c81}',\n        ['\\u{10cc1}', '\\0', '\\0']), ('\\u{10c82}', ['\\u{10cc2}', '\\0', '\\0']), ('\\u{10c83}',\n        ['\\u{10cc3}', '\\0', '\\0']), ('\\u{10c84}', ['\\u{10cc4}', '\\0', '\\0']), ('\\u{10c85}',\n        ['\\u{10cc5}', '\\0', '\\0']), ('\\u{10c86}', ['\\u{10cc6}', '\\0', '\\0']), ('\\u{10c87}',\n        ['\\u{10cc7}', '\\0', '\\0']), ('\\u{10c88}', ['\\u{10cc8}', '\\0', '\\0']), ('\\u{10c89}',\n        ['\\u{10cc9}', '\\0', '\\0']), ('\\u{10c8a}', ['\\u{10cca}', '\\0', '\\0']), ('\\u{10c8b}',\n        ['\\u{10ccb}', '\\0', '\\0']), ('\\u{10c8c}', ['\\u{10ccc}', '\\0', '\\0']), ('\\u{10c8d}',\n        ['\\u{10ccd}', '\\0', '\\0']), ('\\u{10c8e}', ['\\u{10cce}', '\\0', '\\0']), ('\\u{10c8f}',\n        ['\\u{10ccf}', '\\0', '\\0']), ('\\u{10c90}', ['\\u{10cd0}', '\\0', '\\0']), ('\\u{10c91}',\n        ['\\u{10cd1}', '\\0', '\\0']), ('\\u{10c92}', ['\\u{10cd2}', '\\0', '\\0']), ('\\u{10c93}',\n        ['\\u{10cd3}', '\\0', '\\0']), ('\\u{10c94}', ['\\u{10cd4}', '\\0', '\\0']), ('\\u{10c95}',\n        ['\\u{10cd5}', '\\0', '\\0']), ('\\u{10c96}', ['\\u{10cd6}', '\\0', '\\0']), ('\\u{10c97}',\n        ['\\u{10cd7}', '\\0', '\\0']), ('\\u{10c98}', ['\\u{10cd8}', '\\0', '\\0']), ('\\u{10c99}',\n        ['\\u{10cd9}', '\\0', '\\0']), ('\\u{10c9a}', ['\\u{10cda}', '\\0', '\\0']), ('\\u{10c9b}',\n        ['\\u{10cdb}', '\\0', '\\0']), ('\\u{10c9c}', ['\\u{10cdc}', '\\0', '\\0']), ('\\u{10c9d}',\n        ['\\u{10cdd}', '\\0', '\\0']), ('\\u{10c9e}', ['\\u{10cde}', '\\0', '\\0']), ('\\u{10c9f}',\n        ['\\u{10cdf}', '\\0', '\\0']), ('\\u{10ca0}', ['\\u{10ce0}', '\\0', '\\0']), ('\\u{10ca1}',\n        ['\\u{10ce1}', '\\0', '\\0']), ('\\u{10ca2}', ['\\u{10ce2}', '\\0', '\\0']), ('\\u{10ca3}',\n        ['\\u{10ce3}', '\\0', '\\0']), ('\\u{10ca4}', ['\\u{10ce4}', '\\0', '\\0']), ('\\u{10ca5}',\n        ['\\u{10ce5}', '\\0', '\\0']), ('\\u{10ca6}', ['\\u{10ce6}', '\\0', '\\0']), ('\\u{10ca7}',\n        ['\\u{10ce7}', '\\0', '\\0']), ('\\u{10ca8}', ['\\u{10ce8}', '\\0', '\\0']), ('\\u{10ca9}',\n        ['\\u{10ce9}', '\\0', '\\0']), ('\\u{10caa}', ['\\u{10cea}', '\\0', '\\0']), ('\\u{10cab}',\n        ['\\u{10ceb}', '\\0', '\\0']), ('\\u{10cac}', ['\\u{10cec}', '\\0', '\\0']), ('\\u{10cad}',\n        ['\\u{10ced}', '\\0', '\\0']), ('\\u{10cae}', ['\\u{10cee}', '\\0', '\\0']), ('\\u{10caf}',\n        ['\\u{10cef}', '\\0', '\\0']), ('\\u{10cb0}', ['\\u{10cf0}', '\\0', '\\0']), ('\\u{10cb1}',\n        ['\\u{10cf1}', '\\0', '\\0']), ('\\u{10cb2}', ['\\u{10cf2}', '\\0', '\\0']), ('\\u{118a0}',\n        ['\\u{118c0}', '\\0', '\\0']), ('\\u{118a1}', ['\\u{118c1}', '\\0', '\\0']), ('\\u{118a2}',\n        ['\\u{118c2}', '\\0', '\\0']), ('\\u{118a3}', ['\\u{118c3}', '\\0', '\\0']), ('\\u{118a4}',\n        ['\\u{118c4}', '\\0', '\\0']), ('\\u{118a5}', ['\\u{118c5}', '\\0', '\\0']), ('\\u{118a6}',\n        ['\\u{118c6}', '\\0', '\\0']), ('\\u{118a7}', ['\\u{118c7}', '\\0', '\\0']), ('\\u{118a8}',\n        ['\\u{118c8}', '\\0', '\\0']), ('\\u{118a9}', ['\\u{118c9}', '\\0', '\\0']), ('\\u{118aa}',\n        ['\\u{118ca}', '\\0', '\\0']), ('\\u{118ab}', ['\\u{118cb}', '\\0', '\\0']), ('\\u{118ac}',\n        ['\\u{118cc}', '\\0', '\\0']), ('\\u{118ad}', ['\\u{118cd}', '\\0', '\\0']), ('\\u{118ae}',\n        ['\\u{118ce}', '\\0', '\\0']), ('\\u{118af}', ['\\u{118cf}', '\\0', '\\0']), ('\\u{118b0}',\n        ['\\u{118d0}', '\\0', '\\0']), ('\\u{118b1}', ['\\u{118d1}', '\\0', '\\0']), ('\\u{118b2}',\n        ['\\u{118d2}', '\\0', '\\0']), ('\\u{118b3}', ['\\u{118d3}', '\\0', '\\0']), ('\\u{118b4}',\n        ['\\u{118d4}', '\\0', '\\0']), ('\\u{118b5}', ['\\u{118d5}', '\\0', '\\0']), ('\\u{118b6}',\n        ['\\u{118d6}', '\\0', '\\0']), ('\\u{118b7}', ['\\u{118d7}', '\\0', '\\0']), ('\\u{118b8}',\n        ['\\u{118d8}', '\\0', '\\0']), ('\\u{118b9}', ['\\u{118d9}', '\\0', '\\0']), ('\\u{118ba}',\n        ['\\u{118da}', '\\0', '\\0']), ('\\u{118bb}', ['\\u{118db}', '\\0', '\\0']), ('\\u{118bc}',\n        ['\\u{118dc}', '\\0', '\\0']), ('\\u{118bd}', ['\\u{118dd}', '\\0', '\\0']), ('\\u{118be}',\n        ['\\u{118de}', '\\0', '\\0']), ('\\u{118bf}', ['\\u{118df}', '\\0', '\\0']), ('\\u{16e40}',\n        ['\\u{16e60}', '\\0', '\\0']), ('\\u{16e41}', ['\\u{16e61}', '\\0', '\\0']), ('\\u{16e42}',\n        ['\\u{16e62}', '\\0', '\\0']), ('\\u{16e43}', ['\\u{16e63}', '\\0', '\\0']), ('\\u{16e44}',\n        ['\\u{16e64}', '\\0', '\\0']), ('\\u{16e45}', ['\\u{16e65}', '\\0', '\\0']), ('\\u{16e46}',\n        ['\\u{16e66}', '\\0', '\\0']), ('\\u{16e47}', ['\\u{16e67}', '\\0', '\\0']), ('\\u{16e48}',\n        ['\\u{16e68}', '\\0', '\\0']), ('\\u{16e49}', ['\\u{16e69}', '\\0', '\\0']), ('\\u{16e4a}',\n        ['\\u{16e6a}', '\\0', '\\0']), ('\\u{16e4b}', ['\\u{16e6b}', '\\0', '\\0']), ('\\u{16e4c}',\n        ['\\u{16e6c}', '\\0', '\\0']), ('\\u{16e4d}', ['\\u{16e6d}', '\\0', '\\0']), ('\\u{16e4e}',\n        ['\\u{16e6e}', '\\0', '\\0']), ('\\u{16e4f}', ['\\u{16e6f}', '\\0', '\\0']), ('\\u{16e50}',\n        ['\\u{16e70}', '\\0', '\\0']), ('\\u{16e51}', ['\\u{16e71}', '\\0', '\\0']), ('\\u{16e52}',\n        ['\\u{16e72}', '\\0', '\\0']), ('\\u{16e53}', ['\\u{16e73}', '\\0', '\\0']), ('\\u{16e54}',\n        ['\\u{16e74}', '\\0', '\\0']), ('\\u{16e55}', ['\\u{16e75}', '\\0', '\\0']), ('\\u{16e56}',\n        ['\\u{16e76}', '\\0', '\\0']), ('\\u{16e57}', ['\\u{16e77}', '\\0', '\\0']), ('\\u{16e58}',\n        ['\\u{16e78}', '\\0', '\\0']), ('\\u{16e59}', ['\\u{16e79}', '\\0', '\\0']), ('\\u{16e5a}',\n        ['\\u{16e7a}', '\\0', '\\0']), ('\\u{16e5b}', ['\\u{16e7b}', '\\0', '\\0']), ('\\u{16e5c}',\n        ['\\u{16e7c}', '\\0', '\\0']), ('\\u{16e5d}', ['\\u{16e7d}', '\\0', '\\0']), ('\\u{16e5e}',\n        ['\\u{16e7e}', '\\0', '\\0']), ('\\u{16e5f}', ['\\u{16e7f}', '\\0', '\\0']), ('\\u{1e900}',\n        ['\\u{1e922}', '\\0', '\\0']), ('\\u{1e901}', ['\\u{1e923}', '\\0', '\\0']), ('\\u{1e902}',\n        ['\\u{1e924}', '\\0', '\\0']), ('\\u{1e903}', ['\\u{1e925}', '\\0', '\\0']), ('\\u{1e904}',\n        ['\\u{1e926}', '\\0', '\\0']), ('\\u{1e905}', ['\\u{1e927}', '\\0', '\\0']), ('\\u{1e906}',\n        ['\\u{1e928}', '\\0', '\\0']), ('\\u{1e907}', ['\\u{1e929}', '\\0', '\\0']), ('\\u{1e908}',\n        ['\\u{1e92a}', '\\0', '\\0']), ('\\u{1e909}', ['\\u{1e92b}', '\\0', '\\0']), ('\\u{1e90a}',\n        ['\\u{1e92c}', '\\0', '\\0']), ('\\u{1e90b}', ['\\u{1e92d}', '\\0', '\\0']), ('\\u{1e90c}',\n        ['\\u{1e92e}', '\\0', '\\0']), ('\\u{1e90d}', ['\\u{1e92f}', '\\0', '\\0']), ('\\u{1e90e}',\n        ['\\u{1e930}', '\\0', '\\0']), ('\\u{1e90f}', ['\\u{1e931}', '\\0', '\\0']), ('\\u{1e910}',\n        ['\\u{1e932}', '\\0', '\\0']), ('\\u{1e911}', ['\\u{1e933}', '\\0', '\\0']), ('\\u{1e912}',\n        ['\\u{1e934}', '\\0', '\\0']), ('\\u{1e913}', ['\\u{1e935}', '\\0', '\\0']), ('\\u{1e914}',\n        ['\\u{1e936}', '\\0', '\\0']), ('\\u{1e915}', ['\\u{1e937}', '\\0', '\\0']), ('\\u{1e916}',\n        ['\\u{1e938}', '\\0', '\\0']), ('\\u{1e917}', ['\\u{1e939}', '\\0', '\\0']), ('\\u{1e918}',\n        ['\\u{1e93a}', '\\0', '\\0']), ('\\u{1e919}', ['\\u{1e93b}', '\\0', '\\0']), ('\\u{1e91a}',\n        ['\\u{1e93c}', '\\0', '\\0']), ('\\u{1e91b}', ['\\u{1e93d}', '\\0', '\\0']), ('\\u{1e91c}',\n        ['\\u{1e93e}', '\\0', '\\0']), ('\\u{1e91d}', ['\\u{1e93f}', '\\0', '\\0']), ('\\u{1e91e}',\n        ['\\u{1e940}', '\\0', '\\0']), ('\\u{1e91f}', ['\\u{1e941}', '\\0', '\\0']), ('\\u{1e920}',\n        ['\\u{1e942}', '\\0', '\\0']), ('\\u{1e921}', ['\\u{1e943}', '\\0', '\\0'])\n    ];\n\n    const to_uppercase_table: &[(char, [char; 3])] = &[\n        ('\\u{61}', ['\\u{41}', '\\0', '\\0']), ('\\u{62}', ['\\u{42}', '\\0', '\\0']), ('\\u{63}',\n        ['\\u{43}', '\\0', '\\0']), ('\\u{64}', ['\\u{44}', '\\0', '\\0']), ('\\u{65}', ['\\u{45}', '\\0',\n        '\\0']), ('\\u{66}', ['\\u{46}', '\\0', '\\0']), ('\\u{67}', ['\\u{47}', '\\0', '\\0']), ('\\u{68}',\n        ['\\u{48}', '\\0', '\\0']), ('\\u{69}', ['\\u{49}', '\\0', '\\0']), ('\\u{6a}', ['\\u{4a}', '\\0',\n        '\\0']), ('\\u{6b}', ['\\u{4b}', '\\0', '\\0']), ('\\u{6c}', ['\\u{4c}', '\\0', '\\0']), ('\\u{6d}',\n        ['\\u{4d}', '\\0', '\\0']), ('\\u{6e}', ['\\u{4e}', '\\0', '\\0']), ('\\u{6f}', ['\\u{4f}', '\\0',\n        '\\0']), ('\\u{70}', ['\\u{50}', '\\0', '\\0']), ('\\u{71}', ['\\u{51}', '\\0', '\\0']), ('\\u{72}',\n        ['\\u{52}', '\\0', '\\0']), ('\\u{73}', ['\\u{53}', '\\0', '\\0']), ('\\u{74}', ['\\u{54}', '\\0',\n        '\\0']), ('\\u{75}', ['\\u{55}', '\\0', '\\0']), ('\\u{76}', ['\\u{56}', '\\0', '\\0']), ('\\u{77}',\n        ['\\u{57}', '\\0', '\\0']), ('\\u{78}', ['\\u{58}', '\\0', '\\0']), ('\\u{79}', ['\\u{59}', '\\0',\n        '\\0']), ('\\u{7a}', ['\\u{5a}', '\\0', '\\0']), ('\\u{b5}', ['\\u{39c}', '\\0', '\\0']), ('\\u{df}',\n        ['\\u{53}', '\\u{53}', '\\0']), ('\\u{e0}', ['\\u{c0}', '\\0', '\\0']), ('\\u{e1}', ['\\u{c1}', '\\0',\n        '\\0']), ('\\u{e2}', ['\\u{c2}', '\\0', '\\0']), ('\\u{e3}', ['\\u{c3}', '\\0', '\\0']), ('\\u{e4}',\n        ['\\u{c4}', '\\0', '\\0']), ('\\u{e5}', ['\\u{c5}', '\\0', '\\0']), ('\\u{e6}', ['\\u{c6}', '\\0',\n        '\\0']), ('\\u{e7}', ['\\u{c7}', '\\0', '\\0']), ('\\u{e8}', ['\\u{c8}', '\\0', '\\0']), ('\\u{e9}',\n        ['\\u{c9}', '\\0', '\\0']), ('\\u{ea}', ['\\u{ca}', '\\0', '\\0']), ('\\u{eb}', ['\\u{cb}', '\\0',\n        '\\0']), ('\\u{ec}', ['\\u{cc}', '\\0', '\\0']), ('\\u{ed}', ['\\u{cd}', '\\0', '\\0']), ('\\u{ee}',\n        ['\\u{ce}', '\\0', '\\0']), ('\\u{ef}', ['\\u{cf}', '\\0', '\\0']), ('\\u{f0}', ['\\u{d0}', '\\0',\n        '\\0']), ('\\u{f1}', ['\\u{d1}', '\\0', '\\0']), ('\\u{f2}', ['\\u{d2}', '\\0', '\\0']), ('\\u{f3}',\n        ['\\u{d3}', '\\0', '\\0']), ('\\u{f4}', ['\\u{d4}', '\\0', '\\0']), ('\\u{f5}', ['\\u{d5}', '\\0',\n        '\\0']), ('\\u{f6}', ['\\u{d6}', '\\0', '\\0']), ('\\u{f8}', ['\\u{d8}', '\\0', '\\0']), ('\\u{f9}',\n        ['\\u{d9}', '\\0', '\\0']), ('\\u{fa}', ['\\u{da}', '\\0', '\\0']), ('\\u{fb}', ['\\u{db}', '\\0',\n        '\\0']), ('\\u{fc}', ['\\u{dc}', '\\0', '\\0']), ('\\u{fd}', ['\\u{dd}', '\\0', '\\0']), ('\\u{fe}',\n        ['\\u{de}', '\\0', '\\0']), ('\\u{ff}', ['\\u{178}', '\\0', '\\0']), ('\\u{101}', ['\\u{100}', '\\0',\n        '\\0']), ('\\u{103}', ['\\u{102}', '\\0', '\\0']), ('\\u{105}', ['\\u{104}', '\\0', '\\0']),\n        ('\\u{107}', ['\\u{106}', '\\0', '\\0']), ('\\u{109}', ['\\u{108}', '\\0', '\\0']), ('\\u{10b}',\n        ['\\u{10a}', '\\0', '\\0']), ('\\u{10d}', ['\\u{10c}', '\\0', '\\0']), ('\\u{10f}', ['\\u{10e}',\n        '\\0', '\\0']), ('\\u{111}', ['\\u{110}', '\\0', '\\0']), ('\\u{113}', ['\\u{112}', '\\0', '\\0']),\n        ('\\u{115}', ['\\u{114}', '\\0', '\\0']), ('\\u{117}', ['\\u{116}', '\\0', '\\0']), ('\\u{119}',\n        ['\\u{118}', '\\0', '\\0']), ('\\u{11b}', ['\\u{11a}', '\\0', '\\0']), ('\\u{11d}', ['\\u{11c}',\n        '\\0', '\\0']), ('\\u{11f}', ['\\u{11e}', '\\0', '\\0']), ('\\u{121}', ['\\u{120}', '\\0', '\\0']),\n        ('\\u{123}', ['\\u{122}', '\\0', '\\0']), ('\\u{125}', ['\\u{124}', '\\0', '\\0']), ('\\u{127}',\n        ['\\u{126}', '\\0', '\\0']), ('\\u{129}', ['\\u{128}', '\\0', '\\0']), ('\\u{12b}', ['\\u{12a}',\n        '\\0', '\\0']), ('\\u{12d}', ['\\u{12c}', '\\0', '\\0']), ('\\u{12f}', ['\\u{12e}', '\\0', '\\0']),\n        ('\\u{131}', ['\\u{49}', '\\0', '\\0']), ('\\u{133}', ['\\u{132}', '\\0', '\\0']), ('\\u{135}',\n        ['\\u{134}', '\\0', '\\0']), ('\\u{137}', ['\\u{136}', '\\0', '\\0']), ('\\u{13a}', ['\\u{139}',\n        '\\0', '\\0']), ('\\u{13c}', ['\\u{13b}', '\\0', '\\0']), ('\\u{13e}', ['\\u{13d}', '\\0', '\\0']),\n        ('\\u{140}', ['\\u{13f}', '\\0', '\\0']), ('\\u{142}', ['\\u{141}', '\\0', '\\0']), ('\\u{144}',\n        ['\\u{143}', '\\0', '\\0']), ('\\u{146}', ['\\u{145}', '\\0', '\\0']), ('\\u{148}', ['\\u{147}',\n        '\\0', '\\0']), ('\\u{149}', ['\\u{2bc}', '\\u{4e}', '\\0']), ('\\u{14b}', ['\\u{14a}', '\\0',\n        '\\0']), ('\\u{14d}', ['\\u{14c}', '\\0', '\\0']), ('\\u{14f}', ['\\u{14e}', '\\0', '\\0']),\n        ('\\u{151}', ['\\u{150}', '\\0', '\\0']), ('\\u{153}', ['\\u{152}', '\\0', '\\0']), ('\\u{155}',\n        ['\\u{154}', '\\0', '\\0']), ('\\u{157}', ['\\u{156}', '\\0', '\\0']), ('\\u{159}', ['\\u{158}',\n        '\\0', '\\0']), ('\\u{15b}', ['\\u{15a}', '\\0', '\\0']), ('\\u{15d}', ['\\u{15c}', '\\0', '\\0']),\n        ('\\u{15f}', ['\\u{15e}', '\\0', '\\0']), ('\\u{161}', ['\\u{160}', '\\0', '\\0']), ('\\u{163}',\n        ['\\u{162}', '\\0', '\\0']), ('\\u{165}', ['\\u{164}', '\\0', '\\0']), ('\\u{167}', ['\\u{166}',\n        '\\0', '\\0']), ('\\u{169}', ['\\u{168}', '\\0', '\\0']), ('\\u{16b}', ['\\u{16a}', '\\0', '\\0']),\n        ('\\u{16d}', ['\\u{16c}', '\\0', '\\0']), ('\\u{16f}', ['\\u{16e}', '\\0', '\\0']), ('\\u{171}',\n        ['\\u{170}', '\\0', '\\0']), ('\\u{173}', ['\\u{172}', '\\0', '\\0']), ('\\u{175}', ['\\u{174}',\n        '\\0', '\\0']), ('\\u{177}', ['\\u{176}', '\\0', '\\0']), ('\\u{17a}', ['\\u{179}', '\\0', '\\0']),\n        ('\\u{17c}', ['\\u{17b}', '\\0', '\\0']), ('\\u{17e}', ['\\u{17d}', '\\0', '\\0']), ('\\u{17f}',\n        ['\\u{53}', '\\0', '\\0']), ('\\u{180}', ['\\u{243}', '\\0', '\\0']), ('\\u{183}', ['\\u{182}', '\\0',\n        '\\0']), ('\\u{185}', ['\\u{184}', '\\0', '\\0']), ('\\u{188}', ['\\u{187}', '\\0', '\\0']),\n        ('\\u{18c}', ['\\u{18b}', '\\0', '\\0']), ('\\u{192}', ['\\u{191}', '\\0', '\\0']), ('\\u{195}',\n        ['\\u{1f6}', '\\0', '\\0']), ('\\u{199}', ['\\u{198}', '\\0', '\\0']), ('\\u{19a}', ['\\u{23d}',\n        '\\0', '\\0']), ('\\u{19e}', ['\\u{220}', '\\0', '\\0']), ('\\u{1a1}', ['\\u{1a0}', '\\0', '\\0']),\n        ('\\u{1a3}', ['\\u{1a2}', '\\0', '\\0']), ('\\u{1a5}', ['\\u{1a4}', '\\0', '\\0']), ('\\u{1a8}',\n        ['\\u{1a7}', '\\0', '\\0']), ('\\u{1ad}', ['\\u{1ac}', '\\0', '\\0']), ('\\u{1b0}', ['\\u{1af}',\n        '\\0', '\\0']), ('\\u{1b4}', ['\\u{1b3}', '\\0', '\\0']), ('\\u{1b6}', ['\\u{1b5}', '\\0', '\\0']),\n        ('\\u{1b9}', ['\\u{1b8}', '\\0', '\\0']), ('\\u{1bd}', ['\\u{1bc}', '\\0', '\\0']), ('\\u{1bf}',\n        ['\\u{1f7}', '\\0', '\\0']), ('\\u{1c5}', ['\\u{1c4}', '\\0', '\\0']), ('\\u{1c6}', ['\\u{1c4}',\n        '\\0', '\\0']), ('\\u{1c8}', ['\\u{1c7}', '\\0', '\\0']), ('\\u{1c9}', ['\\u{1c7}', '\\0', '\\0']),\n        ('\\u{1cb}', ['\\u{1ca}', '\\0', '\\0']), ('\\u{1cc}', ['\\u{1ca}', '\\0', '\\0']), ('\\u{1ce}',\n        ['\\u{1cd}', '\\0', '\\0']), ('\\u{1d0}', ['\\u{1cf}', '\\0', '\\0']), ('\\u{1d2}', ['\\u{1d1}',\n        '\\0', '\\0']), ('\\u{1d4}', ['\\u{1d3}', '\\0', '\\0']), ('\\u{1d6}', ['\\u{1d5}', '\\0', '\\0']),\n        ('\\u{1d8}', ['\\u{1d7}', '\\0', '\\0']), ('\\u{1da}', ['\\u{1d9}', '\\0', '\\0']), ('\\u{1dc}',\n        ['\\u{1db}', '\\0', '\\0']), ('\\u{1dd}', ['\\u{18e}', '\\0', '\\0']), ('\\u{1df}', ['\\u{1de}',\n        '\\0', '\\0']), ('\\u{1e1}', ['\\u{1e0}', '\\0', '\\0']), ('\\u{1e3}', ['\\u{1e2}', '\\0', '\\0']),\n        ('\\u{1e5}', ['\\u{1e4}', '\\0', '\\0']), ('\\u{1e7}', ['\\u{1e6}', '\\0', '\\0']), ('\\u{1e9}',\n        ['\\u{1e8}', '\\0', '\\0']), ('\\u{1eb}', ['\\u{1ea}', '\\0', '\\0']), ('\\u{1ed}', ['\\u{1ec}',\n        '\\0', '\\0']), ('\\u{1ef}', ['\\u{1ee}', '\\0', '\\0']), ('\\u{1f0}', ['\\u{4a}', '\\u{30c}',\n        '\\0']), ('\\u{1f2}', ['\\u{1f1}', '\\0', '\\0']), ('\\u{1f3}', ['\\u{1f1}', '\\0', '\\0']),\n        ('\\u{1f5}', ['\\u{1f4}', '\\0', '\\0']), ('\\u{1f9}', ['\\u{1f8}', '\\0', '\\0']), ('\\u{1fb}',\n        ['\\u{1fa}', '\\0', '\\0']), ('\\u{1fd}', ['\\u{1fc}', '\\0', '\\0']), ('\\u{1ff}', ['\\u{1fe}',\n        '\\0', '\\0']), ('\\u{201}', ['\\u{200}', '\\0', '\\0']), ('\\u{203}', ['\\u{202}', '\\0', '\\0']),\n        ('\\u{205}', ['\\u{204}', '\\0', '\\0']), ('\\u{207}', ['\\u{206}', '\\0', '\\0']), ('\\u{209}',\n        ['\\u{208}', '\\0', '\\0']), ('\\u{20b}', ['\\u{20a}', '\\0', '\\0']), ('\\u{20d}', ['\\u{20c}',\n        '\\0', '\\0']), ('\\u{20f}', ['\\u{20e}', '\\0', '\\0']), ('\\u{211}', ['\\u{210}', '\\0', '\\0']),\n        ('\\u{213}', ['\\u{212}', '\\0', '\\0']), ('\\u{215}', ['\\u{214}', '\\0', '\\0']), ('\\u{217}',\n        ['\\u{216}', '\\0', '\\0']), ('\\u{219}', ['\\u{218}', '\\0', '\\0']), ('\\u{21b}', ['\\u{21a}',\n        '\\0', '\\0']), ('\\u{21d}', ['\\u{21c}', '\\0', '\\0']), ('\\u{21f}', ['\\u{21e}', '\\0', '\\0']),\n        ('\\u{223}', ['\\u{222}', '\\0', '\\0']), ('\\u{225}', ['\\u{224}', '\\0', '\\0']), ('\\u{227}',\n        ['\\u{226}', '\\0', '\\0']), ('\\u{229}', ['\\u{228}', '\\0', '\\0']), ('\\u{22b}', ['\\u{22a}',\n        '\\0', '\\0']), ('\\u{22d}', ['\\u{22c}', '\\0', '\\0']), ('\\u{22f}', ['\\u{22e}', '\\0', '\\0']),\n        ('\\u{231}', ['\\u{230}', '\\0', '\\0']), ('\\u{233}', ['\\u{232}', '\\0', '\\0']), ('\\u{23c}',\n        ['\\u{23b}', '\\0', '\\0']), ('\\u{23f}', ['\\u{2c7e}', '\\0', '\\0']), ('\\u{240}', ['\\u{2c7f}',\n        '\\0', '\\0']), ('\\u{242}', ['\\u{241}', '\\0', '\\0']), ('\\u{247}', ['\\u{246}', '\\0', '\\0']),\n        ('\\u{249}', ['\\u{248}', '\\0', '\\0']), ('\\u{24b}', ['\\u{24a}', '\\0', '\\0']), ('\\u{24d}',\n        ['\\u{24c}', '\\0', '\\0']), ('\\u{24f}', ['\\u{24e}', '\\0', '\\0']), ('\\u{250}', ['\\u{2c6f}',\n        '\\0', '\\0']), ('\\u{251}', ['\\u{2c6d}', '\\0', '\\0']), ('\\u{252}', ['\\u{2c70}', '\\0', '\\0']),\n        ('\\u{253}', ['\\u{181}', '\\0', '\\0']), ('\\u{254}', ['\\u{186}', '\\0', '\\0']), ('\\u{256}',\n        ['\\u{189}', '\\0', '\\0']), ('\\u{257}', ['\\u{18a}', '\\0', '\\0']), ('\\u{259}', ['\\u{18f}',\n        '\\0', '\\0']), ('\\u{25b}', ['\\u{190}', '\\0', '\\0']), ('\\u{25c}', ['\\u{a7ab}', '\\0', '\\0']),\n        ('\\u{260}', ['\\u{193}', '\\0', '\\0']), ('\\u{261}', ['\\u{a7ac}', '\\0', '\\0']), ('\\u{263}',\n        ['\\u{194}', '\\0', '\\0']), ('\\u{265}', ['\\u{a78d}', '\\0', '\\0']), ('\\u{266}', ['\\u{a7aa}',\n        '\\0', '\\0']), ('\\u{268}', ['\\u{197}', '\\0', '\\0']), ('\\u{269}', ['\\u{196}', '\\0', '\\0']),\n        ('\\u{26a}', ['\\u{a7ae}', '\\0', '\\0']), ('\\u{26b}', ['\\u{2c62}', '\\0', '\\0']), ('\\u{26c}',\n        ['\\u{a7ad}', '\\0', '\\0']), ('\\u{26f}', ['\\u{19c}', '\\0', '\\0']), ('\\u{271}', ['\\u{2c6e}',\n        '\\0', '\\0']), ('\\u{272}', ['\\u{19d}', '\\0', '\\0']), ('\\u{275}', ['\\u{19f}', '\\0', '\\0']),\n        ('\\u{27d}', ['\\u{2c64}', '\\0', '\\0']), ('\\u{280}', ['\\u{1a6}', '\\0', '\\0']), ('\\u{283}',\n        ['\\u{1a9}', '\\0', '\\0']), ('\\u{287}', ['\\u{a7b1}', '\\0', '\\0']), ('\\u{288}', ['\\u{1ae}',\n        '\\0', '\\0']), ('\\u{289}', ['\\u{244}', '\\0', '\\0']), ('\\u{28a}', ['\\u{1b1}', '\\0', '\\0']),\n        ('\\u{28b}', ['\\u{1b2}', '\\0', '\\0']), ('\\u{28c}', ['\\u{245}', '\\0', '\\0']), ('\\u{292}',\n        ['\\u{1b7}', '\\0', '\\0']), ('\\u{29d}', ['\\u{a7b2}', '\\0', '\\0']), ('\\u{29e}', ['\\u{a7b0}',\n        '\\0', '\\0']), ('\\u{345}', ['\\u{399}', '\\0', '\\0']), ('\\u{371}', ['\\u{370}', '\\0', '\\0']),\n        ('\\u{373}', ['\\u{372}', '\\0', '\\0']), ('\\u{377}', ['\\u{376}', '\\0', '\\0']), ('\\u{37b}',\n        ['\\u{3fd}', '\\0', '\\0']), ('\\u{37c}', ['\\u{3fe}', '\\0', '\\0']), ('\\u{37d}', ['\\u{3ff}',\n        '\\0', '\\0']), ('\\u{390}', ['\\u{399}', '\\u{308}', '\\u{301}']), ('\\u{3ac}', ['\\u{386}', '\\0',\n        '\\0']), ('\\u{3ad}', ['\\u{388}', '\\0', '\\0']), ('\\u{3ae}', ['\\u{389}', '\\0', '\\0']),\n        ('\\u{3af}', ['\\u{38a}', '\\0', '\\0']), ('\\u{3b0}', ['\\u{3a5}', '\\u{308}', '\\u{301}']),\n        ('\\u{3b1}', ['\\u{391}', '\\0', '\\0']), ('\\u{3b2}', ['\\u{392}', '\\0', '\\0']), ('\\u{3b3}',\n        ['\\u{393}', '\\0', '\\0']), ('\\u{3b4}', ['\\u{394}', '\\0', '\\0']), ('\\u{3b5}', ['\\u{395}',\n        '\\0', '\\0']), ('\\u{3b6}', ['\\u{396}', '\\0', '\\0']), ('\\u{3b7}', ['\\u{397}', '\\0', '\\0']),\n        ('\\u{3b8}', ['\\u{398}', '\\0', '\\0']), ('\\u{3b9}', ['\\u{399}', '\\0', '\\0']), ('\\u{3ba}',\n        ['\\u{39a}', '\\0', '\\0']), ('\\u{3bb}', ['\\u{39b}', '\\0', '\\0']), ('\\u{3bc}', ['\\u{39c}',\n        '\\0', '\\0']), ('\\u{3bd}', ['\\u{39d}', '\\0', '\\0']), ('\\u{3be}', ['\\u{39e}', '\\0', '\\0']),\n        ('\\u{3bf}', ['\\u{39f}', '\\0', '\\0']), ('\\u{3c0}', ['\\u{3a0}', '\\0', '\\0']), ('\\u{3c1}',\n        ['\\u{3a1}', '\\0', '\\0']), ('\\u{3c2}', ['\\u{3a3}', '\\0', '\\0']), ('\\u{3c3}', ['\\u{3a3}',\n        '\\0', '\\0']), ('\\u{3c4}', ['\\u{3a4}', '\\0', '\\0']), ('\\u{3c5}', ['\\u{3a5}', '\\0', '\\0']),\n        ('\\u{3c6}', ['\\u{3a6}', '\\0', '\\0']), ('\\u{3c7}', ['\\u{3a7}', '\\0', '\\0']), ('\\u{3c8}',\n        ['\\u{3a8}', '\\0', '\\0']), ('\\u{3c9}', ['\\u{3a9}', '\\0', '\\0']), ('\\u{3ca}', ['\\u{3aa}',\n        '\\0', '\\0']), ('\\u{3cb}', ['\\u{3ab}', '\\0', '\\0']), ('\\u{3cc}', ['\\u{38c}', '\\0', '\\0']),\n        ('\\u{3cd}', ['\\u{38e}', '\\0', '\\0']), ('\\u{3ce}', ['\\u{38f}', '\\0', '\\0']), ('\\u{3d0}',\n        ['\\u{392}', '\\0', '\\0']), ('\\u{3d1}', ['\\u{398}', '\\0', '\\0']), ('\\u{3d5}', ['\\u{3a6}',\n        '\\0', '\\0']), ('\\u{3d6}', ['\\u{3a0}', '\\0', '\\0']), ('\\u{3d7}', ['\\u{3cf}', '\\0', '\\0']),\n        ('\\u{3d9}', ['\\u{3d8}', '\\0', '\\0']), ('\\u{3db}', ['\\u{3da}', '\\0', '\\0']), ('\\u{3dd}',\n        ['\\u{3dc}', '\\0', '\\0']), ('\\u{3df}', ['\\u{3de}', '\\0', '\\0']), ('\\u{3e1}', ['\\u{3e0}',\n        '\\0', '\\0']), ('\\u{3e3}', ['\\u{3e2}', '\\0', '\\0']), ('\\u{3e5}', ['\\u{3e4}', '\\0', '\\0']),\n        ('\\u{3e7}', ['\\u{3e6}', '\\0', '\\0']), ('\\u{3e9}', ['\\u{3e8}', '\\0', '\\0']), ('\\u{3eb}',\n        ['\\u{3ea}', '\\0', '\\0']), ('\\u{3ed}', ['\\u{3ec}', '\\0', '\\0']), ('\\u{3ef}', ['\\u{3ee}',\n        '\\0', '\\0']), ('\\u{3f0}', ['\\u{39a}', '\\0', '\\0']), ('\\u{3f1}', ['\\u{3a1}', '\\0', '\\0']),\n        ('\\u{3f2}', ['\\u{3f9}', '\\0', '\\0']), ('\\u{3f3}', ['\\u{37f}', '\\0', '\\0']), ('\\u{3f5}',\n        ['\\u{395}', '\\0', '\\0']), ('\\u{3f8}', ['\\u{3f7}', '\\0', '\\0']), ('\\u{3fb}', ['\\u{3fa}',\n        '\\0', '\\0']), ('\\u{430}', ['\\u{410}', '\\0', '\\0']), ('\\u{431}', ['\\u{411}', '\\0', '\\0']),\n        ('\\u{432}', ['\\u{412}', '\\0', '\\0']), ('\\u{433}', ['\\u{413}', '\\0', '\\0']), ('\\u{434}',\n        ['\\u{414}', '\\0', '\\0']), ('\\u{435}', ['\\u{415}', '\\0', '\\0']), ('\\u{436}', ['\\u{416}',\n        '\\0', '\\0']), ('\\u{437}', ['\\u{417}', '\\0', '\\0']), ('\\u{438}', ['\\u{418}', '\\0', '\\0']),\n        ('\\u{439}', ['\\u{419}', '\\0', '\\0']), ('\\u{43a}', ['\\u{41a}', '\\0', '\\0']), ('\\u{43b}',\n        ['\\u{41b}', '\\0', '\\0']), ('\\u{43c}', ['\\u{41c}', '\\0', '\\0']), ('\\u{43d}', ['\\u{41d}',\n        '\\0', '\\0']), ('\\u{43e}', ['\\u{41e}', '\\0', '\\0']), ('\\u{43f}', ['\\u{41f}', '\\0', '\\0']),\n        ('\\u{440}', ['\\u{420}', '\\0', '\\0']), ('\\u{441}', ['\\u{421}', '\\0', '\\0']), ('\\u{442}',\n        ['\\u{422}', '\\0', '\\0']), ('\\u{443}', ['\\u{423}', '\\0', '\\0']), ('\\u{444}', ['\\u{424}',\n        '\\0', '\\0']), ('\\u{445}', ['\\u{425}', '\\0', '\\0']), ('\\u{446}', ['\\u{426}', '\\0', '\\0']),\n        ('\\u{447}', ['\\u{427}', '\\0', '\\0']), ('\\u{448}', ['\\u{428}', '\\0', '\\0']), ('\\u{449}',\n        ['\\u{429}', '\\0', '\\0']), ('\\u{44a}', ['\\u{42a}', '\\0', '\\0']), ('\\u{44b}', ['\\u{42b}',\n        '\\0', '\\0']), ('\\u{44c}', ['\\u{42c}', '\\0', '\\0']), ('\\u{44d}', ['\\u{42d}', '\\0', '\\0']),\n        ('\\u{44e}', ['\\u{42e}', '\\0', '\\0']), ('\\u{44f}', ['\\u{42f}', '\\0', '\\0']), ('\\u{450}',\n        ['\\u{400}', '\\0', '\\0']), ('\\u{451}', ['\\u{401}', '\\0', '\\0']), ('\\u{452}', ['\\u{402}',\n        '\\0', '\\0']), ('\\u{453}', ['\\u{403}', '\\0', '\\0']), ('\\u{454}', ['\\u{404}', '\\0', '\\0']),\n        ('\\u{455}', ['\\u{405}', '\\0', '\\0']), ('\\u{456}', ['\\u{406}', '\\0', '\\0']), ('\\u{457}',\n        ['\\u{407}', '\\0', '\\0']), ('\\u{458}', ['\\u{408}', '\\0', '\\0']), ('\\u{459}', ['\\u{409}',\n        '\\0', '\\0']), ('\\u{45a}', ['\\u{40a}', '\\0', '\\0']), ('\\u{45b}', ['\\u{40b}', '\\0', '\\0']),\n        ('\\u{45c}', ['\\u{40c}', '\\0', '\\0']), ('\\u{45d}', ['\\u{40d}', '\\0', '\\0']), ('\\u{45e}',\n        ['\\u{40e}', '\\0', '\\0']), ('\\u{45f}', ['\\u{40f}', '\\0', '\\0']), ('\\u{461}', ['\\u{460}',\n        '\\0', '\\0']), ('\\u{463}', ['\\u{462}', '\\0', '\\0']), ('\\u{465}', ['\\u{464}', '\\0', '\\0']),\n        ('\\u{467}', ['\\u{466}', '\\0', '\\0']), ('\\u{469}', ['\\u{468}', '\\0', '\\0']), ('\\u{46b}',\n        ['\\u{46a}', '\\0', '\\0']), ('\\u{46d}', ['\\u{46c}', '\\0', '\\0']), ('\\u{46f}', ['\\u{46e}',\n        '\\0', '\\0']), ('\\u{471}', ['\\u{470}', '\\0', '\\0']), ('\\u{473}', ['\\u{472}', '\\0', '\\0']),\n        ('\\u{475}', ['\\u{474}', '\\0', '\\0']), ('\\u{477}', ['\\u{476}', '\\0', '\\0']), ('\\u{479}',\n        ['\\u{478}', '\\0', '\\0']), ('\\u{47b}', ['\\u{47a}', '\\0', '\\0']), ('\\u{47d}', ['\\u{47c}',\n        '\\0', '\\0']), ('\\u{47f}', ['\\u{47e}', '\\0', '\\0']), ('\\u{481}', ['\\u{480}', '\\0', '\\0']),\n        ('\\u{48b}', ['\\u{48a}', '\\0', '\\0']), ('\\u{48d}', ['\\u{48c}', '\\0', '\\0']), ('\\u{48f}',\n        ['\\u{48e}', '\\0', '\\0']), ('\\u{491}', ['\\u{490}', '\\0', '\\0']), ('\\u{493}', ['\\u{492}',\n        '\\0', '\\0']), ('\\u{495}', ['\\u{494}', '\\0', '\\0']), ('\\u{497}', ['\\u{496}', '\\0', '\\0']),\n        ('\\u{499}', ['\\u{498}', '\\0', '\\0']), ('\\u{49b}', ['\\u{49a}', '\\0', '\\0']), ('\\u{49d}',\n        ['\\u{49c}', '\\0', '\\0']), ('\\u{49f}', ['\\u{49e}', '\\0', '\\0']), ('\\u{4a1}', ['\\u{4a0}',\n        '\\0', '\\0']), ('\\u{4a3}', ['\\u{4a2}', '\\0', '\\0']), ('\\u{4a5}', ['\\u{4a4}', '\\0', '\\0']),\n        ('\\u{4a7}', ['\\u{4a6}', '\\0', '\\0']), ('\\u{4a9}', ['\\u{4a8}', '\\0', '\\0']), ('\\u{4ab}',\n        ['\\u{4aa}', '\\0', '\\0']), ('\\u{4ad}', ['\\u{4ac}', '\\0', '\\0']), ('\\u{4af}', ['\\u{4ae}',\n        '\\0', '\\0']), ('\\u{4b1}', ['\\u{4b0}', '\\0', '\\0']), ('\\u{4b3}', ['\\u{4b2}', '\\0', '\\0']),\n        ('\\u{4b5}', ['\\u{4b4}', '\\0', '\\0']), ('\\u{4b7}', ['\\u{4b6}', '\\0', '\\0']), ('\\u{4b9}',\n        ['\\u{4b8}', '\\0', '\\0']), ('\\u{4bb}', ['\\u{4ba}', '\\0', '\\0']), ('\\u{4bd}', ['\\u{4bc}',\n        '\\0', '\\0']), ('\\u{4bf}', ['\\u{4be}', '\\0', '\\0']), ('\\u{4c2}', ['\\u{4c1}', '\\0', '\\0']),\n        ('\\u{4c4}', ['\\u{4c3}', '\\0', '\\0']), ('\\u{4c6}', ['\\u{4c5}', '\\0', '\\0']), ('\\u{4c8}',\n        ['\\u{4c7}', '\\0', '\\0']), ('\\u{4ca}', ['\\u{4c9}', '\\0', '\\0']), ('\\u{4cc}', ['\\u{4cb}',\n        '\\0', '\\0']), ('\\u{4ce}', ['\\u{4cd}', '\\0', '\\0']), ('\\u{4cf}', ['\\u{4c0}', '\\0', '\\0']),\n        ('\\u{4d1}', ['\\u{4d0}', '\\0', '\\0']), ('\\u{4d3}', ['\\u{4d2}', '\\0', '\\0']), ('\\u{4d5}',\n        ['\\u{4d4}', '\\0', '\\0']), ('\\u{4d7}', ['\\u{4d6}', '\\0', '\\0']), ('\\u{4d9}', ['\\u{4d8}',\n        '\\0', '\\0']), ('\\u{4db}', ['\\u{4da}', '\\0', '\\0']), ('\\u{4dd}', ['\\u{4dc}', '\\0', '\\0']),\n        ('\\u{4df}', ['\\u{4de}', '\\0', '\\0']), ('\\u{4e1}', ['\\u{4e0}', '\\0', '\\0']), ('\\u{4e3}',\n        ['\\u{4e2}', '\\0', '\\0']), ('\\u{4e5}', ['\\u{4e4}', '\\0', '\\0']), ('\\u{4e7}', ['\\u{4e6}',\n        '\\0', '\\0']), ('\\u{4e9}', ['\\u{4e8}', '\\0', '\\0']), ('\\u{4eb}', ['\\u{4ea}', '\\0', '\\0']),\n        ('\\u{4ed}', ['\\u{4ec}', '\\0', '\\0']), ('\\u{4ef}', ['\\u{4ee}', '\\0', '\\0']), ('\\u{4f1}',\n        ['\\u{4f0}', '\\0', '\\0']), ('\\u{4f3}', ['\\u{4f2}', '\\0', '\\0']), ('\\u{4f5}', ['\\u{4f4}',\n        '\\0', '\\0']), ('\\u{4f7}', ['\\u{4f6}', '\\0', '\\0']), ('\\u{4f9}', ['\\u{4f8}', '\\0', '\\0']),\n        ('\\u{4fb}', ['\\u{4fa}', '\\0', '\\0']), ('\\u{4fd}', ['\\u{4fc}', '\\0', '\\0']), ('\\u{4ff}',\n        ['\\u{4fe}', '\\0', '\\0']), ('\\u{501}', ['\\u{500}', '\\0', '\\0']), ('\\u{503}', ['\\u{502}',\n        '\\0', '\\0']), ('\\u{505}', ['\\u{504}', '\\0', '\\0']), ('\\u{507}', ['\\u{506}', '\\0', '\\0']),\n        ('\\u{509}', ['\\u{508}', '\\0', '\\0']), ('\\u{50b}', ['\\u{50a}', '\\0', '\\0']), ('\\u{50d}',\n        ['\\u{50c}', '\\0', '\\0']), ('\\u{50f}', ['\\u{50e}', '\\0', '\\0']), ('\\u{511}', ['\\u{510}',\n        '\\0', '\\0']), ('\\u{513}', ['\\u{512}', '\\0', '\\0']), ('\\u{515}', ['\\u{514}', '\\0', '\\0']),\n        ('\\u{517}', ['\\u{516}', '\\0', '\\0']), ('\\u{519}', ['\\u{518}', '\\0', '\\0']), ('\\u{51b}',\n        ['\\u{51a}', '\\0', '\\0']), ('\\u{51d}', ['\\u{51c}', '\\0', '\\0']), ('\\u{51f}', ['\\u{51e}',\n        '\\0', '\\0']), ('\\u{521}', ['\\u{520}', '\\0', '\\0']), ('\\u{523}', ['\\u{522}', '\\0', '\\0']),\n        ('\\u{525}', ['\\u{524}', '\\0', '\\0']), ('\\u{527}', ['\\u{526}', '\\0', '\\0']), ('\\u{529}',\n        ['\\u{528}', '\\0', '\\0']), ('\\u{52b}', ['\\u{52a}', '\\0', '\\0']), ('\\u{52d}', ['\\u{52c}',\n        '\\0', '\\0']), ('\\u{52f}', ['\\u{52e}', '\\0', '\\0']), ('\\u{561}', ['\\u{531}', '\\0', '\\0']),\n        ('\\u{562}', ['\\u{532}', '\\0', '\\0']), ('\\u{563}', ['\\u{533}', '\\0', '\\0']), ('\\u{564}',\n        ['\\u{534}', '\\0', '\\0']), ('\\u{565}', ['\\u{535}', '\\0', '\\0']), ('\\u{566}', ['\\u{536}',\n        '\\0', '\\0']), ('\\u{567}', ['\\u{537}', '\\0', '\\0']), ('\\u{568}', ['\\u{538}', '\\0', '\\0']),\n        ('\\u{569}', ['\\u{539}', '\\0', '\\0']), ('\\u{56a}', ['\\u{53a}', '\\0', '\\0']), ('\\u{56b}',\n        ['\\u{53b}', '\\0', '\\0']), ('\\u{56c}', ['\\u{53c}', '\\0', '\\0']), ('\\u{56d}', ['\\u{53d}',\n        '\\0', '\\0']), ('\\u{56e}', ['\\u{53e}', '\\0', '\\0']), ('\\u{56f}', ['\\u{53f}', '\\0', '\\0']),\n        ('\\u{570}', ['\\u{540}', '\\0', '\\0']), ('\\u{571}', ['\\u{541}', '\\0', '\\0']), ('\\u{572}',\n        ['\\u{542}', '\\0', '\\0']), ('\\u{573}', ['\\u{543}', '\\0', '\\0']), ('\\u{574}', ['\\u{544}',\n        '\\0', '\\0']), ('\\u{575}', ['\\u{545}', '\\0', '\\0']), ('\\u{576}', ['\\u{546}', '\\0', '\\0']),\n        ('\\u{577}', ['\\u{547}', '\\0', '\\0']), ('\\u{578}', ['\\u{548}', '\\0', '\\0']), ('\\u{579}',\n        ['\\u{549}', '\\0', '\\0']), ('\\u{57a}', ['\\u{54a}', '\\0', '\\0']), ('\\u{57b}', ['\\u{54b}',\n        '\\0', '\\0']), ('\\u{57c}', ['\\u{54c}', '\\0', '\\0']), ('\\u{57d}', ['\\u{54d}', '\\0', '\\0']),\n        ('\\u{57e}', ['\\u{54e}', '\\0', '\\0']), ('\\u{57f}', ['\\u{54f}', '\\0', '\\0']), ('\\u{580}',\n        ['\\u{550}', '\\0', '\\0']), ('\\u{581}', ['\\u{551}', '\\0', '\\0']), ('\\u{582}', ['\\u{552}',\n        '\\0', '\\0']), ('\\u{583}', ['\\u{553}', '\\0', '\\0']), ('\\u{584}', ['\\u{554}', '\\0', '\\0']),\n        ('\\u{585}', ['\\u{555}', '\\0', '\\0']), ('\\u{586}', ['\\u{556}', '\\0', '\\0']), ('\\u{587}',\n        ['\\u{535}', '\\u{552}', '\\0']), ('\\u{10d0}', ['\\u{1c90}', '\\0', '\\0']), ('\\u{10d1}',\n        ['\\u{1c91}', '\\0', '\\0']), ('\\u{10d2}', ['\\u{1c92}', '\\0', '\\0']), ('\\u{10d3}', ['\\u{1c93}',\n        '\\0', '\\0']), ('\\u{10d4}', ['\\u{1c94}', '\\0', '\\0']), ('\\u{10d5}', ['\\u{1c95}', '\\0',\n        '\\0']), ('\\u{10d6}', ['\\u{1c96}', '\\0', '\\0']), ('\\u{10d7}', ['\\u{1c97}', '\\0', '\\0']),\n        ('\\u{10d8}', ['\\u{1c98}', '\\0', '\\0']), ('\\u{10d9}', ['\\u{1c99}', '\\0', '\\0']), ('\\u{10da}',\n        ['\\u{1c9a}', '\\0', '\\0']), ('\\u{10db}', ['\\u{1c9b}', '\\0', '\\0']), ('\\u{10dc}', ['\\u{1c9c}',\n        '\\0', '\\0']), ('\\u{10dd}', ['\\u{1c9d}', '\\0', '\\0']), ('\\u{10de}', ['\\u{1c9e}', '\\0',\n        '\\0']), ('\\u{10df}', ['\\u{1c9f}', '\\0', '\\0']), ('\\u{10e0}', ['\\u{1ca0}', '\\0', '\\0']),\n        ('\\u{10e1}', ['\\u{1ca1}', '\\0', '\\0']), ('\\u{10e2}', ['\\u{1ca2}', '\\0', '\\0']), ('\\u{10e3}',\n        ['\\u{1ca3}', '\\0', '\\0']), ('\\u{10e4}', ['\\u{1ca4}', '\\0', '\\0']), ('\\u{10e5}', ['\\u{1ca5}',\n        '\\0', '\\0']), ('\\u{10e6}', ['\\u{1ca6}', '\\0', '\\0']), ('\\u{10e7}', ['\\u{1ca7}', '\\0',\n        '\\0']), ('\\u{10e8}', ['\\u{1ca8}', '\\0', '\\0']), ('\\u{10e9}', ['\\u{1ca9}', '\\0', '\\0']),\n        ('\\u{10ea}', ['\\u{1caa}', '\\0', '\\0']), ('\\u{10eb}', ['\\u{1cab}', '\\0', '\\0']), ('\\u{10ec}',\n        ['\\u{1cac}', '\\0', '\\0']), ('\\u{10ed}', ['\\u{1cad}', '\\0', '\\0']), ('\\u{10ee}', ['\\u{1cae}',\n        '\\0', '\\0']), ('\\u{10ef}', ['\\u{1caf}', '\\0', '\\0']), ('\\u{10f0}', ['\\u{1cb0}', '\\0',\n        '\\0']), ('\\u{10f1}', ['\\u{1cb1}', '\\0', '\\0']), ('\\u{10f2}', ['\\u{1cb2}', '\\0', '\\0']),\n        ('\\u{10f3}', ['\\u{1cb3}', '\\0', '\\0']), ('\\u{10f4}', ['\\u{1cb4}', '\\0', '\\0']), ('\\u{10f5}',\n        ['\\u{1cb5}', '\\0', '\\0']), ('\\u{10f6}', ['\\u{1cb6}', '\\0', '\\0']), ('\\u{10f7}', ['\\u{1cb7}',\n        '\\0', '\\0']), ('\\u{10f8}', ['\\u{1cb8}', '\\0', '\\0']), ('\\u{10f9}', ['\\u{1cb9}', '\\0',\n        '\\0']), ('\\u{10fa}', ['\\u{1cba}', '\\0', '\\0']), ('\\u{10fd}', ['\\u{1cbd}', '\\0', '\\0']),\n        ('\\u{10fe}', ['\\u{1cbe}', '\\0', '\\0']), ('\\u{10ff}', ['\\u{1cbf}', '\\0', '\\0']), ('\\u{13f8}',\n        ['\\u{13f0}', '\\0', '\\0']), ('\\u{13f9}', ['\\u{13f1}', '\\0', '\\0']), ('\\u{13fa}', ['\\u{13f2}',\n        '\\0', '\\0']), ('\\u{13fb}', ['\\u{13f3}', '\\0', '\\0']), ('\\u{13fc}', ['\\u{13f4}', '\\0',\n        '\\0']), ('\\u{13fd}', ['\\u{13f5}', '\\0', '\\0']), ('\\u{1c80}', ['\\u{412}', '\\0', '\\0']),\n        ('\\u{1c81}', ['\\u{414}', '\\0', '\\0']), ('\\u{1c82}', ['\\u{41e}', '\\0', '\\0']), ('\\u{1c83}',\n        ['\\u{421}', '\\0', '\\0']), ('\\u{1c84}', ['\\u{422}', '\\0', '\\0']), ('\\u{1c85}', ['\\u{422}',\n        '\\0', '\\0']), ('\\u{1c86}', ['\\u{42a}', '\\0', '\\0']), ('\\u{1c87}', ['\\u{462}', '\\0', '\\0']),\n        ('\\u{1c88}', ['\\u{a64a}', '\\0', '\\0']), ('\\u{1d79}', ['\\u{a77d}', '\\0', '\\0']), ('\\u{1d7d}',\n        ['\\u{2c63}', '\\0', '\\0']), ('\\u{1e01}', ['\\u{1e00}', '\\0', '\\0']), ('\\u{1e03}', ['\\u{1e02}',\n        '\\0', '\\0']), ('\\u{1e05}', ['\\u{1e04}', '\\0', '\\0']), ('\\u{1e07}', ['\\u{1e06}', '\\0',\n        '\\0']), ('\\u{1e09}', ['\\u{1e08}', '\\0', '\\0']), ('\\u{1e0b}', ['\\u{1e0a}', '\\0', '\\0']),\n        ('\\u{1e0d}', ['\\u{1e0c}', '\\0', '\\0']), ('\\u{1e0f}', ['\\u{1e0e}', '\\0', '\\0']), ('\\u{1e11}',\n        ['\\u{1e10}', '\\0', '\\0']), ('\\u{1e13}', ['\\u{1e12}', '\\0', '\\0']), ('\\u{1e15}', ['\\u{1e14}',\n        '\\0', '\\0']), ('\\u{1e17}', ['\\u{1e16}', '\\0', '\\0']), ('\\u{1e19}', ['\\u{1e18}', '\\0',\n        '\\0']), ('\\u{1e1b}', ['\\u{1e1a}', '\\0', '\\0']), ('\\u{1e1d}', ['\\u{1e1c}', '\\0', '\\0']),\n        ('\\u{1e1f}', ['\\u{1e1e}', '\\0', '\\0']), ('\\u{1e21}', ['\\u{1e20}', '\\0', '\\0']), ('\\u{1e23}',\n        ['\\u{1e22}', '\\0', '\\0']), ('\\u{1e25}', ['\\u{1e24}', '\\0', '\\0']), ('\\u{1e27}', ['\\u{1e26}',\n        '\\0', '\\0']), ('\\u{1e29}', ['\\u{1e28}', '\\0', '\\0']), ('\\u{1e2b}', ['\\u{1e2a}', '\\0',\n        '\\0']), ('\\u{1e2d}', ['\\u{1e2c}', '\\0', '\\0']), ('\\u{1e2f}', ['\\u{1e2e}', '\\0', '\\0']),\n        ('\\u{1e31}', ['\\u{1e30}', '\\0', '\\0']), ('\\u{1e33}', ['\\u{1e32}', '\\0', '\\0']), ('\\u{1e35}',\n        ['\\u{1e34}', '\\0', '\\0']), ('\\u{1e37}', ['\\u{1e36}', '\\0', '\\0']), ('\\u{1e39}', ['\\u{1e38}',\n        '\\0', '\\0']), ('\\u{1e3b}', ['\\u{1e3a}', '\\0', '\\0']), ('\\u{1e3d}', ['\\u{1e3c}', '\\0',\n        '\\0']), ('\\u{1e3f}', ['\\u{1e3e}', '\\0', '\\0']), ('\\u{1e41}', ['\\u{1e40}', '\\0', '\\0']),\n        ('\\u{1e43}', ['\\u{1e42}', '\\0', '\\0']), ('\\u{1e45}', ['\\u{1e44}', '\\0', '\\0']), ('\\u{1e47}',\n        ['\\u{1e46}', '\\0', '\\0']), ('\\u{1e49}', ['\\u{1e48}', '\\0', '\\0']), ('\\u{1e4b}', ['\\u{1e4a}',\n        '\\0', '\\0']), ('\\u{1e4d}', ['\\u{1e4c}', '\\0', '\\0']), ('\\u{1e4f}', ['\\u{1e4e}', '\\0',\n        '\\0']), ('\\u{1e51}', ['\\u{1e50}', '\\0', '\\0']), ('\\u{1e53}', ['\\u{1e52}', '\\0', '\\0']),\n        ('\\u{1e55}', ['\\u{1e54}', '\\0', '\\0']), ('\\u{1e57}', ['\\u{1e56}', '\\0', '\\0']), ('\\u{1e59}',\n        ['\\u{1e58}', '\\0', '\\0']), ('\\u{1e5b}', ['\\u{1e5a}', '\\0', '\\0']), ('\\u{1e5d}', ['\\u{1e5c}',\n        '\\0', '\\0']), ('\\u{1e5f}', ['\\u{1e5e}', '\\0', '\\0']), ('\\u{1e61}', ['\\u{1e60}', '\\0',\n        '\\0']), ('\\u{1e63}', ['\\u{1e62}', '\\0', '\\0']), ('\\u{1e65}', ['\\u{1e64}', '\\0', '\\0']),\n        ('\\u{1e67}', ['\\u{1e66}', '\\0', '\\0']), ('\\u{1e69}', ['\\u{1e68}', '\\0', '\\0']), ('\\u{1e6b}',\n        ['\\u{1e6a}', '\\0', '\\0']), ('\\u{1e6d}', ['\\u{1e6c}', '\\0', '\\0']), ('\\u{1e6f}', ['\\u{1e6e}',\n        '\\0', '\\0']), ('\\u{1e71}', ['\\u{1e70}', '\\0', '\\0']), ('\\u{1e73}', ['\\u{1e72}', '\\0',\n        '\\0']), ('\\u{1e75}', ['\\u{1e74}', '\\0', '\\0']), ('\\u{1e77}', ['\\u{1e76}', '\\0', '\\0']),\n        ('\\u{1e79}', ['\\u{1e78}', '\\0', '\\0']), ('\\u{1e7b}', ['\\u{1e7a}', '\\0', '\\0']), ('\\u{1e7d}',\n        ['\\u{1e7c}', '\\0', '\\0']), ('\\u{1e7f}', ['\\u{1e7e}', '\\0', '\\0']), ('\\u{1e81}', ['\\u{1e80}',\n        '\\0', '\\0']), ('\\u{1e83}', ['\\u{1e82}', '\\0', '\\0']), ('\\u{1e85}', ['\\u{1e84}', '\\0',\n        '\\0']), ('\\u{1e87}', ['\\u{1e86}', '\\0', '\\0']), ('\\u{1e89}', ['\\u{1e88}', '\\0', '\\0']),\n        ('\\u{1e8b}', ['\\u{1e8a}', '\\0', '\\0']), ('\\u{1e8d}', ['\\u{1e8c}', '\\0', '\\0']), ('\\u{1e8f}',\n        ['\\u{1e8e}', '\\0', '\\0']), ('\\u{1e91}', ['\\u{1e90}', '\\0', '\\0']), ('\\u{1e93}', ['\\u{1e92}',\n        '\\0', '\\0']), ('\\u{1e95}', ['\\u{1e94}', '\\0', '\\0']), ('\\u{1e96}', ['\\u{48}', '\\u{331}',\n        '\\0']), ('\\u{1e97}', ['\\u{54}', '\\u{308}', '\\0']), ('\\u{1e98}', ['\\u{57}', '\\u{30a}',\n        '\\0']), ('\\u{1e99}', ['\\u{59}', '\\u{30a}', '\\0']), ('\\u{1e9a}', ['\\u{41}', '\\u{2be}',\n        '\\0']), ('\\u{1e9b}', ['\\u{1e60}', '\\0', '\\0']), ('\\u{1ea1}', ['\\u{1ea0}', '\\0', '\\0']),\n        ('\\u{1ea3}', ['\\u{1ea2}', '\\0', '\\0']), ('\\u{1ea5}', ['\\u{1ea4}', '\\0', '\\0']), ('\\u{1ea7}',\n        ['\\u{1ea6}', '\\0', '\\0']), ('\\u{1ea9}', ['\\u{1ea8}', '\\0', '\\0']), ('\\u{1eab}', ['\\u{1eaa}',\n        '\\0', '\\0']), ('\\u{1ead}', ['\\u{1eac}', '\\0', '\\0']), ('\\u{1eaf}', ['\\u{1eae}', '\\0',\n        '\\0']), ('\\u{1eb1}', ['\\u{1eb0}', '\\0', '\\0']), ('\\u{1eb3}', ['\\u{1eb2}', '\\0', '\\0']),\n        ('\\u{1eb5}', ['\\u{1eb4}', '\\0', '\\0']), ('\\u{1eb7}', ['\\u{1eb6}', '\\0', '\\0']), ('\\u{1eb9}',\n        ['\\u{1eb8}', '\\0', '\\0']), ('\\u{1ebb}', ['\\u{1eba}', '\\0', '\\0']), ('\\u{1ebd}', ['\\u{1ebc}',\n        '\\0', '\\0']), ('\\u{1ebf}', ['\\u{1ebe}', '\\0', '\\0']), ('\\u{1ec1}', ['\\u{1ec0}', '\\0',\n        '\\0']), ('\\u{1ec3}', ['\\u{1ec2}', '\\0', '\\0']), ('\\u{1ec5}', ['\\u{1ec4}', '\\0', '\\0']),\n        ('\\u{1ec7}', ['\\u{1ec6}', '\\0', '\\0']), ('\\u{1ec9}', ['\\u{1ec8}', '\\0', '\\0']), ('\\u{1ecb}',\n        ['\\u{1eca}', '\\0', '\\0']), ('\\u{1ecd}', ['\\u{1ecc}', '\\0', '\\0']), ('\\u{1ecf}', ['\\u{1ece}',\n        '\\0', '\\0']), ('\\u{1ed1}', ['\\u{1ed0}', '\\0', '\\0']), ('\\u{1ed3}', ['\\u{1ed2}', '\\0',\n        '\\0']), ('\\u{1ed5}', ['\\u{1ed4}', '\\0', '\\0']), ('\\u{1ed7}', ['\\u{1ed6}', '\\0', '\\0']),\n        ('\\u{1ed9}', ['\\u{1ed8}', '\\0', '\\0']), ('\\u{1edb}', ['\\u{1eda}', '\\0', '\\0']), ('\\u{1edd}',\n        ['\\u{1edc}', '\\0', '\\0']), ('\\u{1edf}', ['\\u{1ede}', '\\0', '\\0']), ('\\u{1ee1}', ['\\u{1ee0}',\n        '\\0', '\\0']), ('\\u{1ee3}', ['\\u{1ee2}', '\\0', '\\0']), ('\\u{1ee5}', ['\\u{1ee4}', '\\0',\n        '\\0']), ('\\u{1ee7}', ['\\u{1ee6}', '\\0', '\\0']), ('\\u{1ee9}', ['\\u{1ee8}', '\\0', '\\0']),\n        ('\\u{1eeb}', ['\\u{1eea}', '\\0', '\\0']), ('\\u{1eed}', ['\\u{1eec}', '\\0', '\\0']), ('\\u{1eef}',\n        ['\\u{1eee}', '\\0', '\\0']), ('\\u{1ef1}', ['\\u{1ef0}', '\\0', '\\0']), ('\\u{1ef3}', ['\\u{1ef2}',\n        '\\0', '\\0']), ('\\u{1ef5}', ['\\u{1ef4}', '\\0', '\\0']), ('\\u{1ef7}', ['\\u{1ef6}', '\\0',\n        '\\0']), ('\\u{1ef9}', ['\\u{1ef8}', '\\0', '\\0']), ('\\u{1efb}', ['\\u{1efa}', '\\0', '\\0']),\n        ('\\u{1efd}', ['\\u{1efc}', '\\0', '\\0']), ('\\u{1eff}', ['\\u{1efe}', '\\0', '\\0']), ('\\u{1f00}',\n        ['\\u{1f08}', '\\0', '\\0']), ('\\u{1f01}', ['\\u{1f09}', '\\0', '\\0']), ('\\u{1f02}', ['\\u{1f0a}',\n        '\\0', '\\0']), ('\\u{1f03}', ['\\u{1f0b}', '\\0', '\\0']), ('\\u{1f04}', ['\\u{1f0c}', '\\0',\n        '\\0']), ('\\u{1f05}', ['\\u{1f0d}', '\\0', '\\0']), ('\\u{1f06}', ['\\u{1f0e}', '\\0', '\\0']),\n        ('\\u{1f07}', ['\\u{1f0f}', '\\0', '\\0']), ('\\u{1f10}', ['\\u{1f18}', '\\0', '\\0']), ('\\u{1f11}',\n        ['\\u{1f19}', '\\0', '\\0']), ('\\u{1f12}', ['\\u{1f1a}', '\\0', '\\0']), ('\\u{1f13}', ['\\u{1f1b}',\n        '\\0', '\\0']), ('\\u{1f14}', ['\\u{1f1c}', '\\0', '\\0']), ('\\u{1f15}', ['\\u{1f1d}', '\\0',\n        '\\0']), ('\\u{1f20}', ['\\u{1f28}', '\\0', '\\0']), ('\\u{1f21}', ['\\u{1f29}', '\\0', '\\0']),\n        ('\\u{1f22}', ['\\u{1f2a}', '\\0', '\\0']), ('\\u{1f23}', ['\\u{1f2b}', '\\0', '\\0']), ('\\u{1f24}',\n        ['\\u{1f2c}', '\\0', '\\0']), ('\\u{1f25}', ['\\u{1f2d}', '\\0', '\\0']), ('\\u{1f26}', ['\\u{1f2e}',\n        '\\0', '\\0']), ('\\u{1f27}', ['\\u{1f2f}', '\\0', '\\0']), ('\\u{1f30}', ['\\u{1f38}', '\\0',\n        '\\0']), ('\\u{1f31}', ['\\u{1f39}', '\\0', '\\0']), ('\\u{1f32}', ['\\u{1f3a}', '\\0', '\\0']),\n        ('\\u{1f33}', ['\\u{1f3b}', '\\0', '\\0']), ('\\u{1f34}', ['\\u{1f3c}', '\\0', '\\0']), ('\\u{1f35}',\n        ['\\u{1f3d}', '\\0', '\\0']), ('\\u{1f36}', ['\\u{1f3e}', '\\0', '\\0']), ('\\u{1f37}', ['\\u{1f3f}',\n        '\\0', '\\0']), ('\\u{1f40}', ['\\u{1f48}', '\\0', '\\0']), ('\\u{1f41}', ['\\u{1f49}', '\\0',\n        '\\0']), ('\\u{1f42}', ['\\u{1f4a}', '\\0', '\\0']), ('\\u{1f43}', ['\\u{1f4b}', '\\0', '\\0']),\n        ('\\u{1f44}', ['\\u{1f4c}', '\\0', '\\0']), ('\\u{1f45}', ['\\u{1f4d}', '\\0', '\\0']), ('\\u{1f50}',\n        ['\\u{3a5}', '\\u{313}', '\\0']), ('\\u{1f51}', ['\\u{1f59}', '\\0', '\\0']), ('\\u{1f52}',\n        ['\\u{3a5}', '\\u{313}', '\\u{300}']), ('\\u{1f53}', ['\\u{1f5b}', '\\0', '\\0']), ('\\u{1f54}',\n        ['\\u{3a5}', '\\u{313}', '\\u{301}']), ('\\u{1f55}', ['\\u{1f5d}', '\\0', '\\0']), ('\\u{1f56}',\n        ['\\u{3a5}', '\\u{313}', '\\u{342}']), ('\\u{1f57}', ['\\u{1f5f}', '\\0', '\\0']), ('\\u{1f60}',\n        ['\\u{1f68}', '\\0', '\\0']), ('\\u{1f61}', ['\\u{1f69}', '\\0', '\\0']), ('\\u{1f62}', ['\\u{1f6a}',\n        '\\0', '\\0']), ('\\u{1f63}', ['\\u{1f6b}', '\\0', '\\0']), ('\\u{1f64}', ['\\u{1f6c}', '\\0',\n        '\\0']), ('\\u{1f65}', ['\\u{1f6d}', '\\0', '\\0']), ('\\u{1f66}', ['\\u{1f6e}', '\\0', '\\0']),\n        ('\\u{1f67}', ['\\u{1f6f}', '\\0', '\\0']), ('\\u{1f70}', ['\\u{1fba}', '\\0', '\\0']), ('\\u{1f71}',\n        ['\\u{1fbb}', '\\0', '\\0']), ('\\u{1f72}', ['\\u{1fc8}', '\\0', '\\0']), ('\\u{1f73}', ['\\u{1fc9}',\n        '\\0', '\\0']), ('\\u{1f74}', ['\\u{1fca}', '\\0', '\\0']), ('\\u{1f75}', ['\\u{1fcb}', '\\0',\n        '\\0']), ('\\u{1f76}', ['\\u{1fda}', '\\0', '\\0']), ('\\u{1f77}', ['\\u{1fdb}', '\\0', '\\0']),\n        ('\\u{1f78}', ['\\u{1ff8}', '\\0', '\\0']), ('\\u{1f79}', ['\\u{1ff9}', '\\0', '\\0']), ('\\u{1f7a}',\n        ['\\u{1fea}', '\\0', '\\0']), ('\\u{1f7b}', ['\\u{1feb}', '\\0', '\\0']), ('\\u{1f7c}', ['\\u{1ffa}',\n        '\\0', '\\0']), ('\\u{1f7d}', ['\\u{1ffb}', '\\0', '\\0']), ('\\u{1f80}', ['\\u{1f08}', '\\u{399}',\n        '\\0']), ('\\u{1f81}', ['\\u{1f09}', '\\u{399}', '\\0']), ('\\u{1f82}', ['\\u{1f0a}', '\\u{399}',\n        '\\0']), ('\\u{1f83}', ['\\u{1f0b}', '\\u{399}', '\\0']), ('\\u{1f84}', ['\\u{1f0c}', '\\u{399}',\n        '\\0']), ('\\u{1f85}', ['\\u{1f0d}', '\\u{399}', '\\0']), ('\\u{1f86}', ['\\u{1f0e}', '\\u{399}',\n        '\\0']), ('\\u{1f87}', ['\\u{1f0f}', '\\u{399}', '\\0']), ('\\u{1f88}', ['\\u{1f08}', '\\u{399}',\n        '\\0']), ('\\u{1f89}', ['\\u{1f09}', '\\u{399}', '\\0']), ('\\u{1f8a}', ['\\u{1f0a}', '\\u{399}',\n        '\\0']), ('\\u{1f8b}', ['\\u{1f0b}', '\\u{399}', '\\0']), ('\\u{1f8c}', ['\\u{1f0c}', '\\u{399}',\n        '\\0']), ('\\u{1f8d}', ['\\u{1f0d}', '\\u{399}', '\\0']), ('\\u{1f8e}', ['\\u{1f0e}', '\\u{399}',\n        '\\0']), ('\\u{1f8f}', ['\\u{1f0f}', '\\u{399}', '\\0']), ('\\u{1f90}', ['\\u{1f28}', '\\u{399}',\n        '\\0']), ('\\u{1f91}', ['\\u{1f29}', '\\u{399}', '\\0']), ('\\u{1f92}', ['\\u{1f2a}', '\\u{399}',\n        '\\0']), ('\\u{1f93}', ['\\u{1f2b}', '\\u{399}', '\\0']), ('\\u{1f94}', ['\\u{1f2c}', '\\u{399}',\n        '\\0']), ('\\u{1f95}', ['\\u{1f2d}', '\\u{399}', '\\0']), ('\\u{1f96}', ['\\u{1f2e}', '\\u{399}',\n        '\\0']), ('\\u{1f97}', ['\\u{1f2f}', '\\u{399}', '\\0']), ('\\u{1f98}', ['\\u{1f28}', '\\u{399}',\n        '\\0']), ('\\u{1f99}', ['\\u{1f29}', '\\u{399}', '\\0']), ('\\u{1f9a}', ['\\u{1f2a}', '\\u{399}',\n        '\\0']), ('\\u{1f9b}', ['\\u{1f2b}', '\\u{399}', '\\0']), ('\\u{1f9c}', ['\\u{1f2c}', '\\u{399}',\n        '\\0']), ('\\u{1f9d}', ['\\u{1f2d}', '\\u{399}', '\\0']), ('\\u{1f9e}', ['\\u{1f2e}', '\\u{399}',\n        '\\0']), ('\\u{1f9f}', ['\\u{1f2f}', '\\u{399}', '\\0']), ('\\u{1fa0}', ['\\u{1f68}', '\\u{399}',\n        '\\0']), ('\\u{1fa1}', ['\\u{1f69}', '\\u{399}', '\\0']), ('\\u{1fa2}', ['\\u{1f6a}', '\\u{399}',\n        '\\0']), ('\\u{1fa3}', ['\\u{1f6b}', '\\u{399}', '\\0']), ('\\u{1fa4}', ['\\u{1f6c}', '\\u{399}',\n        '\\0']), ('\\u{1fa5}', ['\\u{1f6d}', '\\u{399}', '\\0']), ('\\u{1fa6}', ['\\u{1f6e}', '\\u{399}',\n        '\\0']), ('\\u{1fa7}', ['\\u{1f6f}', '\\u{399}', '\\0']), ('\\u{1fa8}', ['\\u{1f68}', '\\u{399}',\n        '\\0']), ('\\u{1fa9}', ['\\u{1f69}', '\\u{399}', '\\0']), ('\\u{1faa}', ['\\u{1f6a}', '\\u{399}',\n        '\\0']), ('\\u{1fab}', ['\\u{1f6b}', '\\u{399}', '\\0']), ('\\u{1fac}', ['\\u{1f6c}', '\\u{399}',\n        '\\0']), ('\\u{1fad}', ['\\u{1f6d}', '\\u{399}', '\\0']), ('\\u{1fae}', ['\\u{1f6e}', '\\u{399}',\n        '\\0']), ('\\u{1faf}', ['\\u{1f6f}', '\\u{399}', '\\0']), ('\\u{1fb0}', ['\\u{1fb8}', '\\0', '\\0']),\n        ('\\u{1fb1}', ['\\u{1fb9}', '\\0', '\\0']), ('\\u{1fb2}', ['\\u{1fba}', '\\u{399}', '\\0']),\n        ('\\u{1fb3}', ['\\u{391}', '\\u{399}', '\\0']), ('\\u{1fb4}', ['\\u{386}', '\\u{399}', '\\0']),\n        ('\\u{1fb6}', ['\\u{391}', '\\u{342}', '\\0']), ('\\u{1fb7}', ['\\u{391}', '\\u{342}', '\\u{399}']),\n        ('\\u{1fbc}', ['\\u{391}', '\\u{399}', '\\0']), ('\\u{1fbe}', ['\\u{399}', '\\0', '\\0']),\n        ('\\u{1fc2}', ['\\u{1fca}', '\\u{399}', '\\0']), ('\\u{1fc3}', ['\\u{397}', '\\u{399}', '\\0']),\n        ('\\u{1fc4}', ['\\u{389}', '\\u{399}', '\\0']), ('\\u{1fc6}', ['\\u{397}', '\\u{342}', '\\0']),\n        ('\\u{1fc7}', ['\\u{397}', '\\u{342}', '\\u{399}']), ('\\u{1fcc}', ['\\u{397}', '\\u{399}', '\\0']),\n        ('\\u{1fd0}', ['\\u{1fd8}', '\\0', '\\0']), ('\\u{1fd1}', ['\\u{1fd9}', '\\0', '\\0']), ('\\u{1fd2}',\n        ['\\u{399}', '\\u{308}', '\\u{300}']), ('\\u{1fd3}', ['\\u{399}', '\\u{308}', '\\u{301}']),\n        ('\\u{1fd6}', ['\\u{399}', '\\u{342}', '\\0']), ('\\u{1fd7}', ['\\u{399}', '\\u{308}', '\\u{342}']),\n        ('\\u{1fe0}', ['\\u{1fe8}', '\\0', '\\0']), ('\\u{1fe1}', ['\\u{1fe9}', '\\0', '\\0']), ('\\u{1fe2}',\n        ['\\u{3a5}', '\\u{308}', '\\u{300}']), ('\\u{1fe3}', ['\\u{3a5}', '\\u{308}', '\\u{301}']),\n        ('\\u{1fe4}', ['\\u{3a1}', '\\u{313}', '\\0']), ('\\u{1fe5}', ['\\u{1fec}', '\\0', '\\0']),\n        ('\\u{1fe6}', ['\\u{3a5}', '\\u{342}', '\\0']), ('\\u{1fe7}', ['\\u{3a5}', '\\u{308}', '\\u{342}']),\n        ('\\u{1ff2}', ['\\u{1ffa}', '\\u{399}', '\\0']), ('\\u{1ff3}', ['\\u{3a9}', '\\u{399}', '\\0']),\n        ('\\u{1ff4}', ['\\u{38f}', '\\u{399}', '\\0']), ('\\u{1ff6}', ['\\u{3a9}', '\\u{342}', '\\0']),\n        ('\\u{1ff7}', ['\\u{3a9}', '\\u{342}', '\\u{399}']), ('\\u{1ffc}', ['\\u{3a9}', '\\u{399}', '\\0']),\n        ('\\u{214e}', ['\\u{2132}', '\\0', '\\0']), ('\\u{2170}', ['\\u{2160}', '\\0', '\\0']), ('\\u{2171}',\n        ['\\u{2161}', '\\0', '\\0']), ('\\u{2172}', ['\\u{2162}', '\\0', '\\0']), ('\\u{2173}', ['\\u{2163}',\n        '\\0', '\\0']), ('\\u{2174}', ['\\u{2164}', '\\0', '\\0']), ('\\u{2175}', ['\\u{2165}', '\\0',\n        '\\0']), ('\\u{2176}', ['\\u{2166}', '\\0', '\\0']), ('\\u{2177}', ['\\u{2167}', '\\0', '\\0']),\n        ('\\u{2178}', ['\\u{2168}', '\\0', '\\0']), ('\\u{2179}', ['\\u{2169}', '\\0', '\\0']), ('\\u{217a}',\n        ['\\u{216a}', '\\0', '\\0']), ('\\u{217b}', ['\\u{216b}', '\\0', '\\0']), ('\\u{217c}', ['\\u{216c}',\n        '\\0', '\\0']), ('\\u{217d}', ['\\u{216d}', '\\0', '\\0']), ('\\u{217e}', ['\\u{216e}', '\\0',\n        '\\0']), ('\\u{217f}', ['\\u{216f}', '\\0', '\\0']), ('\\u{2184}', ['\\u{2183}', '\\0', '\\0']),\n        ('\\u{24d0}', ['\\u{24b6}', '\\0', '\\0']), ('\\u{24d1}', ['\\u{24b7}', '\\0', '\\0']), ('\\u{24d2}',\n        ['\\u{24b8}', '\\0', '\\0']), ('\\u{24d3}', ['\\u{24b9}', '\\0', '\\0']), ('\\u{24d4}', ['\\u{24ba}',\n        '\\0', '\\0']), ('\\u{24d5}', ['\\u{24bb}', '\\0', '\\0']), ('\\u{24d6}', ['\\u{24bc}', '\\0',\n        '\\0']), ('\\u{24d7}', ['\\u{24bd}', '\\0', '\\0']), ('\\u{24d8}', ['\\u{24be}', '\\0', '\\0']),\n        ('\\u{24d9}', ['\\u{24bf}', '\\0', '\\0']), ('\\u{24da}', ['\\u{24c0}', '\\0', '\\0']), ('\\u{24db}',\n        ['\\u{24c1}', '\\0', '\\0']), ('\\u{24dc}', ['\\u{24c2}', '\\0', '\\0']), ('\\u{24dd}', ['\\u{24c3}',\n        '\\0', '\\0']), ('\\u{24de}', ['\\u{24c4}', '\\0', '\\0']), ('\\u{24df}', ['\\u{24c5}', '\\0',\n        '\\0']), ('\\u{24e0}', ['\\u{24c6}', '\\0', '\\0']), ('\\u{24e1}', ['\\u{24c7}', '\\0', '\\0']),\n        ('\\u{24e2}', ['\\u{24c8}', '\\0', '\\0']), ('\\u{24e3}', ['\\u{24c9}', '\\0', '\\0']), ('\\u{24e4}',\n        ['\\u{24ca}', '\\0', '\\0']), ('\\u{24e5}', ['\\u{24cb}', '\\0', '\\0']), ('\\u{24e6}', ['\\u{24cc}',\n        '\\0', '\\0']), ('\\u{24e7}', ['\\u{24cd}', '\\0', '\\0']), ('\\u{24e8}', ['\\u{24ce}', '\\0',\n        '\\0']), ('\\u{24e9}', ['\\u{24cf}', '\\0', '\\0']), ('\\u{2c30}', ['\\u{2c00}', '\\0', '\\0']),\n        ('\\u{2c31}', ['\\u{2c01}', '\\0', '\\0']), ('\\u{2c32}', ['\\u{2c02}', '\\0', '\\0']), ('\\u{2c33}',\n        ['\\u{2c03}', '\\0', '\\0']), ('\\u{2c34}', ['\\u{2c04}', '\\0', '\\0']), ('\\u{2c35}', ['\\u{2c05}',\n        '\\0', '\\0']), ('\\u{2c36}', ['\\u{2c06}', '\\0', '\\0']), ('\\u{2c37}', ['\\u{2c07}', '\\0',\n        '\\0']), ('\\u{2c38}', ['\\u{2c08}', '\\0', '\\0']), ('\\u{2c39}', ['\\u{2c09}', '\\0', '\\0']),\n        ('\\u{2c3a}', ['\\u{2c0a}', '\\0', '\\0']), ('\\u{2c3b}', ['\\u{2c0b}', '\\0', '\\0']), ('\\u{2c3c}',\n        ['\\u{2c0c}', '\\0', '\\0']), ('\\u{2c3d}', ['\\u{2c0d}', '\\0', '\\0']), ('\\u{2c3e}', ['\\u{2c0e}',\n        '\\0', '\\0']), ('\\u{2c3f}', ['\\u{2c0f}', '\\0', '\\0']), ('\\u{2c40}', ['\\u{2c10}', '\\0',\n        '\\0']), ('\\u{2c41}', ['\\u{2c11}', '\\0', '\\0']), ('\\u{2c42}', ['\\u{2c12}', '\\0', '\\0']),\n        ('\\u{2c43}', ['\\u{2c13}', '\\0', '\\0']), ('\\u{2c44}', ['\\u{2c14}', '\\0', '\\0']), ('\\u{2c45}',\n        ['\\u{2c15}', '\\0', '\\0']), ('\\u{2c46}', ['\\u{2c16}', '\\0', '\\0']), ('\\u{2c47}', ['\\u{2c17}',\n        '\\0', '\\0']), ('\\u{2c48}', ['\\u{2c18}', '\\0', '\\0']), ('\\u{2c49}', ['\\u{2c19}', '\\0',\n        '\\0']), ('\\u{2c4a}', ['\\u{2c1a}', '\\0', '\\0']), ('\\u{2c4b}', ['\\u{2c1b}', '\\0', '\\0']),\n        ('\\u{2c4c}', ['\\u{2c1c}', '\\0', '\\0']), ('\\u{2c4d}', ['\\u{2c1d}', '\\0', '\\0']), ('\\u{2c4e}',\n        ['\\u{2c1e}', '\\0', '\\0']), ('\\u{2c4f}', ['\\u{2c1f}', '\\0', '\\0']), ('\\u{2c50}', ['\\u{2c20}',\n        '\\0', '\\0']), ('\\u{2c51}', ['\\u{2c21}', '\\0', '\\0']), ('\\u{2c52}', ['\\u{2c22}', '\\0',\n        '\\0']), ('\\u{2c53}', ['\\u{2c23}', '\\0', '\\0']), ('\\u{2c54}', ['\\u{2c24}', '\\0', '\\0']),\n        ('\\u{2c55}', ['\\u{2c25}', '\\0', '\\0']), ('\\u{2c56}', ['\\u{2c26}', '\\0', '\\0']), ('\\u{2c57}',\n        ['\\u{2c27}', '\\0', '\\0']), ('\\u{2c58}', ['\\u{2c28}', '\\0', '\\0']), ('\\u{2c59}', ['\\u{2c29}',\n        '\\0', '\\0']), ('\\u{2c5a}', ['\\u{2c2a}', '\\0', '\\0']), ('\\u{2c5b}', ['\\u{2c2b}', '\\0',\n        '\\0']), ('\\u{2c5c}', ['\\u{2c2c}', '\\0', '\\0']), ('\\u{2c5d}', ['\\u{2c2d}', '\\0', '\\0']),\n        ('\\u{2c5e}', ['\\u{2c2e}', '\\0', '\\0']), ('\\u{2c61}', ['\\u{2c60}', '\\0', '\\0']), ('\\u{2c65}',\n        ['\\u{23a}', '\\0', '\\0']), ('\\u{2c66}', ['\\u{23e}', '\\0', '\\0']), ('\\u{2c68}', ['\\u{2c67}',\n        '\\0', '\\0']), ('\\u{2c6a}', ['\\u{2c69}', '\\0', '\\0']), ('\\u{2c6c}', ['\\u{2c6b}', '\\0',\n        '\\0']), ('\\u{2c73}', ['\\u{2c72}', '\\0', '\\0']), ('\\u{2c76}', ['\\u{2c75}', '\\0', '\\0']),\n        ('\\u{2c81}', ['\\u{2c80}', '\\0', '\\0']), ('\\u{2c83}', ['\\u{2c82}', '\\0', '\\0']), ('\\u{2c85}',\n        ['\\u{2c84}', '\\0', '\\0']), ('\\u{2c87}', ['\\u{2c86}', '\\0', '\\0']), ('\\u{2c89}', ['\\u{2c88}',\n        '\\0', '\\0']), ('\\u{2c8b}', ['\\u{2c8a}', '\\0', '\\0']), ('\\u{2c8d}', ['\\u{2c8c}', '\\0',\n        '\\0']), ('\\u{2c8f}', ['\\u{2c8e}', '\\0', '\\0']), ('\\u{2c91}', ['\\u{2c90}', '\\0', '\\0']),\n        ('\\u{2c93}', ['\\u{2c92}', '\\0', '\\0']), ('\\u{2c95}', ['\\u{2c94}', '\\0', '\\0']), ('\\u{2c97}',\n        ['\\u{2c96}', '\\0', '\\0']), ('\\u{2c99}', ['\\u{2c98}', '\\0', '\\0']), ('\\u{2c9b}', ['\\u{2c9a}',\n        '\\0', '\\0']), ('\\u{2c9d}', ['\\u{2c9c}', '\\0', '\\0']), ('\\u{2c9f}', ['\\u{2c9e}', '\\0',\n        '\\0']), ('\\u{2ca1}', ['\\u{2ca0}', '\\0', '\\0']), ('\\u{2ca3}', ['\\u{2ca2}', '\\0', '\\0']),\n        ('\\u{2ca5}', ['\\u{2ca4}', '\\0', '\\0']), ('\\u{2ca7}', ['\\u{2ca6}', '\\0', '\\0']), ('\\u{2ca9}',\n        ['\\u{2ca8}', '\\0', '\\0']), ('\\u{2cab}', ['\\u{2caa}', '\\0', '\\0']), ('\\u{2cad}', ['\\u{2cac}',\n        '\\0', '\\0']), ('\\u{2caf}', ['\\u{2cae}', '\\0', '\\0']), ('\\u{2cb1}', ['\\u{2cb0}', '\\0',\n        '\\0']), ('\\u{2cb3}', ['\\u{2cb2}', '\\0', '\\0']), ('\\u{2cb5}', ['\\u{2cb4}', '\\0', '\\0']),\n        ('\\u{2cb7}', ['\\u{2cb6}', '\\0', '\\0']), ('\\u{2cb9}', ['\\u{2cb8}', '\\0', '\\0']), ('\\u{2cbb}',\n        ['\\u{2cba}', '\\0', '\\0']), ('\\u{2cbd}', ['\\u{2cbc}', '\\0', '\\0']), ('\\u{2cbf}', ['\\u{2cbe}',\n        '\\0', '\\0']), ('\\u{2cc1}', ['\\u{2cc0}', '\\0', '\\0']), ('\\u{2cc3}', ['\\u{2cc2}', '\\0',\n        '\\0']), ('\\u{2cc5}', ['\\u{2cc4}', '\\0', '\\0']), ('\\u{2cc7}', ['\\u{2cc6}', '\\0', '\\0']),\n        ('\\u{2cc9}', ['\\u{2cc8}', '\\0', '\\0']), ('\\u{2ccb}', ['\\u{2cca}', '\\0', '\\0']), ('\\u{2ccd}',\n        ['\\u{2ccc}', '\\0', '\\0']), ('\\u{2ccf}', ['\\u{2cce}', '\\0', '\\0']), ('\\u{2cd1}', ['\\u{2cd0}',\n        '\\0', '\\0']), ('\\u{2cd3}', ['\\u{2cd2}', '\\0', '\\0']), ('\\u{2cd5}', ['\\u{2cd4}', '\\0',\n        '\\0']), ('\\u{2cd7}', ['\\u{2cd6}', '\\0', '\\0']), ('\\u{2cd9}', ['\\u{2cd8}', '\\0', '\\0']),\n        ('\\u{2cdb}', ['\\u{2cda}', '\\0', '\\0']), ('\\u{2cdd}', ['\\u{2cdc}', '\\0', '\\0']), ('\\u{2cdf}',\n        ['\\u{2cde}', '\\0', '\\0']), ('\\u{2ce1}', ['\\u{2ce0}', '\\0', '\\0']), ('\\u{2ce3}', ['\\u{2ce2}',\n        '\\0', '\\0']), ('\\u{2cec}', ['\\u{2ceb}', '\\0', '\\0']), ('\\u{2cee}', ['\\u{2ced}', '\\0',\n        '\\0']), ('\\u{2cf3}', ['\\u{2cf2}', '\\0', '\\0']), ('\\u{2d00}', ['\\u{10a0}', '\\0', '\\0']),\n        ('\\u{2d01}', ['\\u{10a1}', '\\0', '\\0']), ('\\u{2d02}', ['\\u{10a2}', '\\0', '\\0']), ('\\u{2d03}',\n        ['\\u{10a3}', '\\0', '\\0']), ('\\u{2d04}', ['\\u{10a4}', '\\0', '\\0']), ('\\u{2d05}', ['\\u{10a5}',\n        '\\0', '\\0']), ('\\u{2d06}', ['\\u{10a6}', '\\0', '\\0']), ('\\u{2d07}', ['\\u{10a7}', '\\0',\n        '\\0']), ('\\u{2d08}', ['\\u{10a8}', '\\0', '\\0']), ('\\u{2d09}', ['\\u{10a9}', '\\0', '\\0']),\n        ('\\u{2d0a}', ['\\u{10aa}', '\\0', '\\0']), ('\\u{2d0b}', ['\\u{10ab}', '\\0', '\\0']), ('\\u{2d0c}',\n        ['\\u{10ac}', '\\0', '\\0']), ('\\u{2d0d}', ['\\u{10ad}', '\\0', '\\0']), ('\\u{2d0e}', ['\\u{10ae}',\n        '\\0', '\\0']), ('\\u{2d0f}', ['\\u{10af}', '\\0', '\\0']), ('\\u{2d10}', ['\\u{10b0}', '\\0',\n        '\\0']), ('\\u{2d11}', ['\\u{10b1}', '\\0', '\\0']), ('\\u{2d12}', ['\\u{10b2}', '\\0', '\\0']),\n        ('\\u{2d13}', ['\\u{10b3}', '\\0', '\\0']), ('\\u{2d14}', ['\\u{10b4}', '\\0', '\\0']), ('\\u{2d15}',\n        ['\\u{10b5}', '\\0', '\\0']), ('\\u{2d16}', ['\\u{10b6}', '\\0', '\\0']), ('\\u{2d17}', ['\\u{10b7}',\n        '\\0', '\\0']), ('\\u{2d18}', ['\\u{10b8}', '\\0', '\\0']), ('\\u{2d19}', ['\\u{10b9}', '\\0',\n        '\\0']), ('\\u{2d1a}', ['\\u{10ba}', '\\0', '\\0']), ('\\u{2d1b}', ['\\u{10bb}', '\\0', '\\0']),\n        ('\\u{2d1c}', ['\\u{10bc}', '\\0', '\\0']), ('\\u{2d1d}', ['\\u{10bd}', '\\0', '\\0']), ('\\u{2d1e}',\n        ['\\u{10be}', '\\0', '\\0']), ('\\u{2d1f}', ['\\u{10bf}', '\\0', '\\0']), ('\\u{2d20}', ['\\u{10c0}',\n        '\\0', '\\0']), ('\\u{2d21}', ['\\u{10c1}', '\\0', '\\0']), ('\\u{2d22}', ['\\u{10c2}', '\\0',\n        '\\0']), ('\\u{2d23}', ['\\u{10c3}', '\\0', '\\0']), ('\\u{2d24}', ['\\u{10c4}', '\\0', '\\0']),\n        ('\\u{2d25}', ['\\u{10c5}', '\\0', '\\0']), ('\\u{2d27}', ['\\u{10c7}', '\\0', '\\0']), ('\\u{2d2d}',\n        ['\\u{10cd}', '\\0', '\\0']), ('\\u{a641}', ['\\u{a640}', '\\0', '\\0']), ('\\u{a643}', ['\\u{a642}',\n        '\\0', '\\0']), ('\\u{a645}', ['\\u{a644}', '\\0', '\\0']), ('\\u{a647}', ['\\u{a646}', '\\0',\n        '\\0']), ('\\u{a649}', ['\\u{a648}', '\\0', '\\0']), ('\\u{a64b}', ['\\u{a64a}', '\\0', '\\0']),\n        ('\\u{a64d}', ['\\u{a64c}', '\\0', '\\0']), ('\\u{a64f}', ['\\u{a64e}', '\\0', '\\0']), ('\\u{a651}',\n        ['\\u{a650}', '\\0', '\\0']), ('\\u{a653}', ['\\u{a652}', '\\0', '\\0']), ('\\u{a655}', ['\\u{a654}',\n        '\\0', '\\0']), ('\\u{a657}', ['\\u{a656}', '\\0', '\\0']), ('\\u{a659}', ['\\u{a658}', '\\0',\n        '\\0']), ('\\u{a65b}', ['\\u{a65a}', '\\0', '\\0']), ('\\u{a65d}', ['\\u{a65c}', '\\0', '\\0']),\n        ('\\u{a65f}', ['\\u{a65e}', '\\0', '\\0']), ('\\u{a661}', ['\\u{a660}', '\\0', '\\0']), ('\\u{a663}',\n        ['\\u{a662}', '\\0', '\\0']), ('\\u{a665}', ['\\u{a664}', '\\0', '\\0']), ('\\u{a667}', ['\\u{a666}',\n        '\\0', '\\0']), ('\\u{a669}', ['\\u{a668}', '\\0', '\\0']), ('\\u{a66b}', ['\\u{a66a}', '\\0',\n        '\\0']), ('\\u{a66d}', ['\\u{a66c}', '\\0', '\\0']), ('\\u{a681}', ['\\u{a680}', '\\0', '\\0']),\n        ('\\u{a683}', ['\\u{a682}', '\\0', '\\0']), ('\\u{a685}', ['\\u{a684}', '\\0', '\\0']), ('\\u{a687}',\n        ['\\u{a686}', '\\0', '\\0']), ('\\u{a689}', ['\\u{a688}', '\\0', '\\0']), ('\\u{a68b}', ['\\u{a68a}',\n        '\\0', '\\0']), ('\\u{a68d}', ['\\u{a68c}', '\\0', '\\0']), ('\\u{a68f}', ['\\u{a68e}', '\\0',\n        '\\0']), ('\\u{a691}', ['\\u{a690}', '\\0', '\\0']), ('\\u{a693}', ['\\u{a692}', '\\0', '\\0']),\n        ('\\u{a695}', ['\\u{a694}', '\\0', '\\0']), ('\\u{a697}', ['\\u{a696}', '\\0', '\\0']), ('\\u{a699}',\n        ['\\u{a698}', '\\0', '\\0']), ('\\u{a69b}', ['\\u{a69a}', '\\0', '\\0']), ('\\u{a723}', ['\\u{a722}',\n        '\\0', '\\0']), ('\\u{a725}', ['\\u{a724}', '\\0', '\\0']), ('\\u{a727}', ['\\u{a726}', '\\0',\n        '\\0']), ('\\u{a729}', ['\\u{a728}', '\\0', '\\0']), ('\\u{a72b}', ['\\u{a72a}', '\\0', '\\0']),\n        ('\\u{a72d}', ['\\u{a72c}', '\\0', '\\0']), ('\\u{a72f}', ['\\u{a72e}', '\\0', '\\0']), ('\\u{a733}',\n        ['\\u{a732}', '\\0', '\\0']), ('\\u{a735}', ['\\u{a734}', '\\0', '\\0']), ('\\u{a737}', ['\\u{a736}',\n        '\\0', '\\0']), ('\\u{a739}', ['\\u{a738}', '\\0', '\\0']), ('\\u{a73b}', ['\\u{a73a}', '\\0',\n        '\\0']), ('\\u{a73d}', ['\\u{a73c}', '\\0', '\\0']), ('\\u{a73f}', ['\\u{a73e}', '\\0', '\\0']),\n        ('\\u{a741}', ['\\u{a740}', '\\0', '\\0']), ('\\u{a743}', ['\\u{a742}', '\\0', '\\0']), ('\\u{a745}',\n        ['\\u{a744}', '\\0', '\\0']), ('\\u{a747}', ['\\u{a746}', '\\0', '\\0']), ('\\u{a749}', ['\\u{a748}',\n        '\\0', '\\0']), ('\\u{a74b}', ['\\u{a74a}', '\\0', '\\0']), ('\\u{a74d}', ['\\u{a74c}', '\\0',\n        '\\0']), ('\\u{a74f}', ['\\u{a74e}', '\\0', '\\0']), ('\\u{a751}', ['\\u{a750}', '\\0', '\\0']),\n        ('\\u{a753}', ['\\u{a752}', '\\0', '\\0']), ('\\u{a755}', ['\\u{a754}', '\\0', '\\0']), ('\\u{a757}',\n        ['\\u{a756}', '\\0', '\\0']), ('\\u{a759}', ['\\u{a758}', '\\0', '\\0']), ('\\u{a75b}', ['\\u{a75a}',\n        '\\0', '\\0']), ('\\u{a75d}', ['\\u{a75c}', '\\0', '\\0']), ('\\u{a75f}', ['\\u{a75e}', '\\0',\n        '\\0']), ('\\u{a761}', ['\\u{a760}', '\\0', '\\0']), ('\\u{a763}', ['\\u{a762}', '\\0', '\\0']),\n        ('\\u{a765}', ['\\u{a764}', '\\0', '\\0']), ('\\u{a767}', ['\\u{a766}', '\\0', '\\0']), ('\\u{a769}',\n        ['\\u{a768}', '\\0', '\\0']), ('\\u{a76b}', ['\\u{a76a}', '\\0', '\\0']), ('\\u{a76d}', ['\\u{a76c}',\n        '\\0', '\\0']), ('\\u{a76f}', ['\\u{a76e}', '\\0', '\\0']), ('\\u{a77a}', ['\\u{a779}', '\\0',\n        '\\0']), ('\\u{a77c}', ['\\u{a77b}', '\\0', '\\0']), ('\\u{a77f}', ['\\u{a77e}', '\\0', '\\0']),\n        ('\\u{a781}', ['\\u{a780}', '\\0', '\\0']), ('\\u{a783}', ['\\u{a782}', '\\0', '\\0']), ('\\u{a785}',\n        ['\\u{a784}', '\\0', '\\0']), ('\\u{a787}', ['\\u{a786}', '\\0', '\\0']), ('\\u{a78c}', ['\\u{a78b}',\n        '\\0', '\\0']), ('\\u{a791}', ['\\u{a790}', '\\0', '\\0']), ('\\u{a793}', ['\\u{a792}', '\\0',\n        '\\0']), ('\\u{a797}', ['\\u{a796}', '\\0', '\\0']), ('\\u{a799}', ['\\u{a798}', '\\0', '\\0']),\n        ('\\u{a79b}', ['\\u{a79a}', '\\0', '\\0']), ('\\u{a79d}', ['\\u{a79c}', '\\0', '\\0']), ('\\u{a79f}',\n        ['\\u{a79e}', '\\0', '\\0']), ('\\u{a7a1}', ['\\u{a7a0}', '\\0', '\\0']), ('\\u{a7a3}', ['\\u{a7a2}',\n        '\\0', '\\0']), ('\\u{a7a5}', ['\\u{a7a4}', '\\0', '\\0']), ('\\u{a7a7}', ['\\u{a7a6}', '\\0',\n        '\\0']), ('\\u{a7a9}', ['\\u{a7a8}', '\\0', '\\0']), ('\\u{a7b5}', ['\\u{a7b4}', '\\0', '\\0']),\n        ('\\u{a7b7}', ['\\u{a7b6}', '\\0', '\\0']), ('\\u{a7b9}', ['\\u{a7b8}', '\\0', '\\0']), ('\\u{ab53}',\n        ['\\u{a7b3}', '\\0', '\\0']), ('\\u{ab70}', ['\\u{13a0}', '\\0', '\\0']), ('\\u{ab71}', ['\\u{13a1}',\n        '\\0', '\\0']), ('\\u{ab72}', ['\\u{13a2}', '\\0', '\\0']), ('\\u{ab73}', ['\\u{13a3}', '\\0',\n        '\\0']), ('\\u{ab74}', ['\\u{13a4}', '\\0', '\\0']), ('\\u{ab75}', ['\\u{13a5}', '\\0', '\\0']),\n        ('\\u{ab76}', ['\\u{13a6}', '\\0', '\\0']), ('\\u{ab77}', ['\\u{13a7}', '\\0', '\\0']), ('\\u{ab78}',\n        ['\\u{13a8}', '\\0', '\\0']), ('\\u{ab79}', ['\\u{13a9}', '\\0', '\\0']), ('\\u{ab7a}', ['\\u{13aa}',\n        '\\0', '\\0']), ('\\u{ab7b}', ['\\u{13ab}', '\\0', '\\0']), ('\\u{ab7c}', ['\\u{13ac}', '\\0',\n        '\\0']), ('\\u{ab7d}', ['\\u{13ad}', '\\0', '\\0']), ('\\u{ab7e}', ['\\u{13ae}', '\\0', '\\0']),\n        ('\\u{ab7f}', ['\\u{13af}', '\\0', '\\0']), ('\\u{ab80}', ['\\u{13b0}', '\\0', '\\0']), ('\\u{ab81}',\n        ['\\u{13b1}', '\\0', '\\0']), ('\\u{ab82}', ['\\u{13b2}', '\\0', '\\0']), ('\\u{ab83}', ['\\u{13b3}',\n        '\\0', '\\0']), ('\\u{ab84}', ['\\u{13b4}', '\\0', '\\0']), ('\\u{ab85}', ['\\u{13b5}', '\\0',\n        '\\0']), ('\\u{ab86}', ['\\u{13b6}', '\\0', '\\0']), ('\\u{ab87}', ['\\u{13b7}', '\\0', '\\0']),\n        ('\\u{ab88}', ['\\u{13b8}', '\\0', '\\0']), ('\\u{ab89}', ['\\u{13b9}', '\\0', '\\0']), ('\\u{ab8a}',\n        ['\\u{13ba}', '\\0', '\\0']), ('\\u{ab8b}', ['\\u{13bb}', '\\0', '\\0']), ('\\u{ab8c}', ['\\u{13bc}',\n        '\\0', '\\0']), ('\\u{ab8d}', ['\\u{13bd}', '\\0', '\\0']), ('\\u{ab8e}', ['\\u{13be}', '\\0',\n        '\\0']), ('\\u{ab8f}', ['\\u{13bf}', '\\0', '\\0']), ('\\u{ab90}', ['\\u{13c0}', '\\0', '\\0']),\n        ('\\u{ab91}', ['\\u{13c1}', '\\0', '\\0']), ('\\u{ab92}', ['\\u{13c2}', '\\0', '\\0']), ('\\u{ab93}',\n        ['\\u{13c3}', '\\0', '\\0']), ('\\u{ab94}', ['\\u{13c4}', '\\0', '\\0']), ('\\u{ab95}', ['\\u{13c5}',\n        '\\0', '\\0']), ('\\u{ab96}', ['\\u{13c6}', '\\0', '\\0']), ('\\u{ab97}', ['\\u{13c7}', '\\0',\n        '\\0']), ('\\u{ab98}', ['\\u{13c8}', '\\0', '\\0']), ('\\u{ab99}', ['\\u{13c9}', '\\0', '\\0']),\n        ('\\u{ab9a}', ['\\u{13ca}', '\\0', '\\0']), ('\\u{ab9b}', ['\\u{13cb}', '\\0', '\\0']), ('\\u{ab9c}',\n        ['\\u{13cc}', '\\0', '\\0']), ('\\u{ab9d}', ['\\u{13cd}', '\\0', '\\0']), ('\\u{ab9e}', ['\\u{13ce}',\n        '\\0', '\\0']), ('\\u{ab9f}', ['\\u{13cf}', '\\0', '\\0']), ('\\u{aba0}', ['\\u{13d0}', '\\0',\n        '\\0']), ('\\u{aba1}', ['\\u{13d1}', '\\0', '\\0']), ('\\u{aba2}', ['\\u{13d2}', '\\0', '\\0']),\n        ('\\u{aba3}', ['\\u{13d3}', '\\0', '\\0']), ('\\u{aba4}', ['\\u{13d4}', '\\0', '\\0']), ('\\u{aba5}',\n        ['\\u{13d5}', '\\0', '\\0']), ('\\u{aba6}', ['\\u{13d6}', '\\0', '\\0']), ('\\u{aba7}', ['\\u{13d7}',\n        '\\0', '\\0']), ('\\u{aba8}', ['\\u{13d8}', '\\0', '\\0']), ('\\u{aba9}', ['\\u{13d9}', '\\0',\n        '\\0']), ('\\u{abaa}', ['\\u{13da}', '\\0', '\\0']), ('\\u{abab}', ['\\u{13db}', '\\0', '\\0']),\n        ('\\u{abac}', ['\\u{13dc}', '\\0', '\\0']), ('\\u{abad}', ['\\u{13dd}', '\\0', '\\0']), ('\\u{abae}',\n        ['\\u{13de}', '\\0', '\\0']), ('\\u{abaf}', ['\\u{13df}', '\\0', '\\0']), ('\\u{abb0}', ['\\u{13e0}',\n        '\\0', '\\0']), ('\\u{abb1}', ['\\u{13e1}', '\\0', '\\0']), ('\\u{abb2}', ['\\u{13e2}', '\\0',\n        '\\0']), ('\\u{abb3}', ['\\u{13e3}', '\\0', '\\0']), ('\\u{abb4}', ['\\u{13e4}', '\\0', '\\0']),\n        ('\\u{abb5}', ['\\u{13e5}', '\\0', '\\0']), ('\\u{abb6}', ['\\u{13e6}', '\\0', '\\0']), ('\\u{abb7}',\n        ['\\u{13e7}', '\\0', '\\0']), ('\\u{abb8}', ['\\u{13e8}', '\\0', '\\0']), ('\\u{abb9}', ['\\u{13e9}',\n        '\\0', '\\0']), ('\\u{abba}', ['\\u{13ea}', '\\0', '\\0']), ('\\u{abbb}', ['\\u{13eb}', '\\0',\n        '\\0']), ('\\u{abbc}', ['\\u{13ec}', '\\0', '\\0']), ('\\u{abbd}', ['\\u{13ed}', '\\0', '\\0']),\n        ('\\u{abbe}', ['\\u{13ee}', '\\0', '\\0']), ('\\u{abbf}', ['\\u{13ef}', '\\0', '\\0']), ('\\u{fb00}',\n        ['\\u{46}', '\\u{46}', '\\0']), ('\\u{fb01}', ['\\u{46}', '\\u{49}', '\\0']), ('\\u{fb02}',\n        ['\\u{46}', '\\u{4c}', '\\0']), ('\\u{fb03}', ['\\u{46}', '\\u{46}', '\\u{49}']), ('\\u{fb04}',\n        ['\\u{46}', '\\u{46}', '\\u{4c}']), ('\\u{fb05}', ['\\u{53}', '\\u{54}', '\\0']), ('\\u{fb06}',\n        ['\\u{53}', '\\u{54}', '\\0']), ('\\u{fb13}', ['\\u{544}', '\\u{546}', '\\0']), ('\\u{fb14}',\n        ['\\u{544}', '\\u{535}', '\\0']), ('\\u{fb15}', ['\\u{544}', '\\u{53b}', '\\0']), ('\\u{fb16}',\n        ['\\u{54e}', '\\u{546}', '\\0']), ('\\u{fb17}', ['\\u{544}', '\\u{53d}', '\\0']), ('\\u{ff41}',\n        ['\\u{ff21}', '\\0', '\\0']), ('\\u{ff42}', ['\\u{ff22}', '\\0', '\\0']), ('\\u{ff43}', ['\\u{ff23}',\n        '\\0', '\\0']), ('\\u{ff44}', ['\\u{ff24}', '\\0', '\\0']), ('\\u{ff45}', ['\\u{ff25}', '\\0',\n        '\\0']), ('\\u{ff46}', ['\\u{ff26}', '\\0', '\\0']), ('\\u{ff47}', ['\\u{ff27}', '\\0', '\\0']),\n        ('\\u{ff48}', ['\\u{ff28}', '\\0', '\\0']), ('\\u{ff49}', ['\\u{ff29}', '\\0', '\\0']), ('\\u{ff4a}',\n        ['\\u{ff2a}', '\\0', '\\0']), ('\\u{ff4b}', ['\\u{ff2b}', '\\0', '\\0']), ('\\u{ff4c}', ['\\u{ff2c}',\n        '\\0', '\\0']), ('\\u{ff4d}', ['\\u{ff2d}', '\\0', '\\0']), ('\\u{ff4e}', ['\\u{ff2e}', '\\0',\n        '\\0']), ('\\u{ff4f}', ['\\u{ff2f}', '\\0', '\\0']), ('\\u{ff50}', ['\\u{ff30}', '\\0', '\\0']),\n        ('\\u{ff51}', ['\\u{ff31}', '\\0', '\\0']), ('\\u{ff52}', ['\\u{ff32}', '\\0', '\\0']), ('\\u{ff53}',\n        ['\\u{ff33}', '\\0', '\\0']), ('\\u{ff54}', ['\\u{ff34}', '\\0', '\\0']), ('\\u{ff55}', ['\\u{ff35}',\n        '\\0', '\\0']), ('\\u{ff56}', ['\\u{ff36}', '\\0', '\\0']), ('\\u{ff57}', ['\\u{ff37}', '\\0',\n        '\\0']), ('\\u{ff58}', ['\\u{ff38}', '\\0', '\\0']), ('\\u{ff59}', ['\\u{ff39}', '\\0', '\\0']),\n        ('\\u{ff5a}', ['\\u{ff3a}', '\\0', '\\0']), ('\\u{10428}', ['\\u{10400}', '\\0', '\\0']),\n        ('\\u{10429}', ['\\u{10401}', '\\0', '\\0']), ('\\u{1042a}', ['\\u{10402}', '\\0', '\\0']),\n        ('\\u{1042b}', ['\\u{10403}', '\\0', '\\0']), ('\\u{1042c}', ['\\u{10404}', '\\0', '\\0']),\n        ('\\u{1042d}', ['\\u{10405}', '\\0', '\\0']), ('\\u{1042e}', ['\\u{10406}', '\\0', '\\0']),\n        ('\\u{1042f}', ['\\u{10407}', '\\0', '\\0']), ('\\u{10430}', ['\\u{10408}', '\\0', '\\0']),\n        ('\\u{10431}', ['\\u{10409}', '\\0', '\\0']), ('\\u{10432}', ['\\u{1040a}', '\\0', '\\0']),\n        ('\\u{10433}', ['\\u{1040b}', '\\0', '\\0']), ('\\u{10434}', ['\\u{1040c}', '\\0', '\\0']),\n        ('\\u{10435}', ['\\u{1040d}', '\\0', '\\0']), ('\\u{10436}', ['\\u{1040e}', '\\0', '\\0']),\n        ('\\u{10437}', ['\\u{1040f}', '\\0', '\\0']), ('\\u{10438}', ['\\u{10410}', '\\0', '\\0']),\n        ('\\u{10439}', ['\\u{10411}', '\\0', '\\0']), ('\\u{1043a}', ['\\u{10412}', '\\0', '\\0']),\n        ('\\u{1043b}', ['\\u{10413}', '\\0', '\\0']), ('\\u{1043c}', ['\\u{10414}', '\\0', '\\0']),\n        ('\\u{1043d}', ['\\u{10415}', '\\0', '\\0']), ('\\u{1043e}', ['\\u{10416}', '\\0', '\\0']),\n        ('\\u{1043f}', ['\\u{10417}', '\\0', '\\0']), ('\\u{10440}', ['\\u{10418}', '\\0', '\\0']),\n        ('\\u{10441}', ['\\u{10419}', '\\0', '\\0']), ('\\u{10442}', ['\\u{1041a}', '\\0', '\\0']),\n        ('\\u{10443}', ['\\u{1041b}', '\\0', '\\0']), ('\\u{10444}', ['\\u{1041c}', '\\0', '\\0']),\n        ('\\u{10445}', ['\\u{1041d}', '\\0', '\\0']), ('\\u{10446}', ['\\u{1041e}', '\\0', '\\0']),\n        ('\\u{10447}', ['\\u{1041f}', '\\0', '\\0']), ('\\u{10448}', ['\\u{10420}', '\\0', '\\0']),\n        ('\\u{10449}', ['\\u{10421}', '\\0', '\\0']), ('\\u{1044a}', ['\\u{10422}', '\\0', '\\0']),\n        ('\\u{1044b}', ['\\u{10423}', '\\0', '\\0']), ('\\u{1044c}', ['\\u{10424}', '\\0', '\\0']),\n        ('\\u{1044d}', ['\\u{10425}', '\\0', '\\0']), ('\\u{1044e}', ['\\u{10426}', '\\0', '\\0']),\n        ('\\u{1044f}', ['\\u{10427}', '\\0', '\\0']), ('\\u{104d8}', ['\\u{104b0}', '\\0', '\\0']),\n        ('\\u{104d9}', ['\\u{104b1}', '\\0', '\\0']), ('\\u{104da}', ['\\u{104b2}', '\\0', '\\0']),\n        ('\\u{104db}', ['\\u{104b3}', '\\0', '\\0']), ('\\u{104dc}', ['\\u{104b4}', '\\0', '\\0']),\n        ('\\u{104dd}', ['\\u{104b5}', '\\0', '\\0']), ('\\u{104de}', ['\\u{104b6}', '\\0', '\\0']),\n        ('\\u{104df}', ['\\u{104b7}', '\\0', '\\0']), ('\\u{104e0}', ['\\u{104b8}', '\\0', '\\0']),\n        ('\\u{104e1}', ['\\u{104b9}', '\\0', '\\0']), ('\\u{104e2}', ['\\u{104ba}', '\\0', '\\0']),\n        ('\\u{104e3}', ['\\u{104bb}', '\\0', '\\0']), ('\\u{104e4}', ['\\u{104bc}', '\\0', '\\0']),\n        ('\\u{104e5}', ['\\u{104bd}', '\\0', '\\0']), ('\\u{104e6}', ['\\u{104be}', '\\0', '\\0']),\n        ('\\u{104e7}', ['\\u{104bf}', '\\0', '\\0']), ('\\u{104e8}', ['\\u{104c0}', '\\0', '\\0']),\n        ('\\u{104e9}', ['\\u{104c1}', '\\0', '\\0']), ('\\u{104ea}', ['\\u{104c2}', '\\0', '\\0']),\n        ('\\u{104eb}', ['\\u{104c3}', '\\0', '\\0']), ('\\u{104ec}', ['\\u{104c4}', '\\0', '\\0']),\n        ('\\u{104ed}', ['\\u{104c5}', '\\0', '\\0']), ('\\u{104ee}', ['\\u{104c6}', '\\0', '\\0']),\n        ('\\u{104ef}', ['\\u{104c7}', '\\0', '\\0']), ('\\u{104f0}', ['\\u{104c8}', '\\0', '\\0']),\n        ('\\u{104f1}', ['\\u{104c9}', '\\0', '\\0']), ('\\u{104f2}', ['\\u{104ca}', '\\0', '\\0']),\n        ('\\u{104f3}', ['\\u{104cb}', '\\0', '\\0']), ('\\u{104f4}', ['\\u{104cc}', '\\0', '\\0']),\n        ('\\u{104f5}', ['\\u{104cd}', '\\0', '\\0']), ('\\u{104f6}', ['\\u{104ce}', '\\0', '\\0']),\n        ('\\u{104f7}', ['\\u{104cf}', '\\0', '\\0']), ('\\u{104f8}', ['\\u{104d0}', '\\0', '\\0']),\n        ('\\u{104f9}', ['\\u{104d1}', '\\0', '\\0']), ('\\u{104fa}', ['\\u{104d2}', '\\0', '\\0']),\n        ('\\u{104fb}', ['\\u{104d3}', '\\0', '\\0']), ('\\u{10cc0}', ['\\u{10c80}', '\\0', '\\0']),\n        ('\\u{10cc1}', ['\\u{10c81}', '\\0', '\\0']), ('\\u{10cc2}', ['\\u{10c82}', '\\0', '\\0']),\n        ('\\u{10cc3}', ['\\u{10c83}', '\\0', '\\0']), ('\\u{10cc4}', ['\\u{10c84}', '\\0', '\\0']),\n        ('\\u{10cc5}', ['\\u{10c85}', '\\0', '\\0']), ('\\u{10cc6}', ['\\u{10c86}', '\\0', '\\0']),\n        ('\\u{10cc7}', ['\\u{10c87}', '\\0', '\\0']), ('\\u{10cc8}', ['\\u{10c88}', '\\0', '\\0']),\n        ('\\u{10cc9}', ['\\u{10c89}', '\\0', '\\0']), ('\\u{10cca}', ['\\u{10c8a}', '\\0', '\\0']),\n        ('\\u{10ccb}', ['\\u{10c8b}', '\\0', '\\0']), ('\\u{10ccc}', ['\\u{10c8c}', '\\0', '\\0']),\n        ('\\u{10ccd}', ['\\u{10c8d}', '\\0', '\\0']), ('\\u{10cce}', ['\\u{10c8e}', '\\0', '\\0']),\n        ('\\u{10ccf}', ['\\u{10c8f}', '\\0', '\\0']), ('\\u{10cd0}', ['\\u{10c90}', '\\0', '\\0']),\n        ('\\u{10cd1}', ['\\u{10c91}', '\\0', '\\0']), ('\\u{10cd2}', ['\\u{10c92}', '\\0', '\\0']),\n        ('\\u{10cd3}', ['\\u{10c93}', '\\0', '\\0']), ('\\u{10cd4}', ['\\u{10c94}', '\\0', '\\0']),\n        ('\\u{10cd5}', ['\\u{10c95}', '\\0', '\\0']), ('\\u{10cd6}', ['\\u{10c96}', '\\0', '\\0']),\n        ('\\u{10cd7}', ['\\u{10c97}', '\\0', '\\0']), ('\\u{10cd8}', ['\\u{10c98}', '\\0', '\\0']),\n        ('\\u{10cd9}', ['\\u{10c99}', '\\0', '\\0']), ('\\u{10cda}', ['\\u{10c9a}', '\\0', '\\0']),\n        ('\\u{10cdb}', ['\\u{10c9b}', '\\0', '\\0']), ('\\u{10cdc}', ['\\u{10c9c}', '\\0', '\\0']),\n        ('\\u{10cdd}', ['\\u{10c9d}', '\\0', '\\0']), ('\\u{10cde}', ['\\u{10c9e}', '\\0', '\\0']),\n        ('\\u{10cdf}', ['\\u{10c9f}', '\\0', '\\0']), ('\\u{10ce0}', ['\\u{10ca0}', '\\0', '\\0']),\n        ('\\u{10ce1}', ['\\u{10ca1}', '\\0', '\\0']), ('\\u{10ce2}', ['\\u{10ca2}', '\\0', '\\0']),\n        ('\\u{10ce3}', ['\\u{10ca3}', '\\0', '\\0']), ('\\u{10ce4}', ['\\u{10ca4}', '\\0', '\\0']),\n        ('\\u{10ce5}', ['\\u{10ca5}', '\\0', '\\0']), ('\\u{10ce6}', ['\\u{10ca6}', '\\0', '\\0']),\n        ('\\u{10ce7}', ['\\u{10ca7}', '\\0', '\\0']), ('\\u{10ce8}', ['\\u{10ca8}', '\\0', '\\0']),\n        ('\\u{10ce9}', ['\\u{10ca9}', '\\0', '\\0']), ('\\u{10cea}', ['\\u{10caa}', '\\0', '\\0']),\n        ('\\u{10ceb}', ['\\u{10cab}', '\\0', '\\0']), ('\\u{10cec}', ['\\u{10cac}', '\\0', '\\0']),\n        ('\\u{10ced}', ['\\u{10cad}', '\\0', '\\0']), ('\\u{10cee}', ['\\u{10cae}', '\\0', '\\0']),\n        ('\\u{10cef}', ['\\u{10caf}', '\\0', '\\0']), ('\\u{10cf0}', ['\\u{10cb0}', '\\0', '\\0']),\n        ('\\u{10cf1}', ['\\u{10cb1}', '\\0', '\\0']), ('\\u{10cf2}', ['\\u{10cb2}', '\\0', '\\0']),\n        ('\\u{118c0}', ['\\u{118a0}', '\\0', '\\0']), ('\\u{118c1}', ['\\u{118a1}', '\\0', '\\0']),\n        ('\\u{118c2}', ['\\u{118a2}', '\\0', '\\0']), ('\\u{118c3}', ['\\u{118a3}', '\\0', '\\0']),\n        ('\\u{118c4}', ['\\u{118a4}', '\\0', '\\0']), ('\\u{118c5}', ['\\u{118a5}', '\\0', '\\0']),\n        ('\\u{118c6}', ['\\u{118a6}', '\\0', '\\0']), ('\\u{118c7}', ['\\u{118a7}', '\\0', '\\0']),\n        ('\\u{118c8}', ['\\u{118a8}', '\\0', '\\0']), ('\\u{118c9}', ['\\u{118a9}', '\\0', '\\0']),\n        ('\\u{118ca}', ['\\u{118aa}', '\\0', '\\0']), ('\\u{118cb}', ['\\u{118ab}', '\\0', '\\0']),\n        ('\\u{118cc}', ['\\u{118ac}', '\\0', '\\0']), ('\\u{118cd}', ['\\u{118ad}', '\\0', '\\0']),\n        ('\\u{118ce}', ['\\u{118ae}', '\\0', '\\0']), ('\\u{118cf}', ['\\u{118af}', '\\0', '\\0']),\n        ('\\u{118d0}', ['\\u{118b0}', '\\0', '\\0']), ('\\u{118d1}', ['\\u{118b1}', '\\0', '\\0']),\n        ('\\u{118d2}', ['\\u{118b2}', '\\0', '\\0']), ('\\u{118d3}', ['\\u{118b3}', '\\0', '\\0']),\n        ('\\u{118d4}', ['\\u{118b4}', '\\0', '\\0']), ('\\u{118d5}', ['\\u{118b5}', '\\0', '\\0']),\n        ('\\u{118d6}', ['\\u{118b6}', '\\0', '\\0']), ('\\u{118d7}', ['\\u{118b7}', '\\0', '\\0']),\n        ('\\u{118d8}', ['\\u{118b8}', '\\0', '\\0']), ('\\u{118d9}', ['\\u{118b9}', '\\0', '\\0']),\n        ('\\u{118da}', ['\\u{118ba}', '\\0', '\\0']), ('\\u{118db}', ['\\u{118bb}', '\\0', '\\0']),\n        ('\\u{118dc}', ['\\u{118bc}', '\\0', '\\0']), ('\\u{118dd}', ['\\u{118bd}', '\\0', '\\0']),\n        ('\\u{118de}', ['\\u{118be}', '\\0', '\\0']), ('\\u{118df}', ['\\u{118bf}', '\\0', '\\0']),\n        ('\\u{16e60}', ['\\u{16e40}', '\\0', '\\0']), ('\\u{16e61}', ['\\u{16e41}', '\\0', '\\0']),\n        ('\\u{16e62}', ['\\u{16e42}', '\\0', '\\0']), ('\\u{16e63}', ['\\u{16e43}', '\\0', '\\0']),\n        ('\\u{16e64}', ['\\u{16e44}', '\\0', '\\0']), ('\\u{16e65}', ['\\u{16e45}', '\\0', '\\0']),\n        ('\\u{16e66}', ['\\u{16e46}', '\\0', '\\0']), ('\\u{16e67}', ['\\u{16e47}', '\\0', '\\0']),\n        ('\\u{16e68}', ['\\u{16e48}', '\\0', '\\0']), ('\\u{16e69}', ['\\u{16e49}', '\\0', '\\0']),\n        ('\\u{16e6a}', ['\\u{16e4a}', '\\0', '\\0']), ('\\u{16e6b}', ['\\u{16e4b}', '\\0', '\\0']),\n        ('\\u{16e6c}', ['\\u{16e4c}', '\\0', '\\0']), ('\\u{16e6d}', ['\\u{16e4d}', '\\0', '\\0']),\n        ('\\u{16e6e}', ['\\u{16e4e}', '\\0', '\\0']), ('\\u{16e6f}', ['\\u{16e4f}', '\\0', '\\0']),\n        ('\\u{16e70}', ['\\u{16e50}', '\\0', '\\0']), ('\\u{16e71}', ['\\u{16e51}', '\\0', '\\0']),\n        ('\\u{16e72}', ['\\u{16e52}', '\\0', '\\0']), ('\\u{16e73}', ['\\u{16e53}', '\\0', '\\0']),\n        ('\\u{16e74}', ['\\u{16e54}', '\\0', '\\0']), ('\\u{16e75}', ['\\u{16e55}', '\\0', '\\0']),\n        ('\\u{16e76}', ['\\u{16e56}', '\\0', '\\0']), ('\\u{16e77}', ['\\u{16e57}', '\\0', '\\0']),\n        ('\\u{16e78}', ['\\u{16e58}', '\\0', '\\0']), ('\\u{16e79}', ['\\u{16e59}', '\\0', '\\0']),\n        ('\\u{16e7a}', ['\\u{16e5a}', '\\0', '\\0']), ('\\u{16e7b}', ['\\u{16e5b}', '\\0', '\\0']),\n        ('\\u{16e7c}', ['\\u{16e5c}', '\\0', '\\0']), ('\\u{16e7d}', ['\\u{16e5d}', '\\0', '\\0']),\n        ('\\u{16e7e}', ['\\u{16e5e}', '\\0', '\\0']), ('\\u{16e7f}', ['\\u{16e5f}', '\\0', '\\0']),\n        ('\\u{1e922}', ['\\u{1e900}', '\\0', '\\0']), ('\\u{1e923}', ['\\u{1e901}', '\\0', '\\0']),\n        ('\\u{1e924}', ['\\u{1e902}', '\\0', '\\0']), ('\\u{1e925}', ['\\u{1e903}', '\\0', '\\0']),\n        ('\\u{1e926}', ['\\u{1e904}', '\\0', '\\0']), ('\\u{1e927}', ['\\u{1e905}', '\\0', '\\0']),\n        ('\\u{1e928}', ['\\u{1e906}', '\\0', '\\0']), ('\\u{1e929}', ['\\u{1e907}', '\\0', '\\0']),\n        ('\\u{1e92a}', ['\\u{1e908}', '\\0', '\\0']), ('\\u{1e92b}', ['\\u{1e909}', '\\0', '\\0']),\n        ('\\u{1e92c}', ['\\u{1e90a}', '\\0', '\\0']), ('\\u{1e92d}', ['\\u{1e90b}', '\\0', '\\0']),\n        ('\\u{1e92e}', ['\\u{1e90c}', '\\0', '\\0']), ('\\u{1e92f}', ['\\u{1e90d}', '\\0', '\\0']),\n        ('\\u{1e930}', ['\\u{1e90e}', '\\0', '\\0']), ('\\u{1e931}', ['\\u{1e90f}', '\\0', '\\0']),\n        ('\\u{1e932}', ['\\u{1e910}', '\\0', '\\0']), ('\\u{1e933}', ['\\u{1e911}', '\\0', '\\0']),\n        ('\\u{1e934}', ['\\u{1e912}', '\\0', '\\0']), ('\\u{1e935}', ['\\u{1e913}', '\\0', '\\0']),\n        ('\\u{1e936}', ['\\u{1e914}', '\\0', '\\0']), ('\\u{1e937}', ['\\u{1e915}', '\\0', '\\0']),\n        ('\\u{1e938}', ['\\u{1e916}', '\\0', '\\0']), ('\\u{1e939}', ['\\u{1e917}', '\\0', '\\0']),\n        ('\\u{1e93a}', ['\\u{1e918}', '\\0', '\\0']), ('\\u{1e93b}', ['\\u{1e919}', '\\0', '\\0']),\n        ('\\u{1e93c}', ['\\u{1e91a}', '\\0', '\\0']), ('\\u{1e93d}', ['\\u{1e91b}', '\\0', '\\0']),\n        ('\\u{1e93e}', ['\\u{1e91c}', '\\0', '\\0']), ('\\u{1e93f}', ['\\u{1e91d}', '\\0', '\\0']),\n        ('\\u{1e940}', ['\\u{1e91e}', '\\0', '\\0']), ('\\u{1e941}', ['\\u{1e91f}', '\\0', '\\0']),\n        ('\\u{1e942}', ['\\u{1e920}', '\\0', '\\0']), ('\\u{1e943}', ['\\u{1e921}', '\\0', '\\0'])\n    ];\n\n}\n\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A character type.\n//!\n//! The `char` type represents a single character. More specifically, since\n//! 'character' isn't a well-defined concept in Unicode, `char` is a '[Unicode\n//! scalar value]', which is similar to, but not the same as, a '[Unicode code\n//! point]'.\n//!\n//! [Unicode scalar value]: http://www.unicode.org/glossary/#unicode_scalar_value\n//! [Unicode code point]: http://www.unicode.org/glossary/#code_point\n//!\n//! This module exists for technical reasons, the primary documentation for\n//! `char` is directly on [the `char` primitive type](../../std/primitive.char.html)\n//! itself.\n//!\n//! This module is the home of the iterator implementations for the iterators\n//! implemented on `char`, as well as some useful constants and conversion\n//! functions that convert various types to `char`.\n\n#![allow(non_snake_case)]\n#![stable(feature = \"core_char\", since = \"1.2.0\")]\n\nmod convert;\nmod decode;\nmod methods;\n\n// stable re-exports\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::convert::{from_u32, from_digit};\n#[stable(feature = \"char_from_unchecked\", since = \"1.5.0\")]\npub use self::convert::from_u32_unchecked;\n#[stable(feature = \"char_from_str\", since = \"1.20.0\")]\npub use self::convert::ParseCharError;\n#[unstable(feature = \"try_from\", issue = \"33417\")]\npub use self::convert::CharTryFromError;\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\npub use self::decode::{decode_utf16, DecodeUtf16, DecodeUtf16Error};\n\n// unstable re-exports\n#[unstable(feature = \"unicode_version\", issue = \"49726\")]\npub use unicode::tables::UNICODE_VERSION;\n#[unstable(feature = \"unicode_version\", issue = \"49726\")]\npub use unicode::version::UnicodeVersion;\n\nuse fmt::{self, Write};\nuse iter::FusedIterator;\n\n// UTF-8 ranges and tags for encoding characters\nconst TAG_CONT: u8     = 0b1000_0000;\nconst TAG_TWO_B: u8    = 0b1100_0000;\nconst TAG_THREE_B: u8  = 0b1110_0000;\nconst TAG_FOUR_B: u8   = 0b1111_0000;\nconst MAX_ONE_B: u32   =     0x80;\nconst MAX_TWO_B: u32   =    0x800;\nconst MAX_THREE_B: u32 =  0x10000;\n\n/*\n    Lu  Uppercase_Letter        an uppercase letter\n    Ll  Lowercase_Letter        a lowercase letter\n    Lt  Titlecase_Letter        a digraphic character, with first part uppercase\n    Lm  Modifier_Letter         a modifier letter\n    Lo  Other_Letter            other letters, including syllables and ideographs\n    Mn  Nonspacing_Mark         a nonspacing combining mark (zero advance width)\n    Mc  Spacing_Mark            a spacing combining mark (positive advance width)\n    Me  Enclosing_Mark          an enclosing combining mark\n    Nd  Decimal_Number          a decimal digit\n    Nl  Letter_Number           a letterlike numeric character\n    No  Other_Number            a numeric character of other type\n    Pc  Connector_Punctuation   a connecting punctuation mark, like a tie\n    Pd  Dash_Punctuation        a dash or hyphen punctuation mark\n    Ps  Open_Punctuation        an opening punctuation mark (of a pair)\n    Pe  Close_Punctuation       a closing punctuation mark (of a pair)\n    Pi  Initial_Punctuation     an initial quotation mark\n    Pf  Final_Punctuation       a final quotation mark\n    Po  Other_Punctuation       a punctuation mark of other type\n    Sm  Math_Symbol             a symbol of primarily mathematical use\n    Sc  Currency_Symbol         a currency sign\n    Sk  Modifier_Symbol         a non-letterlike modifier symbol\n    So  Other_Symbol            a symbol of other type\n    Zs  Space_Separator         a space character (of various non-zero widths)\n    Zl  Line_Separator          U+2028 LINE SEPARATOR only\n    Zp  Paragraph_Separator     U+2029 PARAGRAPH SEPARATOR only\n    Cc  Control                 a C0 or C1 control code\n    Cf  Format                  a format control character\n    Cs  Surrogate               a surrogate code point\n    Co  Private_Use             a private-use character\n    Cn  Unassigned              a reserved unassigned code point or a noncharacter\n*/\n\n/// The highest valid code point a `char` can have.\n///\n/// A [`char`] is a [Unicode Scalar Value], which means that it is a [Code\n/// Point], but only ones within a certain range. `MAX` is the highest valid\n/// code point that's a valid [Unicode Scalar Value].\n///\n/// [`char`]: ../../std/primitive.char.html\n/// [Unicode Scalar Value]: http://www.unicode.org/glossary/#unicode_scalar_value\n/// [Code Point]: http://www.unicode.org/glossary/#code_point\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX: char = '\\u{10ffff}';\n\n/// `U+FFFD REPLACEMENT CHARACTER` (\ufffd) is used in Unicode to represent a\n/// decoding error.\n///\n/// It can occur, for example, when giving ill-formed UTF-8 bytes to\n/// [`String::from_utf8_lossy`](../../std/string/struct.String.html#method.from_utf8_lossy).\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\npub const REPLACEMENT_CHARACTER: char = '\\u{FFFD}';\n\n/// Returns an iterator that yields the hexadecimal Unicode escape of a\n/// character, as `char`s.\n///\n/// This `struct` is created by the [`escape_unicode`] method on [`char`]. See\n/// its documentation for more.\n///\n/// [`escape_unicode`]: ../../std/primitive.char.html#method.escape_unicode\n/// [`char`]: ../../std/primitive.char.html\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct EscapeUnicode {\n    c: char,\n    state: EscapeUnicodeState,\n\n    // The index of the next hex digit to be printed (0 if none),\n    // i.e. the number of remaining hex digits to be printed;\n    // increasing from the least significant digit: 0x543210\n    hex_digit_idx: usize,\n}\n\n// The enum values are ordered so that their representation is the\n// same as the remaining length (besides the hexadecimal digits). This\n// likely makes `len()` a single load from memory) and inline-worth.\n#[derive(Clone, Debug)]\nenum EscapeUnicodeState {\n    Done,\n    RightBrace,\n    Value,\n    LeftBrace,\n    Type,\n    Backslash,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for EscapeUnicode {\n    type Item = char;\n\n    fn next(&mut self) -> Option<char> {\n        match self.state {\n            EscapeUnicodeState::Backslash => {\n                self.state = EscapeUnicodeState::Type;\n                Some('\\\\')\n            }\n            EscapeUnicodeState::Type => {\n                self.state = EscapeUnicodeState::LeftBrace;\n                Some('u')\n            }\n            EscapeUnicodeState::LeftBrace => {\n                self.state = EscapeUnicodeState::Value;\n                Some('{')\n            }\n            EscapeUnicodeState::Value => {\n                let hex_digit = ((self.c as u32) >> (self.hex_digit_idx * 4)) & 0xf;\n                let c = from_digit(hex_digit, 16).unwrap();\n                if self.hex_digit_idx == 0 {\n                    self.state = EscapeUnicodeState::RightBrace;\n                } else {\n                    self.hex_digit_idx -= 1;\n                }\n                Some(c)\n            }\n            EscapeUnicodeState::RightBrace => {\n                self.state = EscapeUnicodeState::Done;\n                Some('}')\n            }\n            EscapeUnicodeState::Done => None,\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.len();\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    fn last(self) -> Option<char> {\n        match self.state {\n            EscapeUnicodeState::Done => None,\n\n            EscapeUnicodeState::RightBrace |\n            EscapeUnicodeState::Value |\n            EscapeUnicodeState::LeftBrace |\n            EscapeUnicodeState::Type |\n            EscapeUnicodeState::Backslash => Some('}'),\n        }\n    }\n}\n\n#[stable(feature = \"exact_size_escape\", since = \"1.11.0\")]\nimpl ExactSizeIterator for EscapeUnicode {\n    #[inline]\n    fn len(&self) -> usize {\n        // The match is a single memory access with no branching\n        self.hex_digit_idx + match self.state {\n            EscapeUnicodeState::Done => 0,\n            EscapeUnicodeState::RightBrace => 1,\n            EscapeUnicodeState::Value => 2,\n            EscapeUnicodeState::LeftBrace => 3,\n            EscapeUnicodeState::Type => 4,\n            EscapeUnicodeState::Backslash => 5,\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for EscapeUnicode {}\n\n#[stable(feature = \"char_struct_display\", since = \"1.16.0\")]\nimpl fmt::Display for EscapeUnicode {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        for c in self.clone() {\n            f.write_char(c)?;\n        }\n        Ok(())\n    }\n}\n\n/// An iterator that yields the literal escape code of a `char`.\n///\n/// This `struct` is created by the [`escape_default`] method on [`char`]. See\n/// its documentation for more.\n///\n/// [`escape_default`]: ../../std/primitive.char.html#method.escape_default\n/// [`char`]: ../../std/primitive.char.html\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct EscapeDefault {\n    state: EscapeDefaultState\n}\n\n#[derive(Clone, Debug)]\nenum EscapeDefaultState {\n    Done,\n    Char(char),\n    Backslash(char),\n    Unicode(EscapeUnicode),\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for EscapeDefault {\n    type Item = char;\n\n    fn next(&mut self) -> Option<char> {\n        match self.state {\n            EscapeDefaultState::Backslash(c) => {\n                self.state = EscapeDefaultState::Char(c);\n                Some('\\\\')\n            }\n            EscapeDefaultState::Char(c) => {\n                self.state = EscapeDefaultState::Done;\n                Some(c)\n            }\n            EscapeDefaultState::Done => None,\n            EscapeDefaultState::Unicode(ref mut iter) => iter.next(),\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let n = self.len();\n        (n, Some(n))\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.len()\n    }\n\n    fn nth(&mut self, n: usize) -> Option<char> {\n        match self.state {\n            EscapeDefaultState::Backslash(c) if n == 0 => {\n                self.state = EscapeDefaultState::Char(c);\n                Some('\\\\')\n            },\n            EscapeDefaultState::Backslash(c) if n == 1 => {\n                self.state = EscapeDefaultState::Done;\n                Some(c)\n            },\n            EscapeDefaultState::Backslash(_) => {\n                self.state = EscapeDefaultState::Done;\n                None\n            },\n            EscapeDefaultState::Char(c) => {\n                self.state = EscapeDefaultState::Done;\n\n                if n == 0 {\n                    Some(c)\n                } else {\n                    None\n                }\n            },\n            EscapeDefaultState::Done => None,\n            EscapeDefaultState::Unicode(ref mut i) => i.nth(n),\n        }\n    }\n\n    fn last(self) -> Option<char> {\n        match self.state {\n            EscapeDefaultState::Unicode(iter) => iter.last(),\n            EscapeDefaultState::Done => None,\n            EscapeDefaultState::Backslash(c) | EscapeDefaultState::Char(c) => Some(c),\n        }\n    }\n}\n\n#[stable(feature = \"exact_size_escape\", since = \"1.11.0\")]\nimpl ExactSizeIterator for EscapeDefault {\n    fn len(&self) -> usize {\n        match self.state {\n            EscapeDefaultState::Done => 0,\n            EscapeDefaultState::Char(_) => 1,\n            EscapeDefaultState::Backslash(_) => 2,\n            EscapeDefaultState::Unicode(ref iter) => iter.len(),\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for EscapeDefault {}\n\n#[stable(feature = \"char_struct_display\", since = \"1.16.0\")]\nimpl fmt::Display for EscapeDefault {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        for c in self.clone() {\n            f.write_char(c)?;\n        }\n        Ok(())\n    }\n}\n\n/// An iterator that yields the literal escape code of a `char`.\n///\n/// This `struct` is created by the [`escape_debug`] method on [`char`]. See its\n/// documentation for more.\n///\n/// [`escape_debug`]: ../../std/primitive.char.html#method.escape_debug\n/// [`char`]: ../../std/primitive.char.html\n#[stable(feature = \"char_escape_debug\", since = \"1.20.0\")]\n#[derive(Clone, Debug)]\npub struct EscapeDebug(EscapeDefault);\n\n#[stable(feature = \"char_escape_debug\", since = \"1.20.0\")]\nimpl Iterator for EscapeDebug {\n    type Item = char;\n    fn next(&mut self) -> Option<char> { self.0.next() }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.0.size_hint() }\n}\n\n#[stable(feature = \"char_escape_debug\", since = \"1.20.0\")]\nimpl ExactSizeIterator for EscapeDebug { }\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for EscapeDebug {}\n\n#[stable(feature = \"char_escape_debug\", since = \"1.20.0\")]\nimpl fmt::Display for EscapeDebug {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&self.0, f)\n    }\n}\n\n/// Returns an iterator that yields the lowercase equivalent of a `char`.\n///\n/// This `struct` is created by the [`to_lowercase`] method on [`char`]. See\n/// its documentation for more.\n///\n/// [`to_lowercase`]: ../../std/primitive.char.html#method.to_lowercase\n/// [`char`]: ../../std/primitive.char.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug, Clone)]\npub struct ToLowercase(CaseMappingIter);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for ToLowercase {\n    type Item = char;\n    fn next(&mut self) -> Option<char> {\n        self.0.next()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for ToLowercase {}\n\n/// Returns an iterator that yields the uppercase equivalent of a `char`.\n///\n/// This `struct` is created by the [`to_uppercase`] method on [`char`]. See\n/// its documentation for more.\n///\n/// [`to_uppercase`]: ../../std/primitive.char.html#method.to_uppercase\n/// [`char`]: ../../std/primitive.char.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug, Clone)]\npub struct ToUppercase(CaseMappingIter);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for ToUppercase {\n    type Item = char;\n    fn next(&mut self) -> Option<char> {\n        self.0.next()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for ToUppercase {}\n\n#[derive(Debug, Clone)]\nenum CaseMappingIter {\n    Three(char, char, char),\n    Two(char, char),\n    One(char),\n    Zero,\n}\n\nimpl CaseMappingIter {\n    fn new(chars: [char; 3]) -> CaseMappingIter {\n        if chars[2] == '\\0' {\n            if chars[1] == '\\0' {\n                CaseMappingIter::One(chars[0])  // Including if chars[0] == '\\0'\n            } else {\n                CaseMappingIter::Two(chars[0], chars[1])\n            }\n        } else {\n            CaseMappingIter::Three(chars[0], chars[1], chars[2])\n        }\n    }\n}\n\nimpl Iterator for CaseMappingIter {\n    type Item = char;\n    fn next(&mut self) -> Option<char> {\n        match *self {\n            CaseMappingIter::Three(a, b, c) => {\n                *self = CaseMappingIter::Two(b, c);\n                Some(a)\n            }\n            CaseMappingIter::Two(b, c) => {\n                *self = CaseMappingIter::One(c);\n                Some(b)\n            }\n            CaseMappingIter::One(c) => {\n                *self = CaseMappingIter::Zero;\n                Some(c)\n            }\n            CaseMappingIter::Zero => None,\n        }\n    }\n}\n\nimpl fmt::Display for CaseMappingIter {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            CaseMappingIter::Three(a, b, c) => {\n                f.write_char(a)?;\n                f.write_char(b)?;\n                f.write_char(c)\n            }\n            CaseMappingIter::Two(b, c) => {\n                f.write_char(b)?;\n                f.write_char(c)\n            }\n            CaseMappingIter::One(c) => {\n                f.write_char(c)\n            }\n            CaseMappingIter::Zero => Ok(()),\n        }\n    }\n}\n\n#[stable(feature = \"char_struct_display\", since = \"1.16.0\")]\nimpl fmt::Display for ToLowercase {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&self.0, f)\n    }\n}\n\n#[stable(feature = \"char_struct_display\", since = \"1.16.0\")]\nimpl fmt::Display for ToUppercase {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&self.0, f)\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Character conversions.\n\nuse convert::TryFrom;\nuse fmt;\nuse mem::transmute;\nuse str::FromStr;\nuse super::MAX;\n\n/// Converts a `u32` to a `char`.\n///\n/// Note that all [`char`]s are valid [`u32`]s, and can be cast to one with\n/// [`as`]:\n///\n/// ```\n/// let c = '\ud83d\udcaf';\n/// let i = c as u32;\n///\n/// assert_eq!(128175, i);\n/// ```\n///\n/// However, the reverse is not true: not all valid [`u32`]s are valid\n/// [`char`]s. `from_u32()` will return `None` if the input is not a valid value\n/// for a [`char`].\n///\n/// [`char`]: ../../std/primitive.char.html\n/// [`u32`]: ../../std/primitive.u32.html\n/// [`as`]: ../../book/first-edition/casting-between-types.html#as\n///\n/// For an unsafe version of this function which ignores these checks, see\n/// [`from_u32_unchecked`].\n///\n/// [`from_u32_unchecked`]: fn.from_u32_unchecked.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::char;\n///\n/// let c = char::from_u32(0x2764);\n///\n/// assert_eq!(Some('\u2764'), c);\n/// ```\n///\n/// Returning `None` when the input is not a valid [`char`]:\n///\n/// ```\n/// use std::char;\n///\n/// let c = char::from_u32(0x110000);\n///\n/// assert_eq!(None, c);\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn from_u32(i: u32) -> Option<char> {\n    char::try_from(i).ok()\n}\n\n/// Converts a `u32` to a `char`, ignoring validity.\n///\n/// Note that all [`char`]s are valid [`u32`]s, and can be cast to one with\n/// [`as`]:\n///\n/// ```\n/// let c = '\ud83d\udcaf';\n/// let i = c as u32;\n///\n/// assert_eq!(128175, i);\n/// ```\n///\n/// However, the reverse is not true: not all valid [`u32`]s are valid\n/// [`char`]s. `from_u32_unchecked()` will ignore this, and blindly cast to\n/// [`char`], possibly creating an invalid one.\n///\n/// [`char`]: ../../std/primitive.char.html\n/// [`u32`]: ../../std/primitive.u32.html\n/// [`as`]: ../../book/first-edition/casting-between-types.html#as\n///\n/// # Safety\n///\n/// This function is unsafe, as it may construct invalid `char` values.\n///\n/// For a safe version of this function, see the [`from_u32`] function.\n///\n/// [`from_u32`]: fn.from_u32.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::char;\n///\n/// let c = unsafe { char::from_u32_unchecked(0x2764) };\n///\n/// assert_eq!('\u2764', c);\n/// ```\n#[inline]\n#[stable(feature = \"char_from_unchecked\", since = \"1.5.0\")]\npub unsafe fn from_u32_unchecked(i: u32) -> char {\n    transmute(i)\n}\n\n#[stable(feature = \"char_convert\", since = \"1.13.0\")]\nimpl From<char> for u32 {\n    /// Converts a [`char`] into a [`u32`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::mem;\n    ///\n    /// fn main() {\n    ///     let c = 'c';\n    ///     let u = u32::from(c);\n    ///     assert!(4 == mem::size_of_val(&u))\n    /// }\n    /// ```\n    #[inline]\n    fn from(c: char) -> Self {\n        c as u32\n    }\n}\n\n/// Maps a byte in 0x00...0xFF to a `char` whose code point has the same value, in U+0000 to U+00FF.\n///\n/// Unicode is designed such that this effectively decodes bytes\n/// with the character encoding that IANA calls ISO-8859-1.\n/// This encoding is compatible with ASCII.\n///\n/// Note that this is different from ISO/IEC 8859-1 a.k.a. ISO 8859-1 (with one less hyphen),\n/// which leaves some \"blanks\", byte values that are not assigned to any character.\n/// ISO-8859-1 (the IANA one) assigns them to the C0 and C1 control codes.\n///\n/// Note that this is *also* different from Windows-1252 a.k.a. code page 1252,\n/// which is a superset ISO/IEC 8859-1 that assigns some (not all!) blanks\n/// to punctuation and various Latin characters.\n///\n/// To confuse things further, [on the Web](https://encoding.spec.whatwg.org/)\n/// `ascii`, `iso-8859-1`, and `windows-1252` are all aliases\n/// for a superset of Windows-1252 that fills the remaining blanks with corresponding\n/// C0 and C1 control codes.\n#[stable(feature = \"char_convert\", since = \"1.13.0\")]\nimpl From<u8> for char {\n    /// Converts a [`u8`] into a [`char`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::mem;\n    ///\n    /// fn main() {\n    ///     let u = 32 as u8;\n    ///     let c = char::from(u);\n    ///     assert!(4 == mem::size_of_val(&c))\n    /// }\n    /// ```\n    #[inline]\n    fn from(i: u8) -> Self {\n        i as char\n    }\n}\n\n\n/// An error which can be returned when parsing a char.\n#[stable(feature = \"char_from_str\", since = \"1.20.0\")]\n#[derive(Clone, Debug, PartialEq, Eq)]\npub struct ParseCharError {\n    kind: CharErrorKind,\n}\n\nimpl ParseCharError {\n    #[unstable(feature = \"char_error_internals\",\n               reason = \"this method should not be available publicly\",\n               issue = \"0\")]\n    #[doc(hidden)]\n    pub fn __description(&self) -> &str {\n        match self.kind {\n            CharErrorKind::EmptyString => {\n                \"cannot parse char from empty string\"\n            },\n            CharErrorKind::TooManyChars => \"too many characters in string\"\n        }\n    }\n}\n\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\nenum CharErrorKind {\n    EmptyString,\n    TooManyChars,\n}\n\n#[stable(feature = \"char_from_str\", since = \"1.20.0\")]\nimpl fmt::Display for ParseCharError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.__description().fmt(f)\n    }\n}\n\n\n#[stable(feature = \"char_from_str\", since = \"1.20.0\")]\nimpl FromStr for char {\n    type Err = ParseCharError;\n\n    #[inline]\n    fn from_str(s: &str) -> Result<Self, Self::Err> {\n        let mut chars = s.chars();\n        match (chars.next(), chars.next()) {\n            (None, _) => {\n                Err(ParseCharError { kind: CharErrorKind::EmptyString })\n            },\n            (Some(c), None) => Ok(c),\n            _ => {\n                Err(ParseCharError { kind: CharErrorKind::TooManyChars })\n            }\n        }\n    }\n}\n\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl TryFrom<u32> for char {\n    type Error = CharTryFromError;\n\n    #[inline]\n    fn try_from(i: u32) -> Result<Self, Self::Error> {\n        if (i > MAX as u32) || (i >= 0xD800 && i <= 0xDFFF) {\n            Err(CharTryFromError(()))\n        } else {\n            Ok(unsafe { from_u32_unchecked(i) })\n        }\n    }\n}\n\n/// The error type returned when a conversion from u32 to char fails.\n#[unstable(feature = \"try_from\", issue = \"33417\")]\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub struct CharTryFromError(());\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl fmt::Display for CharTryFromError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        \"converted integer out of range for `char`\".fmt(f)\n    }\n}\n\n/// Converts a digit in the given radix to a `char`.\n///\n/// A 'radix' here is sometimes also called a 'base'. A radix of two\n/// indicates a binary number, a radix of ten, decimal, and a radix of\n/// sixteen, hexadecimal, to give some common values. Arbitrary\n/// radices are supported.\n///\n/// `from_digit()` will return `None` if the input is not a digit in\n/// the given radix.\n///\n/// # Panics\n///\n/// Panics if given a radix larger than 36.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::char;\n///\n/// let c = char::from_digit(4, 10);\n///\n/// assert_eq!(Some('4'), c);\n///\n/// // Decimal 11 is a single digit in base 16\n/// let c = char::from_digit(11, 16);\n///\n/// assert_eq!(Some('b'), c);\n/// ```\n///\n/// Returning `None` when the input is not a digit:\n///\n/// ```\n/// use std::char;\n///\n/// let c = char::from_digit(20, 10);\n///\n/// assert_eq!(None, c);\n/// ```\n///\n/// Passing a large radix, causing a panic:\n///\n/// ```\n/// use std::thread;\n/// use std::char;\n///\n/// let result = thread::spawn(|| {\n///     // this panics\n///     let c = char::from_digit(1, 37);\n/// }).join();\n///\n/// assert!(result.is_err());\n/// ```\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn from_digit(num: u32, radix: u32) -> Option<char> {\n    if radix > 36 {\n        panic!(\"from_digit: radix is too high (maximum 36)\");\n    }\n    if num < radix {\n        let num = num as u8;\n        if num < 10 {\n            Some((b'0' + num) as char)\n        } else {\n            Some((b'a' + num - 10) as char)\n        }\n    } else {\n        None\n    }\n}\n\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! The string Pattern API.\n//!\n//! For more details, see the traits `Pattern`, `Searcher`,\n//! `ReverseSearcher` and `DoubleEndedSearcher`.\n\n#![unstable(feature = \"pattern\",\n            reason = \"API not fully fleshed out and ready to be stabilized\",\n            issue = \"27721\")]\n\nuse cmp;\nuse fmt;\nuse slice::memchr;\nuse usize;\n\n// Pattern\n\n/// A string pattern.\n///\n/// A `Pattern<'a>` expresses that the implementing type\n/// can be used as a string pattern for searching in a `&'a str`.\n///\n/// For example, both `'a'` and `\"aa\"` are patterns that\n/// would match at index `1` in the string `\"baaaab\"`.\n///\n/// The trait itself acts as a builder for an associated\n/// `Searcher` type, which does the actual work of finding\n/// occurrences of the pattern in a string.\npub trait Pattern<'a>: Sized {\n    /// Associated searcher for this pattern\n    type Searcher: Searcher<'a>;\n\n    /// Constructs the associated searcher from\n    /// `self` and the `haystack` to search in.\n    fn into_searcher(self, haystack: &'a str) -> Self::Searcher;\n\n    /// Checks whether the pattern matches anywhere in the haystack\n    #[inline]\n    fn is_contained_in(self, haystack: &'a str) -> bool {\n        self.into_searcher(haystack).next_match().is_some()\n    }\n\n    /// Checks whether the pattern matches at the front of the haystack\n    #[inline]\n    fn is_prefix_of(self, haystack: &'a str) -> bool {\n        match self.into_searcher(haystack).next() {\n            SearchStep::Match(0, _) => true,\n            _ => false,\n        }\n    }\n\n    /// Checks whether the pattern matches at the back of the haystack\n    #[inline]\n    fn is_suffix_of(self, haystack: &'a str) -> bool\n        where Self::Searcher: ReverseSearcher<'a>\n    {\n        match self.into_searcher(haystack).next_back() {\n            SearchStep::Match(_, j) if haystack.len() == j => true,\n            _ => false,\n        }\n    }\n}\n\n// Searcher\n\n/// Result of calling `Searcher::next()` or `ReverseSearcher::next_back()`.\n#[derive(Copy, Clone, Eq, PartialEq, Debug)]\npub enum SearchStep {\n    /// Expresses that a match of the pattern has been found at\n    /// `haystack[a..b]`.\n    Match(usize, usize),\n    /// Expresses that `haystack[a..b]` has been rejected as a possible match\n    /// of the pattern.\n    ///\n    /// Note that there might be more than one `Reject` between two `Match`es,\n    /// there is no requirement for them to be combined into one.\n    Reject(usize, usize),\n    /// Expresses that every byte of the haystack has been visited, ending\n    /// the iteration.\n    Done\n}\n\n/// A searcher for a string pattern.\n///\n/// This trait provides methods for searching for non-overlapping\n/// matches of a pattern starting from the front (left) of a string.\n///\n/// It will be implemented by associated `Searcher`\n/// types of the `Pattern` trait.\n///\n/// The trait is marked unsafe because the indices returned by the\n/// `next()` methods are required to lie on valid utf8 boundaries in\n/// the haystack. This enables consumers of this trait to\n/// slice the haystack without additional runtime checks.\npub unsafe trait Searcher<'a> {\n    /// Getter for the underlying string to be searched in\n    ///\n    /// Will always return the same `&str`\n    fn haystack(&self) -> &'a str;\n\n    /// Performs the next search step starting from the front.\n    ///\n    /// - Returns `Match(a, b)` if `haystack[a..b]` matches the pattern.\n    /// - Returns `Reject(a, b)` if `haystack[a..b]` can not match the\n    ///   pattern, even partially.\n    /// - Returns `Done` if every byte of the haystack has been visited\n    ///\n    /// The stream of `Match` and `Reject` values up to a `Done`\n    /// will contain index ranges that are adjacent, non-overlapping,\n    /// covering the whole haystack, and laying on utf8 boundaries.\n    ///\n    /// A `Match` result needs to contain the whole matched pattern,\n    /// however `Reject` results may be split up into arbitrary\n    /// many adjacent fragments. Both ranges may have zero length.\n    ///\n    /// As an example, the pattern `\"aaa\"` and the haystack `\"cbaaaaab\"`\n    /// might produce the stream\n    /// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`\n    fn next(&mut self) -> SearchStep;\n\n    /// Find the next `Match` result. See `next()`\n    ///\n    /// Unlike next(), there is no guarantee that the returned ranges\n    /// of this and next_reject will overlap. This will return (start_match, end_match),\n    /// where start_match is the index of where the match begins, and end_match is\n    /// the index after the end of the match.\n    #[inline]\n    fn next_match(&mut self) -> Option<(usize, usize)> {\n        loop {\n            match self.next() {\n                SearchStep::Match(a, b) => return Some((a, b)),\n                SearchStep::Done => return None,\n                _ => continue,\n            }\n        }\n    }\n\n    /// Find the next `Reject` result. See `next()` and `next_match()`\n    ///\n    /// Unlike next(), there is no guarantee that the returned ranges\n    /// of this and next_match will overlap.\n    #[inline]\n    fn next_reject(&mut self) -> Option<(usize, usize)> {\n        loop {\n            match self.next() {\n                SearchStep::Reject(a, b) => return Some((a, b)),\n                SearchStep::Done => return None,\n                _ => continue,\n            }\n        }\n    }\n}\n\n/// A reverse searcher for a string pattern.\n///\n/// This trait provides methods for searching for non-overlapping\n/// matches of a pattern starting from the back (right) of a string.\n///\n/// It will be implemented by associated `Searcher`\n/// types of the `Pattern` trait if the pattern supports searching\n/// for it from the back.\n///\n/// The index ranges returned by this trait are not required\n/// to exactly match those of the forward search in reverse.\n///\n/// For the reason why this trait is marked unsafe, see them\n/// parent trait `Searcher`.\npub unsafe trait ReverseSearcher<'a>: Searcher<'a> {\n    /// Performs the next search step starting from the back.\n    ///\n    /// - Returns `Match(a, b)` if `haystack[a..b]` matches the pattern.\n    /// - Returns `Reject(a, b)` if `haystack[a..b]` can not match the\n    ///   pattern, even partially.\n    /// - Returns `Done` if every byte of the haystack has been visited\n    ///\n    /// The stream of `Match` and `Reject` values up to a `Done`\n    /// will contain index ranges that are adjacent, non-overlapping,\n    /// covering the whole haystack, and laying on utf8 boundaries.\n    ///\n    /// A `Match` result needs to contain the whole matched pattern,\n    /// however `Reject` results may be split up into arbitrary\n    /// many adjacent fragments. Both ranges may have zero length.\n    ///\n    /// As an example, the pattern `\"aaa\"` and the haystack `\"cbaaaaab\"`\n    /// might produce the stream\n    /// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`\n    fn next_back(&mut self) -> SearchStep;\n\n    /// Find the next `Match` result. See `next_back()`\n    #[inline]\n    fn next_match_back(&mut self) -> Option<(usize, usize)>{\n        loop {\n            match self.next_back() {\n                SearchStep::Match(a, b) => return Some((a, b)),\n                SearchStep::Done => return None,\n                _ => continue,\n            }\n        }\n    }\n\n    /// Find the next `Reject` result. See `next_back()`\n    #[inline]\n    fn next_reject_back(&mut self) -> Option<(usize, usize)>{\n        loop {\n            match self.next_back() {\n                SearchStep::Reject(a, b) => return Some((a, b)),\n                SearchStep::Done => return None,\n                _ => continue,\n            }\n        }\n    }\n}\n\n/// A marker trait to express that a `ReverseSearcher`\n/// can be used for a `DoubleEndedIterator` implementation.\n///\n/// For this, the impl of `Searcher` and `ReverseSearcher` need\n/// to follow these conditions:\n///\n/// - All results of `next()` need to be identical\n///   to the results of `next_back()` in reverse order.\n/// - `next()` and `next_back()` need to behave as\n///   the two ends of a range of values, that is they\n///   can not \"walk past each other\".\n///\n/// # Examples\n///\n/// `char::Searcher` is a `DoubleEndedSearcher` because searching for a\n/// `char` only requires looking at one at a time, which behaves the same\n/// from both ends.\n///\n/// `(&str)::Searcher` is not a `DoubleEndedSearcher` because\n/// the pattern `\"aa\"` in the haystack `\"aaa\"` matches as either\n/// `\"[aa]a\"` or `\"a[aa]\"`, depending from which side it is searched.\npub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {}\n\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for char\n/////////////////////////////////////////////////////////////////////////////\n\n/// Associated type for `<char as Pattern<'a>>::Searcher`.\n#[derive(Clone, Debug)]\npub struct CharSearcher<'a> {\n    haystack: &'a str,\n    // safety invariant: `finger`/`finger_back` must be a valid utf8 byte index of `haystack`\n    // This invariant can be broken *within* next_match and next_match_back, however\n    // they must exit with fingers on valid code point boundaries.\n\n    /// `finger` is the current byte index of the forward search.\n    /// Imagine that it exists before the byte at its index, i.e.\n    /// `haystack[finger]` is the first byte of the slice we must inspect during\n    /// forward searching\n    finger: usize,\n    /// `finger_back` is the current byte index of the reverse search.\n    /// Imagine that it exists after the byte at its index, i.e.\n    /// haystack[finger_back - 1] is the last byte of the slice we must inspect during\n    /// forward searching (and thus the first byte to be inspected when calling next_back())\n    finger_back: usize,\n    /// The character being searched for\n    needle: char,\n\n    // safety invariant: `utf8_size` must be less than 5\n    /// The number of bytes `needle` takes up when encoded in utf8\n    utf8_size: usize,\n    /// A utf8 encoded copy of the `needle`\n    utf8_encoded: [u8; 4],\n}\n\nunsafe impl<'a> Searcher<'a> for CharSearcher<'a> {\n    #[inline]\n    fn haystack(&self) -> &'a str {\n        self.haystack\n    }\n    #[inline]\n    fn next(&mut self) -> SearchStep {\n        let old_finger = self.finger;\n        let slice = unsafe { self.haystack.get_unchecked(old_finger..self.finger_back) };\n        let mut iter = slice.chars();\n        let old_len = iter.iter.len();\n        if let Some(ch) = iter.next() {\n            // add byte offset of current character\n            // without re-encoding as utf-8\n            self.finger += old_len - iter.iter.len();\n            if ch == self.needle {\n                SearchStep::Match(old_finger, self.finger)\n            } else {\n                SearchStep::Reject(old_finger, self.finger)\n            }\n        } else {\n            SearchStep::Done\n        }\n    }\n    #[inline]\n    fn next_match(&mut self) -> Option<(usize, usize)> {\n        loop {\n            // get the haystack after the last character found\n            let bytes = if let Some(slice) = self.haystack.as_bytes()\n                                                 .get(self.finger..self.finger_back) {\n                slice\n            } else {\n                return None;\n            };\n            // the last byte of the utf8 encoded needle\n            let last_byte = unsafe { *self.utf8_encoded.get_unchecked(self.utf8_size - 1) };\n            if let Some(index) = memchr::memchr(last_byte, bytes) {\n                // The new finger is the index of the byte we found,\n                // plus one, since we memchr'd for the last byte of the character.\n                //\n                // Note that this doesn't always give us a finger on a UTF8 boundary.\n                // If we *didn't* find our character\n                // we may have indexed to the non-last byte of a 3-byte or 4-byte character.\n                // We can't just skip to the next valid starting byte because a character like\n                // \ua041 (U+A041 YI SYLLABLE PA), utf-8 `EA 81 81` will have us always find\n                // the second byte when searching for the third.\n                //\n                // However, this is totally okay. While we have the invariant that\n                // self.finger is on a UTF8 boundary, this invariant is not relied upon\n                // within this method (it is relied upon in CharSearcher::next()).\n                //\n                // We only exit this method when we reach the end of the string, or if we\n                // find something. When we find something the `finger` will be set\n                // to a UTF8 boundary.\n                self.finger += index + 1;\n                if self.finger >= self.utf8_size {\n                    let found_char = self.finger - self.utf8_size;\n                    if let Some(slice) = self.haystack.as_bytes().get(found_char..self.finger) {\n                        if slice == &self.utf8_encoded[0..self.utf8_size] {\n                            return Some((found_char, self.finger));\n                        }\n                    }\n                }\n            } else {\n                // found nothing, exit\n                self.finger = self.finger_back;\n                return None;\n            }\n        }\n    }\n\n    // let next_reject use the default implementation from the Searcher trait\n}\n\nunsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> {\n    #[inline]\n    fn next_back(&mut self) -> SearchStep {\n        let old_finger = self.finger_back;\n        let slice = unsafe { self.haystack.get_unchecked(self.finger..old_finger) };\n        let mut iter = slice.chars();\n        let old_len = iter.iter.len();\n        if let Some(ch) = iter.next_back() {\n            // subtract byte offset of current character\n            // without re-encoding as utf-8\n            self.finger_back -= old_len - iter.iter.len();\n            if ch == self.needle {\n                SearchStep::Match(self.finger_back, old_finger)\n            } else {\n                SearchStep::Reject(self.finger_back, old_finger)\n            }\n        } else {\n            SearchStep::Done\n        }\n    }\n    #[inline]\n    fn next_match_back(&mut self) -> Option<(usize, usize)> {\n        let haystack = self.haystack.as_bytes();\n        loop {\n            // get the haystack up to but not including the last character searched\n            let bytes = if let Some(slice) = haystack.get(self.finger..self.finger_back) {\n                slice\n            } else {\n                return None;\n            };\n            // the last byte of the utf8 encoded needle\n            let last_byte = unsafe { *self.utf8_encoded.get_unchecked(self.utf8_size - 1) };\n            if let Some(index) = memchr::memrchr(last_byte, bytes) {\n                // we searched a slice that was offset by self.finger,\n                // add self.finger to recoup the original index\n                let index = self.finger + index;\n                // memrchr will return the index of the byte we wish to\n                // find. In case of an ASCII character, this is indeed\n                // were we wish our new finger to be (\"after\" the found\n                // char in the paradigm of reverse iteration). For\n                // multibyte chars we need to skip down by the number of more\n                // bytes they have than ASCII\n                let shift = self.utf8_size - 1;\n                if index >= shift {\n                    let found_char = index - shift;\n                    if let Some(slice) = haystack.get(found_char..(found_char + self.utf8_size)) {\n                        if slice == &self.utf8_encoded[0..self.utf8_size] {\n                            // move finger to before the character found (i.e. at its start index)\n                            self.finger_back = found_char;\n                            return Some((self.finger_back, self.finger_back + self.utf8_size));\n                        }\n                    }\n                }\n                // We can't use finger_back = index - size + 1 here. If we found the last char\n                // of a different-sized character (or the middle byte of a different character)\n                // we need to bump the finger_back down to `index`. This similarly makes\n                // `finger_back` have the potential to no longer be on a boundary,\n                // but this is OK since we only exit this function on a boundary\n                // or when the haystack has been searched completely.\n                //\n                // Unlike next_match this does not\n                // have the problem of repeated bytes in utf-8 because\n                // we're searching for the last byte, and we can only have\n                // found the last byte when searching in reverse.\n                self.finger_back = index;\n            } else {\n                self.finger_back = self.finger;\n                // found nothing, exit\n                return None;\n            }\n        }\n    }\n\n    // let next_reject_back use the default implementation from the Searcher trait\n}\n\nimpl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a> {}\n\n/// Searches for chars that are equal to a given char\nimpl<'a> Pattern<'a> for char {\n    type Searcher = CharSearcher<'a>;\n\n    #[inline]\n    fn into_searcher(self, haystack: &'a str) -> Self::Searcher {\n        let mut utf8_encoded = [0; 4];\n        self.encode_utf8(&mut utf8_encoded);\n        let utf8_size = self.len_utf8();\n        CharSearcher {\n            haystack,\n            finger: 0,\n            finger_back: haystack.len(),\n            needle: self,\n            utf8_size,\n            utf8_encoded\n        }\n    }\n\n    #[inline]\n    fn is_contained_in(self, haystack: &'a str) -> bool {\n        if (self as u32) < 128 {\n            haystack.as_bytes().contains(&(self as u8))\n        } else {\n            let mut buffer = [0u8; 4];\n            self.encode_utf8(&mut buffer).is_contained_in(haystack)\n        }\n    }\n\n    #[inline]\n    fn is_prefix_of(self, haystack: &'a str) -> bool {\n        if let Some(ch) = haystack.chars().next() {\n            self == ch\n        } else {\n            false\n        }\n    }\n\n    #[inline]\n    fn is_suffix_of(self, haystack: &'a str) -> bool where Self::Searcher: ReverseSearcher<'a>\n    {\n        if let Some(ch) = haystack.chars().next_back() {\n            self == ch\n        } else {\n            false\n        }\n    }\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for a MultiCharEq wrapper\n/////////////////////////////////////////////////////////////////////////////\n\n#[doc(hidden)]\ntrait MultiCharEq {\n    fn matches(&mut self, c: char) -> bool;\n}\n\nimpl<F> MultiCharEq for F where F: FnMut(char) -> bool {\n    #[inline]\n    fn matches(&mut self, c: char) -> bool { (*self)(c) }\n}\n\nimpl MultiCharEq for &[char] {\n    #[inline]\n    fn matches(&mut self, c: char) -> bool {\n        self.iter().any(|&m| { m == c })\n    }\n}\n\nstruct MultiCharEqPattern<C: MultiCharEq>(C);\n\n#[derive(Clone, Debug)]\nstruct MultiCharEqSearcher<'a, C: MultiCharEq> {\n    char_eq: C,\n    haystack: &'a str,\n    char_indices: super::CharIndices<'a>,\n}\n\nimpl<'a, C: MultiCharEq> Pattern<'a> for MultiCharEqPattern<C> {\n    type Searcher = MultiCharEqSearcher<'a, C>;\n\n    #[inline]\n    fn into_searcher(self, haystack: &'a str) -> MultiCharEqSearcher<'a, C> {\n        MultiCharEqSearcher {\n            haystack,\n            char_eq: self.0,\n            char_indices: haystack.char_indices(),\n        }\n    }\n}\n\nunsafe impl<'a, C: MultiCharEq> Searcher<'a> for MultiCharEqSearcher<'a, C> {\n    #[inline]\n    fn haystack(&self) -> &'a str {\n        self.haystack\n    }\n\n    #[inline]\n    fn next(&mut self) -> SearchStep {\n        let s = &mut self.char_indices;\n        // Compare lengths of the internal byte slice iterator\n        // to find length of current char\n        let pre_len = s.iter.iter.len();\n        if let Some((i, c)) = s.next() {\n            let len = s.iter.iter.len();\n            let char_len = pre_len - len;\n            if self.char_eq.matches(c) {\n                return SearchStep::Match(i, i + char_len);\n            } else {\n                return SearchStep::Reject(i, i + char_len);\n            }\n        }\n        SearchStep::Done\n    }\n}\n\nunsafe impl<'a, C: MultiCharEq> ReverseSearcher<'a> for MultiCharEqSearcher<'a, C> {\n    #[inline]\n    fn next_back(&mut self) -> SearchStep {\n        let s = &mut self.char_indices;\n        // Compare lengths of the internal byte slice iterator\n        // to find length of current char\n        let pre_len = s.iter.iter.len();\n        if let Some((i, c)) = s.next_back() {\n            let len = s.iter.iter.len();\n            let char_len = pre_len - len;\n            if self.char_eq.matches(c) {\n                return SearchStep::Match(i, i + char_len);\n            } else {\n                return SearchStep::Reject(i, i + char_len);\n            }\n        }\n        SearchStep::Done\n    }\n}\n\nimpl<'a, C: MultiCharEq> DoubleEndedSearcher<'a> for MultiCharEqSearcher<'a, C> {}\n\n/////////////////////////////////////////////////////////////////////////////\n\nmacro_rules! pattern_methods {\n    ($t:ty, $pmap:expr, $smap:expr) => {\n        type Searcher = $t;\n\n        #[inline]\n        fn into_searcher(self, haystack: &'a str) -> $t {\n            ($smap)(($pmap)(self).into_searcher(haystack))\n        }\n\n        #[inline]\n        fn is_contained_in(self, haystack: &'a str) -> bool {\n            ($pmap)(self).is_contained_in(haystack)\n        }\n\n        #[inline]\n        fn is_prefix_of(self, haystack: &'a str) -> bool {\n            ($pmap)(self).is_prefix_of(haystack)\n        }\n\n        #[inline]\n        fn is_suffix_of(self, haystack: &'a str) -> bool\n            where $t: ReverseSearcher<'a>\n        {\n            ($pmap)(self).is_suffix_of(haystack)\n        }\n    }\n}\n\nmacro_rules! searcher_methods {\n    (forward) => {\n        #[inline]\n        fn haystack(&self) -> &'a str {\n            self.0.haystack()\n        }\n        #[inline]\n        fn next(&mut self) -> SearchStep {\n            self.0.next()\n        }\n        #[inline]\n        fn next_match(&mut self) -> Option<(usize, usize)> {\n            self.0.next_match()\n        }\n        #[inline]\n        fn next_reject(&mut self) -> Option<(usize, usize)> {\n            self.0.next_reject()\n        }\n    };\n    (reverse) => {\n        #[inline]\n        fn next_back(&mut self) -> SearchStep {\n            self.0.next_back()\n        }\n        #[inline]\n        fn next_match_back(&mut self) -> Option<(usize, usize)> {\n            self.0.next_match_back()\n        }\n        #[inline]\n        fn next_reject_back(&mut self) -> Option<(usize, usize)> {\n            self.0.next_reject_back()\n        }\n    }\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for &[char]\n/////////////////////////////////////////////////////////////////////////////\n\n// Todo: Change / Remove due to ambiguity in meaning.\n\n/// Associated type for `<&[char] as Pattern<'a>>::Searcher`.\n#[derive(Clone, Debug)]\npub struct CharSliceSearcher<'a, 'b>(<MultiCharEqPattern<&'b [char]> as Pattern<'a>>::Searcher);\n\nunsafe impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b> {\n    searcher_methods!(forward);\n}\n\nunsafe impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b> {\n    searcher_methods!(reverse);\n}\n\nimpl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b> {}\n\n/// Searches for chars that are equal to any of the chars in the array\nimpl<'a, 'b> Pattern<'a> for &'b [char] {\n    pattern_methods!(CharSliceSearcher<'a, 'b>, MultiCharEqPattern, CharSliceSearcher);\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for F: FnMut(char) -> bool\n/////////////////////////////////////////////////////////////////////////////\n\n/// Associated type for `<F as Pattern<'a>>::Searcher`.\n#[derive(Clone)]\npub struct CharPredicateSearcher<'a, F>(<MultiCharEqPattern<F> as Pattern<'a>>::Searcher)\n    where F: FnMut(char) -> bool;\n\nimpl<F> fmt::Debug for CharPredicateSearcher<'_, F>\n    where F: FnMut(char) -> bool\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"CharPredicateSearcher\")\n            .field(\"haystack\", &self.0.haystack)\n            .field(\"char_indices\", &self.0.char_indices)\n            .finish()\n    }\n}\nunsafe impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>\n    where F: FnMut(char) -> bool\n{\n    searcher_methods!(forward);\n}\n\nunsafe impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>\n    where F: FnMut(char) -> bool\n{\n    searcher_methods!(reverse);\n}\n\nimpl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F>\n    where F: FnMut(char) -> bool {}\n\n/// Searches for chars that match the given predicate\nimpl<'a, F> Pattern<'a> for F where F: FnMut(char) -> bool {\n    pattern_methods!(CharPredicateSearcher<'a, F>, MultiCharEqPattern, CharPredicateSearcher);\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for &&str\n/////////////////////////////////////////////////////////////////////////////\n\n/// Delegates to the `&str` impl.\nimpl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {\n    pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);\n}\n\n/////////////////////////////////////////////////////////////////////////////\n// Impl for &str\n/////////////////////////////////////////////////////////////////////////////\n\n/// Non-allocating substring search.\n///\n/// Will handle the pattern `\"\"` as returning empty matches at each character\n/// boundary.\nimpl<'a, 'b> Pattern<'a> for &'b str {\n    type Searcher = StrSearcher<'a, 'b>;\n\n    #[inline]\n    fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b> {\n        StrSearcher::new(haystack, self)\n    }\n\n    /// Checks whether the pattern matches at the front of the haystack\n    #[inline]\n    fn is_prefix_of(self, haystack: &'a str) -> bool {\n        haystack.is_char_boundary(self.len()) &&\n            self == &haystack[..self.len()]\n    }\n\n    /// Checks whether the pattern matches at the back of the haystack\n    #[inline]\n    fn is_suffix_of(self, haystack: &'a str) -> bool {\n        self.len() <= haystack.len() &&\n            haystack.is_char_boundary(haystack.len() - self.len()) &&\n            self == &haystack[haystack.len() - self.len()..]\n    }\n}\n\n\n/////////////////////////////////////////////////////////////////////////////\n// Two Way substring searcher\n/////////////////////////////////////////////////////////////////////////////\n\n#[derive(Clone, Debug)]\n/// Associated type for `<&str as Pattern<'a>>::Searcher`.\npub struct StrSearcher<'a, 'b> {\n    haystack: &'a str,\n    needle: &'b str,\n\n    searcher: StrSearcherImpl,\n}\n\n#[derive(Clone, Debug)]\nenum StrSearcherImpl {\n    Empty(EmptyNeedle),\n    TwoWay(TwoWaySearcher),\n}\n\n#[derive(Clone, Debug)]\nstruct EmptyNeedle {\n    position: usize,\n    end: usize,\n    is_match_fw: bool,\n    is_match_bw: bool,\n}\n\nimpl<'a, 'b> StrSearcher<'a, 'b> {\n    fn new(haystack: &'a str, needle: &'b str) -> StrSearcher<'a, 'b> {\n        if needle.is_empty() {\n            StrSearcher {\n                haystack,\n                needle,\n                searcher: StrSearcherImpl::Empty(EmptyNeedle {\n                    position: 0,\n                    end: haystack.len(),\n                    is_match_fw: true,\n                    is_match_bw: true,\n                }),\n            }\n        } else {\n            StrSearcher {\n                haystack,\n                needle,\n                searcher: StrSearcherImpl::TwoWay(\n                    TwoWaySearcher::new(needle.as_bytes(), haystack.len())\n                ),\n            }\n        }\n    }\n}\n\nunsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {\n    #[inline]\n    fn haystack(&self) -> &'a str {\n        self.haystack\n    }\n\n    #[inline]\n    fn next(&mut self) -> SearchStep {\n        match self.searcher {\n            StrSearcherImpl::Empty(ref mut searcher) => {\n                // empty needle rejects every char and matches every empty string between them\n                let is_match = searcher.is_match_fw;\n                searcher.is_match_fw = !searcher.is_match_fw;\n                let pos = searcher.position;\n                match self.haystack[pos..].chars().next() {\n                    _ if is_match => SearchStep::Match(pos, pos),\n                    None => SearchStep::Done,\n                    Some(ch) => {\n                        searcher.position += ch.len_utf8();\n                        SearchStep::Reject(pos, searcher.position)\n                    }\n                }\n            }\n            StrSearcherImpl::TwoWay(ref mut searcher) => {\n                // TwoWaySearcher produces valid *Match* indices that split at char boundaries\n                // as long as it does correct matching and that haystack and needle are\n                // valid UTF-8\n                // *Rejects* from the algorithm can fall on any indices, but we will walk them\n                // manually to the next character boundary, so that they are utf-8 safe.\n                if searcher.position == self.haystack.len() {\n                    return SearchStep::Done;\n                }\n                let is_long = searcher.memory == usize::MAX;\n                match searcher.next::<RejectAndMatch>(self.haystack.as_bytes(),\n                                                      self.needle.as_bytes(),\n                                                      is_long)\n                {\n                    SearchStep::Reject(a, mut b) => {\n                        // skip to next char boundary\n                        while !self.haystack.is_char_boundary(b) {\n                            b += 1;\n                        }\n                        searcher.position = cmp::max(b, searcher.position);\n                        SearchStep::Reject(a, b)\n                    }\n                    otherwise => otherwise,\n                }\n            }\n        }\n    }\n\n    #[inline]\n    fn next_match(&mut self) -> Option<(usize, usize)> {\n        match self.searcher {\n            StrSearcherImpl::Empty(..) => {\n                loop {\n                    match self.next() {\n                        SearchStep::Match(a, b) => return Some((a, b)),\n                        SearchStep::Done => return None,\n                        SearchStep::Reject(..) => { }\n                    }\n                }\n            }\n            StrSearcherImpl::TwoWay(ref mut searcher) => {\n                let is_long = searcher.memory == usize::MAX;\n                // write out `true` and `false` cases to encourage the compiler\n                // to specialize the two cases separately.\n                if is_long {\n                    searcher.next::<MatchOnly>(self.haystack.as_bytes(),\n                                               self.needle.as_bytes(),\n                                               true)\n                } else {\n                    searcher.next::<MatchOnly>(self.haystack.as_bytes(),\n                                               self.needle.as_bytes(),\n                                               false)\n                }\n            }\n        }\n    }\n}\n\nunsafe impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b> {\n    #[inline]\n    fn next_back(&mut self) -> SearchStep {\n        match self.searcher {\n            StrSearcherImpl::Empty(ref mut searcher) => {\n                let is_match = searcher.is_match_bw;\n                searcher.is_match_bw = !searcher.is_match_bw;\n                let end = searcher.end;\n                match self.haystack[..end].chars().next_back() {\n                    _ if is_match => SearchStep::Match(end, end),\n                    None => SearchStep::Done,\n                    Some(ch) => {\n                        searcher.end -= ch.len_utf8();\n                        SearchStep::Reject(searcher.end, end)\n                    }\n                }\n            }\n            StrSearcherImpl::TwoWay(ref mut searcher) => {\n                if searcher.end == 0 {\n                    return SearchStep::Done;\n                }\n                let is_long = searcher.memory == usize::MAX;\n                match searcher.next_back::<RejectAndMatch>(self.haystack.as_bytes(),\n                                                           self.needle.as_bytes(),\n                                                           is_long)\n                {\n                    SearchStep::Reject(mut a, b) => {\n                        // skip to next char boundary\n                        while !self.haystack.is_char_boundary(a) {\n                            a -= 1;\n                        }\n                        searcher.end = cmp::min(a, searcher.end);\n                        SearchStep::Reject(a, b)\n                    }\n                    otherwise => otherwise,\n                }\n            }\n        }\n    }\n\n    #[inline]\n    fn next_match_back(&mut self) -> Option<(usize, usize)> {\n        match self.searcher {\n            StrSearcherImpl::Empty(..) => {\n                loop {\n                    match self.next_back() {\n                        SearchStep::Match(a, b) => return Some((a, b)),\n                        SearchStep::Done => return None,\n                        SearchStep::Reject(..) => { }\n                    }\n                }\n            }\n            StrSearcherImpl::TwoWay(ref mut searcher) => {\n                let is_long = searcher.memory == usize::MAX;\n                // write out `true` and `false`, like `next_match`\n                if is_long {\n                    searcher.next_back::<MatchOnly>(self.haystack.as_bytes(),\n                                                    self.needle.as_bytes(),\n                                                    true)\n                } else {\n                    searcher.next_back::<MatchOnly>(self.haystack.as_bytes(),\n                                                    self.needle.as_bytes(),\n                                                    false)\n                }\n            }\n        }\n    }\n}\n\n/// The internal state of the two-way substring search algorithm.\n#[derive(Clone, Debug)]\nstruct TwoWaySearcher {\n    // constants\n    /// critical factorization index\n    crit_pos: usize,\n    /// critical factorization index for reversed needle\n    crit_pos_back: usize,\n    period: usize,\n    /// `byteset` is an extension (not part of the two way algorithm);\n    /// it's a 64-bit \"fingerprint\" where each set bit `j` corresponds\n    /// to a (byte & 63) == j present in the needle.\n    byteset: u64,\n\n    // variables\n    position: usize,\n    end: usize,\n    /// index into needle before which we have already matched\n    memory: usize,\n    /// index into needle after which we have already matched\n    memory_back: usize,\n}\n\n/*\n    This is the Two-Way search algorithm, which was introduced in the paper:\n    Crochemore, M., Perrin, D., 1991, Two-way string-matching, Journal of the ACM 38(3):651-675.\n\n    Here's some background information.\n\n    A *word* is a string of symbols. The *length* of a word should be a familiar\n    notion, and here we denote it for any word x by |x|.\n    (We also allow for the possibility of the *empty word*, a word of length zero).\n\n    If x is any non-empty word, then an integer p with 0 < p <= |x| is said to be a\n    *period* for x iff for all i with 0 <= i <= |x| - p - 1, we have x[i] == x[i+p].\n    For example, both 1 and 2 are periods for the string \"aa\". As another example,\n    the only period of the string \"abcd\" is 4.\n\n    We denote by period(x) the *smallest* period of x (provided that x is non-empty).\n    This is always well-defined since every non-empty word x has at least one period,\n    |x|. We sometimes call this *the period* of x.\n\n    If u, v and x are words such that x = uv, where uv is the concatenation of u and\n    v, then we say that (u, v) is a *factorization* of x.\n\n    Let (u, v) be a factorization for a word x. Then if w is a non-empty word such\n    that both of the following hold\n\n      - either w is a suffix of u or u is a suffix of w\n      - either w is a prefix of v or v is a prefix of w\n\n    then w is said to be a *repetition* for the factorization (u, v).\n\n    Just to unpack this, there are four possibilities here. Let w = \"abc\". Then we\n    might have:\n\n      - w is a suffix of u and w is a prefix of v. ex: (\"lolabc\", \"abcde\")\n      - w is a suffix of u and v is a prefix of w. ex: (\"lolabc\", \"ab\")\n      - u is a suffix of w and w is a prefix of v. ex: (\"bc\", \"abchi\")\n      - u is a suffix of w and v is a prefix of w. ex: (\"bc\", \"a\")\n\n    Note that the word vu is a repetition for any factorization (u,v) of x = uv,\n    so every factorization has at least one repetition.\n\n    If x is a string and (u, v) is a factorization for x, then a *local period* for\n    (u, v) is an integer r such that there is some word w such that |w| = r and w is\n    a repetition for (u, v).\n\n    We denote by local_period(u, v) the smallest local period of (u, v). We sometimes\n    call this *the local period* of (u, v). Provided that x = uv is non-empty, this\n    is well-defined (because each non-empty word has at least one factorization, as\n    noted above).\n\n    It can be proven that the following is an equivalent definition of a local period\n    for a factorization (u, v): any positive integer r such that x[i] == x[i+r] for\n    all i such that |u| - r <= i <= |u| - 1 and such that both x[i] and x[i+r] are\n    defined. (i.e. i > 0 and i + r < |x|).\n\n    Using the above reformulation, it is easy to prove that\n\n        1 <= local_period(u, v) <= period(uv)\n\n    A factorization (u, v) of x such that local_period(u,v) = period(x) is called a\n    *critical factorization*.\n\n    The algorithm hinges on the following theorem, which is stated without proof:\n\n    **Critical Factorization Theorem** Any word x has at least one critical\n    factorization (u, v) such that |u| < period(x).\n\n    The purpose of maximal_suffix is to find such a critical factorization.\n\n    If the period is short, compute another factorization x = u' v' to use\n    for reverse search, chosen instead so that |v'| < period(x).\n\n*/\nimpl TwoWaySearcher {\n    fn new(needle: &[u8], end: usize) -> TwoWaySearcher {\n        let (crit_pos_false, period_false) = TwoWaySearcher::maximal_suffix(needle, false);\n        let (crit_pos_true, period_true) = TwoWaySearcher::maximal_suffix(needle, true);\n\n        let (crit_pos, period) =\n            if crit_pos_false > crit_pos_true {\n                (crit_pos_false, period_false)\n            } else {\n                (crit_pos_true, period_true)\n            };\n\n        // A particularly readable explanation of what's going on here can be found\n        // in Crochemore and Rytter's book \"Text Algorithms\", ch 13. Specifically\n        // see the code for \"Algorithm CP\" on p. 323.\n        //\n        // What's going on is we have some critical factorization (u, v) of the\n        // needle, and we want to determine whether u is a suffix of\n        // &v[..period]. If it is, we use \"Algorithm CP1\". Otherwise we use\n        // \"Algorithm CP2\", which is optimized for when the period of the needle\n        // is large.\n        if &needle[..crit_pos] == &needle[period.. period + crit_pos] {\n            // short period case -- the period is exact\n            // compute a separate critical factorization for the reversed needle\n            // x = u' v' where |v'| < period(x).\n            //\n            // This is sped up by the period being known already.\n            // Note that a case like x = \"acba\" may be factored exactly forwards\n            // (crit_pos = 1, period = 3) while being factored with approximate\n            // period in reverse (crit_pos = 2, period = 2). We use the given\n            // reverse factorization but keep the exact period.\n            let crit_pos_back = needle.len() - cmp::max(\n                TwoWaySearcher::reverse_maximal_suffix(needle, period, false),\n                TwoWaySearcher::reverse_maximal_suffix(needle, period, true));\n\n            TwoWaySearcher {\n                crit_pos,\n                crit_pos_back,\n                period,\n                byteset: Self::byteset_create(&needle[..period]),\n\n                position: 0,\n                end,\n                memory: 0,\n                memory_back: needle.len(),\n            }\n        } else {\n            // long period case -- we have an approximation to the actual period,\n            // and don't use memorization.\n            //\n            // Approximate the period by lower bound max(|u|, |v|) + 1.\n            // The critical factorization is efficient to use for both forward and\n            // reverse search.\n\n            TwoWaySearcher {\n                crit_pos,\n                crit_pos_back: crit_pos,\n                period: cmp::max(crit_pos, needle.len() - crit_pos) + 1,\n                byteset: Self::byteset_create(needle),\n\n                position: 0,\n                end,\n                memory: usize::MAX, // Dummy value to signify that the period is long\n                memory_back: usize::MAX,\n            }\n        }\n    }\n\n    #[inline]\n    fn byteset_create(bytes: &[u8]) -> u64 {\n        bytes.iter().fold(0, |a, &b| (1 << (b & 0x3f)) | a)\n    }\n\n    #[inline]\n    fn byteset_contains(&self, byte: u8) -> bool {\n        (self.byteset >> ((byte & 0x3f) as usize)) & 1 != 0\n    }\n\n    // One of the main ideas of Two-Way is that we factorize the needle into\n    // two halves, (u, v), and begin trying to find v in the haystack by scanning\n    // left to right. If v matches, we try to match u by scanning right to left.\n    // How far we can jump when we encounter a mismatch is all based on the fact\n    // that (u, v) is a critical factorization for the needle.\n    #[inline]\n    fn next<S>(&mut self, haystack: &[u8], needle: &[u8], long_period: bool)\n        -> S::Output\n        where S: TwoWayStrategy\n    {\n        // `next()` uses `self.position` as its cursor\n        let old_pos = self.position;\n        let needle_last = needle.len() - 1;\n        'search: loop {\n            // Check that we have room to search in\n            // position + needle_last can not overflow if we assume slices\n            // are bounded by isize's range.\n            let tail_byte = match haystack.get(self.position + needle_last) {\n                Some(&b) => b,\n                None => {\n                    self.position = haystack.len();\n                    return S::rejecting(old_pos, self.position);\n                }\n            };\n\n            if S::use_early_reject() && old_pos != self.position {\n                return S::rejecting(old_pos, self.position);\n            }\n\n            // Quickly skip by large portions unrelated to our substring\n            if !self.byteset_contains(tail_byte) {\n                self.position += needle.len();\n                if !long_period {\n                    self.memory = 0;\n                }\n                continue 'search;\n            }\n\n            // See if the right part of the needle matches\n            let start = if long_period { self.crit_pos }\n                        else { cmp::max(self.crit_pos, self.memory) };\n            for i in start..needle.len() {\n                if needle[i] != haystack[self.position + i] {\n                    self.position += i - self.crit_pos + 1;\n                    if !long_period {\n                        self.memory = 0;\n                    }\n                    continue 'search;\n                }\n            }\n\n            // See if the left part of the needle matches\n            let start = if long_period { 0 } else { self.memory };\n            for i in (start..self.crit_pos).rev() {\n                if needle[i] != haystack[self.position + i] {\n                    self.position += self.period;\n                    if !long_period {\n                        self.memory = needle.len() - self.period;\n                    }\n                    continue 'search;\n                }\n            }\n\n            // We have found a match!\n            let match_pos = self.position;\n\n            // Note: add self.period instead of needle.len() to have overlapping matches\n            self.position += needle.len();\n            if !long_period {\n                self.memory = 0; // set to needle.len() - self.period for overlapping matches\n            }\n\n            return S::matching(match_pos, match_pos + needle.len());\n        }\n    }\n\n    // Follows the ideas in `next()`.\n    //\n    // The definitions are symmetrical, with period(x) = period(reverse(x))\n    // and local_period(u, v) = local_period(reverse(v), reverse(u)), so if (u, v)\n    // is a critical factorization, so is (reverse(v), reverse(u)).\n    //\n    // For the reverse case we have computed a critical factorization x = u' v'\n    // (field `crit_pos_back`). We need |u| < period(x) for the forward case and\n    // thus |v'| < period(x) for the reverse.\n    //\n    // To search in reverse through the haystack, we search forward through\n    // a reversed haystack with a reversed needle, matching first u' and then v'.\n    #[inline]\n    fn next_back<S>(&mut self, haystack: &[u8], needle: &[u8], long_period: bool)\n        -> S::Output\n        where S: TwoWayStrategy\n    {\n        // `next_back()` uses `self.end` as its cursor -- so that `next()` and `next_back()`\n        // are independent.\n        let old_end = self.end;\n        'search: loop {\n            // Check that we have room to search in\n            // end - needle.len() will wrap around when there is no more room,\n            // but due to slice length limits it can never wrap all the way back\n            // into the length of haystack.\n            let front_byte = match haystack.get(self.end.wrapping_sub(needle.len())) {\n                Some(&b) => b,\n                None => {\n                    self.end = 0;\n                    return S::rejecting(0, old_end);\n                }\n            };\n\n            if S::use_early_reject() && old_end != self.end {\n                return S::rejecting(self.end, old_end);\n            }\n\n            // Quickly skip by large portions unrelated to our substring\n            if !self.byteset_contains(front_byte) {\n                self.end -= needle.len();\n                if !long_period {\n                    self.memory_back = needle.len();\n                }\n                continue 'search;\n            }\n\n            // See if the left part of the needle matches\n            let crit = if long_period { self.crit_pos_back }\n                       else { cmp::min(self.crit_pos_back, self.memory_back) };\n            for i in (0..crit).rev() {\n                if needle[i] != haystack[self.end - needle.len() + i] {\n                    self.end -= self.crit_pos_back - i;\n                    if !long_period {\n                        self.memory_back = needle.len();\n                    }\n                    continue 'search;\n                }\n            }\n\n            // See if the right part of the needle matches\n            let needle_end = if long_period { needle.len() }\n                             else { self.memory_back };\n            for i in self.crit_pos_back..needle_end {\n                if needle[i] != haystack[self.end - needle.len() + i] {\n                    self.end -= self.period;\n                    if !long_period {\n                        self.memory_back = self.period;\n                    }\n                    continue 'search;\n                }\n            }\n\n            // We have found a match!\n            let match_pos = self.end - needle.len();\n            // Note: sub self.period instead of needle.len() to have overlapping matches\n            self.end -= needle.len();\n            if !long_period {\n                self.memory_back = needle.len();\n            }\n\n            return S::matching(match_pos, match_pos + needle.len());\n        }\n    }\n\n    // Compute the maximal suffix of `arr`.\n    //\n    // The maximal suffix is a possible critical factorization (u, v) of `arr`.\n    //\n    // Returns (`i`, `p`) where `i` is the starting index of v and `p` is the\n    // period of v.\n    //\n    // `order_greater` determines if lexical order is `<` or `>`. Both\n    // orders must be computed -- the ordering with the largest `i` gives\n    // a critical factorization.\n    //\n    // For long period cases, the resulting period is not exact (it is too short).\n    #[inline]\n    fn maximal_suffix(arr: &[u8], order_greater: bool) -> (usize, usize) {\n        let mut left = 0; // Corresponds to i in the paper\n        let mut right = 1; // Corresponds to j in the paper\n        let mut offset = 0; // Corresponds to k in the paper, but starting at 0\n                            // to match 0-based indexing.\n        let mut period = 1; // Corresponds to p in the paper\n\n        while let Some(&a) = arr.get(right + offset) {\n            // `left` will be inbounds when `right` is.\n            let b = arr[left + offset];\n            if (a < b && !order_greater) || (a > b && order_greater) {\n                // Suffix is smaller, period is entire prefix so far.\n                right += offset + 1;\n                offset = 0;\n                period = right - left;\n            } else if a == b {\n                // Advance through repetition of the current period.\n                if offset + 1 == period {\n                    right += offset + 1;\n                    offset = 0;\n                } else {\n                    offset += 1;\n                }\n            } else {\n                // Suffix is larger, start over from current location.\n                left = right;\n                right += 1;\n                offset = 0;\n                period = 1;\n            }\n        }\n        (left, period)\n    }\n\n    // Compute the maximal suffix of the reverse of `arr`.\n    //\n    // The maximal suffix is a possible critical factorization (u', v') of `arr`.\n    //\n    // Returns `i` where `i` is the starting index of v', from the back;\n    // returns immediately when a period of `known_period` is reached.\n    //\n    // `order_greater` determines if lexical order is `<` or `>`. Both\n    // orders must be computed -- the ordering with the largest `i` gives\n    // a critical factorization.\n    //\n    // For long period cases, the resulting period is not exact (it is too short).\n    fn reverse_maximal_suffix(arr: &[u8], known_period: usize,\n                              order_greater: bool) -> usize\n    {\n        let mut left = 0; // Corresponds to i in the paper\n        let mut right = 1; // Corresponds to j in the paper\n        let mut offset = 0; // Corresponds to k in the paper, but starting at 0\n                            // to match 0-based indexing.\n        let mut period = 1; // Corresponds to p in the paper\n        let n = arr.len();\n\n        while right + offset < n {\n            let a = arr[n - (1 + right + offset)];\n            let b = arr[n - (1 + left + offset)];\n            if (a < b && !order_greater) || (a > b && order_greater) {\n                // Suffix is smaller, period is entire prefix so far.\n                right += offset + 1;\n                offset = 0;\n                period = right - left;\n            } else if a == b {\n                // Advance through repetition of the current period.\n                if offset + 1 == period {\n                    right += offset + 1;\n                    offset = 0;\n                } else {\n                    offset += 1;\n                }\n            } else {\n                // Suffix is larger, start over from current location.\n                left = right;\n                right += 1;\n                offset = 0;\n                period = 1;\n            }\n            if period == known_period {\n                break;\n            }\n        }\n        debug_assert!(period <= known_period);\n        left\n    }\n}\n\n// TwoWayStrategy allows the algorithm to either skip non-matches as quickly\n// as possible, or to work in a mode where it emits Rejects relatively quickly.\ntrait TwoWayStrategy {\n    type Output;\n    fn use_early_reject() -> bool;\n    fn rejecting(a: usize, b: usize) -> Self::Output;\n    fn matching(a: usize, b: usize) -> Self::Output;\n}\n\n/// Skip to match intervals as quickly as possible\nenum MatchOnly { }\n\nimpl TwoWayStrategy for MatchOnly {\n    type Output = Option<(usize, usize)>;\n\n    #[inline]\n    fn use_early_reject() -> bool { false }\n    #[inline]\n    fn rejecting(_a: usize, _b: usize) -> Self::Output { None }\n    #[inline]\n    fn matching(a: usize, b: usize) -> Self::Output { Some((a, b)) }\n}\n\n/// Emit Rejects regularly\nenum RejectAndMatch { }\n\nimpl TwoWayStrategy for RejectAndMatch {\n    type Output = SearchStep;\n\n    #[inline]\n    fn use_early_reject() -> bool { true }\n    #[inline]\n    fn rejecting(a: usize, b: usize) -> Self::Output { SearchStep::Reject(a, b) }\n    #[inline]\n    fn matching(a: usize, b: usize) -> Self::Output { SearchStep::Match(a, b) }\n}\n","// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! The `Clone` trait for types that cannot be 'implicitly copied'.\n//!\n//! In Rust, some simple types are \"implicitly copyable\" and when you\n//! assign them or pass them as arguments, the receiver will get a copy,\n//! leaving the original value in place. These types do not require\n//! allocation to copy and do not have finalizers (i.e. they do not\n//! contain owned boxes or implement [`Drop`]), so the compiler considers\n//! them cheap and safe to copy. For other types copies must be made\n//! explicitly, by convention implementing the [`Clone`] trait and calling\n//! the [`clone`][clone] method.\n//!\n//! [`Clone`]: trait.Clone.html\n//! [clone]: trait.Clone.html#tymethod.clone\n//! [`Drop`]: ../../std/ops/trait.Drop.html\n//!\n//! Basic usage example:\n//!\n//! ```\n//! let s = String::new(); // String type implements Clone\n//! let copy = s.clone(); // so we can clone it\n//! ```\n//!\n//! To easily implement the Clone trait, you can also use\n//! `#[derive(Clone)]`. Example:\n//!\n//! ```\n//! #[derive(Clone)] // we add the Clone trait to Morpheus struct\n//! struct Morpheus {\n//!    blue_pill: f32,\n//!    red_pill: i64,\n//! }\n//!\n//! fn main() {\n//!    let f = Morpheus { blue_pill: 0.0, red_pill: 0 };\n//!    let copy = f.clone(); // and now we can clone it!\n//! }\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n/// A common trait for the ability to explicitly duplicate an object.\n///\n/// Differs from [`Copy`] in that [`Copy`] is implicit and extremely inexpensive, while\n/// `Clone` is always explicit and may or may not be expensive. In order to enforce\n/// these characteristics, Rust does not allow you to reimplement [`Copy`], but you\n/// may reimplement `Clone` and run arbitrary code.\n///\n/// Since `Clone` is more general than [`Copy`], you can automatically make anything\n/// [`Copy`] be `Clone` as well.\n///\n/// ## Derivable\n///\n/// This trait can be used with `#[derive]` if all fields are `Clone`. The `derive`d\n/// implementation of [`clone`] calls [`clone`] on each field.\n///\n/// ## How can I implement `Clone`?\n///\n/// Types that are [`Copy`] should have a trivial implementation of `Clone`. More formally:\n/// if `T: Copy`, `x: T`, and `y: &T`, then `let x = y.clone();` is equivalent to `let x = *y;`.\n/// Manual implementations should be careful to uphold this invariant; however, unsafe code\n/// must not rely on it to ensure memory safety.\n///\n/// An example is an array holding more than 32 elements of a type that is `Clone`; the standard\n/// library only implements `Clone` up until arrays of size 32. In this case, the implementation of\n/// `Clone` cannot be `derive`d, but can be implemented as:\n///\n/// [`Copy`]: ../../std/marker/trait.Copy.html\n/// [`clone`]: trait.Clone.html#tymethod.clone\n///\n/// ```\n/// #[derive(Copy)]\n/// struct Stats {\n///    frequencies: [i32; 100],\n/// }\n///\n/// impl Clone for Stats {\n///     fn clone(&self) -> Stats { *self }\n/// }\n/// ```\n///\n/// ## Additional implementors\n///\n/// In addition to the [implementors listed below][impls],\n/// the following types also implement `Clone`:\n///\n/// * Function item types (i.e. the distinct types defined for each function)\n/// * Function pointer types (e.g. `fn() -> i32`)\n/// * Array types, for all sizes, if the item type also implements `Clone` (e.g. `[i32; 123456]`)\n/// * Tuple types, if each component also implements `Clone` (e.g. `()`, `(i32, bool)`)\n/// * Closure types, if they capture no value from the environment\n///   or if all such captured values implement `Clone` themselves.\n///   Note that variables captured by shared reference always implement `Clone`\n///   (even if the referent doesn't),\n///   while variables captured by mutable reference never implement `Clone`.\n///\n/// [impls]: #implementors\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[lang = \"clone\"]\npub trait Clone : Sized {\n    /// Returns a copy of the value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let hello = \"Hello\"; // &str implements Clone\n    ///\n    /// assert_eq!(\"Hello\", hello.clone());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[must_use = \"cloning is often expensive and is not expected to have side effects\"]\n    fn clone(&self) -> Self;\n\n    /// Performs copy-assignment from `source`.\n    ///\n    /// `a.clone_from(&b)` is equivalent to `a = b.clone()` in functionality,\n    /// but can be overridden to reuse the resources of `a` to avoid unnecessary\n    /// allocations.\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn clone_from(&mut self, source: &Self) {\n        *self = source.clone()\n    }\n}\n\n// FIXME(aburka): these structs are used solely by #[derive] to\n// assert that every component of a type implements Clone or Copy.\n//\n// These structs should never appear in user code.\n#[doc(hidden)]\n#[allow(missing_debug_implementations)]\n#[unstable(feature = \"derive_clone_copy\",\n           reason = \"deriving hack, should not be public\",\n           issue = \"0\")]\npub struct AssertParamIsClone<T: Clone + ?Sized> { _field: ::marker::PhantomData<T> }\n#[doc(hidden)]\n#[allow(missing_debug_implementations)]\n#[unstable(feature = \"derive_clone_copy\",\n           reason = \"deriving hack, should not be public\",\n           issue = \"0\")]\npub struct AssertParamIsCopy<T: Copy + ?Sized> { _field: ::marker::PhantomData<T> }\n\n/// Implementations of `Clone` for primitive types.\n///\n/// Implementations that cannot be described in Rust\n/// are implemented in `SelectionContext::copy_clone_conditions()` in librustc.\nmod impls {\n\n    use super::Clone;\n\n    macro_rules! impl_clone {\n        ($($t:ty)*) => {\n            $(\n                #[stable(feature = \"rust1\", since = \"1.0.0\")]\n                impl Clone for $t {\n                    #[inline]\n                    fn clone(&self) -> Self {\n                        *self\n                    }\n                }\n            )*\n        }\n    }\n\n    impl_clone! {\n        usize u8 u16 u32 u64 u128\n        isize i8 i16 i32 i64 i128\n        f32 f64\n        bool char\n    }\n\n    #[unstable(feature = \"never_type\", issue = \"35121\")]\n    impl Clone for ! {\n        #[inline]\n        fn clone(&self) -> Self {\n            *self\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<T: ?Sized> Clone for *const T {\n        #[inline]\n        fn clone(&self) -> Self {\n            *self\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<T: ?Sized> Clone for *mut T {\n        #[inline]\n        fn clone(&self) -> Self {\n            *self\n        }\n    }\n\n    // Shared references can be cloned, but mutable references *cannot*!\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<T: ?Sized> Clone for &T {\n        #[inline]\n        fn clone(&self) -> Self {\n            *self\n        }\n    }\n\n}\n","#[allow(warnings)]\n#[cfg(target_pointer_width = \"16\")]\ntype c_int = i16;\n#[allow(warnings)]\n#[cfg(not(target_pointer_width = \"16\"))]\ntype c_int = i32;\n\n#[cfg_attr(all(feature = \"mem\", not(feature = \"mangled-names\")), no_mangle)]\npub unsafe extern \"C\" fn memcpy(dest: *mut u8,\n                                src: *const u8,\n                                n: usize)\n                                -> *mut u8 {\n    let mut i = 0;\n    while i < n {\n        *dest.offset(i as isize) = *src.offset(i as isize);\n        i += 1;\n    }\n    dest\n}\n\n#[cfg_attr(all(feature = \"mem\", not(feature = \"mangled-names\")), no_mangle)]\npub unsafe extern \"C\" fn memmove(dest: *mut u8,\n                                 src: *const u8,\n                                 n: usize)\n                                 -> *mut u8 {\n    if src < dest as *const u8 {\n        // copy from end\n        let mut i = n;\n        while i != 0 {\n            i -= 1;\n            *dest.offset(i as isize) = *src.offset(i as isize);\n        }\n    } else {\n        // copy from beginning\n        let mut i = 0;\n        while i < n {\n            *dest.offset(i as isize) = *src.offset(i as isize);\n            i += 1;\n        }\n    }\n    dest\n}\n\n#[cfg_attr(all(feature = \"mem\", not(feature = \"mangled-names\")), no_mangle)]\npub unsafe extern \"C\" fn memset(s: *mut u8, c: c_int, n: usize) -> *mut u8 {\n    let mut i = 0;\n    while i < n {\n        *s.offset(i as isize) = c as u8;\n        i += 1;\n    }\n    s\n}\n\n#[cfg_attr(all(feature = \"mem\", not(feature = \"mangled-names\")), no_mangle)]\npub unsafe extern \"C\" fn memcmp(s1: *const u8, s2: *const u8, n: usize) -> i32 {\n    let mut i = 0;\n    while i < n {\n        let a = *s1.offset(i as isize);\n        let b = *s2.offset(i as isize);\n        if a != b {\n            return a as i32 - b as i32;\n        }\n        i += 1;\n    }\n    0\n}\n","// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n#![stable(feature = \"duration_core\", since = \"1.25.0\")]\n\n//! Temporal quantification.\n//!\n//! Example:\n//!\n//! ```\n//! use std::time::Duration;\n//!\n//! let five_seconds = Duration::new(5, 0);\n//! // both declarations are equivalent\n//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5));\n//! ```\n\nuse {fmt, u64};\nuse iter::Sum;\nuse ops::{Add, Sub, Mul, Div, AddAssign, SubAssign, MulAssign, DivAssign};\n\nconst NANOS_PER_SEC: u32 = 1_000_000_000;\nconst NANOS_PER_MILLI: u32 = 1_000_000;\nconst NANOS_PER_MICRO: u32 = 1_000;\nconst MILLIS_PER_SEC: u64 = 1_000;\nconst MICROS_PER_SEC: u64 = 1_000_000;\nconst MAX_NANOS_F64: f64 = ((u64::MAX as u128 + 1)*(NANOS_PER_SEC as u128)) as f64;\n\n/// A `Duration` type to represent a span of time, typically used for system\n/// timeouts.\n///\n/// Each `Duration` is composed of a whole number of seconds and a fractional part\n/// represented in nanoseconds.  If the underlying system does not support\n/// nanosecond-level precision, APIs binding a system timeout will typically round up\n/// the number of nanoseconds.\n///\n/// `Duration`s implement many common traits, including [`Add`], [`Sub`], and other\n/// [`ops`] traits.\n///\n/// [`Add`]: ../../std/ops/trait.Add.html\n/// [`Sub`]: ../../std/ops/trait.Sub.html\n/// [`ops`]: ../../std/ops/index.html\n///\n/// # Examples\n///\n/// ```\n/// use std::time::Duration;\n///\n/// let five_seconds = Duration::new(5, 0);\n/// let five_seconds_and_five_nanos = five_seconds + Duration::new(0, 5);\n///\n/// assert_eq!(five_seconds_and_five_nanos.as_secs(), 5);\n/// assert_eq!(five_seconds_and_five_nanos.subsec_nanos(), 5);\n///\n/// let ten_millis = Duration::from_millis(10);\n/// ```\n#[stable(feature = \"duration\", since = \"1.3.0\")]\n#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]\npub struct Duration {\n    secs: u64,\n    nanos: u32, // Always 0 <= nanos < NANOS_PER_SEC\n}\n\nimpl Duration {\n    /// Creates a new `Duration` from the specified number of whole seconds and\n    /// additional nanoseconds.\n    ///\n    /// If the number of nanoseconds is greater than 1 billion (the number of\n    /// nanoseconds in a second), then it will carry over into the seconds provided.\n    ///\n    /// # Panics\n    ///\n    /// This constructor will panic if the carry from the nanoseconds overflows\n    /// the seconds counter.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let five_seconds = Duration::new(5, 0);\n    /// ```\n    #[stable(feature = \"duration\", since = \"1.3.0\")]\n    #[inline]\n    pub fn new(secs: u64, nanos: u32) -> Duration {\n        let secs = secs.checked_add((nanos / NANOS_PER_SEC) as u64)\n            .expect(\"overflow in Duration::new\");\n        let nanos = nanos % NANOS_PER_SEC;\n        Duration { secs, nanos }\n    }\n\n    /// Creates a new `Duration` from the specified number of whole seconds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_secs(5);\n    ///\n    /// assert_eq!(5, duration.as_secs());\n    /// assert_eq!(0, duration.subsec_nanos());\n    /// ```\n    #[stable(feature = \"duration\", since = \"1.3.0\")]\n    #[inline]\n    #[rustc_promotable]\n    pub const fn from_secs(secs: u64) -> Duration {\n        Duration { secs, nanos: 0 }\n    }\n\n    /// Creates a new `Duration` from the specified number of milliseconds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_millis(2569);\n    ///\n    /// assert_eq!(2, duration.as_secs());\n    /// assert_eq!(569_000_000, duration.subsec_nanos());\n    /// ```\n    #[stable(feature = \"duration\", since = \"1.3.0\")]\n    #[inline]\n    #[rustc_promotable]\n    pub const fn from_millis(millis: u64) -> Duration {\n        Duration {\n            secs: millis / MILLIS_PER_SEC,\n            nanos: ((millis % MILLIS_PER_SEC) as u32) * NANOS_PER_MILLI,\n        }\n    }\n\n    /// Creates a new `Duration` from the specified number of microseconds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_micros(1_000_002);\n    ///\n    /// assert_eq!(1, duration.as_secs());\n    /// assert_eq!(2000, duration.subsec_nanos());\n    /// ```\n    #[stable(feature = \"duration_from_micros\", since = \"1.27.0\")]\n    #[inline]\n    #[rustc_promotable]\n    pub const fn from_micros(micros: u64) -> Duration {\n        Duration {\n            secs: micros / MICROS_PER_SEC,\n            nanos: ((micros % MICROS_PER_SEC) as u32) * NANOS_PER_MICRO,\n        }\n    }\n\n    /// Creates a new `Duration` from the specified number of nanoseconds.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_nanos(1_000_000_123);\n    ///\n    /// assert_eq!(1, duration.as_secs());\n    /// assert_eq!(123, duration.subsec_nanos());\n    /// ```\n    #[stable(feature = \"duration_extras\", since = \"1.27.0\")]\n    #[inline]\n    #[rustc_promotable]\n    pub const fn from_nanos(nanos: u64) -> Duration {\n        Duration {\n            secs: nanos / (NANOS_PER_SEC as u64),\n            nanos: (nanos % (NANOS_PER_SEC as u64)) as u32,\n        }\n    }\n\n    /// Returns the number of _whole_ seconds contained by this `Duration`.\n    ///\n    /// The returned value does not include the fractional (nanosecond) part of the\n    /// duration, which can be obtained using [`subsec_nanos`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::new(5, 730023852);\n    /// assert_eq!(duration.as_secs(), 5);\n    /// ```\n    ///\n    /// To determine the total number of seconds represented by the `Duration`,\n    /// use `as_secs` in combination with [`subsec_nanos`]:\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::new(5, 730023852);\n    ///\n    /// assert_eq!(5.730023852,\n    ///            duration.as_secs() as f64\n    ///            + duration.subsec_nanos() as f64 * 1e-9);\n    /// ```\n    ///\n    /// [`subsec_nanos`]: #method.subsec_nanos\n    #[stable(feature = \"duration\", since = \"1.3.0\")]\n    #[rustc_const_unstable(feature=\"duration_getters\")]\n    #[inline]\n    pub const fn as_secs(&self) -> u64 { self.secs }\n\n    /// Returns the fractional part of this `Duration`, in whole milliseconds.\n    ///\n    /// This method does **not** return the length of the duration when\n    /// represented by milliseconds. The returned number always represents a\n    /// fractional portion of a second (i.e. it is less than one thousand).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_millis(5432);\n    /// assert_eq!(duration.as_secs(), 5);\n    /// assert_eq!(duration.subsec_millis(), 432);\n    /// ```\n    #[stable(feature = \"duration_extras\", since = \"1.27.0\")]\n    #[rustc_const_unstable(feature=\"duration_getters\")]\n    #[inline]\n    pub const fn subsec_millis(&self) -> u32 { self.nanos / NANOS_PER_MILLI }\n\n    /// Returns the fractional part of this `Duration`, in whole microseconds.\n    ///\n    /// This method does **not** return the length of the duration when\n    /// represented by microseconds. The returned number always represents a\n    /// fractional portion of a second (i.e. it is less than one million).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_micros(1_234_567);\n    /// assert_eq!(duration.as_secs(), 1);\n    /// assert_eq!(duration.subsec_micros(), 234_567);\n    /// ```\n    #[stable(feature = \"duration_extras\", since = \"1.27.0\")]\n    #[rustc_const_unstable(feature=\"duration_getters\")]\n    #[inline]\n    pub const fn subsec_micros(&self) -> u32 { self.nanos / NANOS_PER_MICRO }\n\n    /// Returns the fractional part of this `Duration`, in nanoseconds.\n    ///\n    /// This method does **not** return the length of the duration when\n    /// represented by nanoseconds. The returned number always represents a\n    /// fractional portion of a second (i.e. it is less than one billion).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::from_millis(5010);\n    /// assert_eq!(duration.as_secs(), 5);\n    /// assert_eq!(duration.subsec_nanos(), 10_000_000);\n    /// ```\n    #[stable(feature = \"duration\", since = \"1.3.0\")]\n    #[rustc_const_unstable(feature=\"duration_getters\")]\n    #[inline]\n    pub const fn subsec_nanos(&self) -> u32 { self.nanos }\n\n    /// Returns the total number of whole milliseconds contained by this `Duration`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(duration_as_u128)]\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::new(5, 730023852);\n    /// assert_eq!(duration.as_millis(), 5730);\n    /// ```\n    #[unstable(feature = \"duration_as_u128\", issue = \"50202\")]\n    #[inline]\n    pub fn as_millis(&self) -> u128 {\n        self.secs as u128 * MILLIS_PER_SEC as u128 + (self.nanos / NANOS_PER_MILLI) as u128\n    }\n\n    /// Returns the total number of whole microseconds contained by this `Duration`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(duration_as_u128)]\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::new(5, 730023852);\n    /// assert_eq!(duration.as_micros(), 5730023);\n    /// ```\n    #[unstable(feature = \"duration_as_u128\", issue = \"50202\")]\n    #[inline]\n    pub fn as_micros(&self) -> u128 {\n        self.secs as u128 * MICROS_PER_SEC as u128 + (self.nanos / NANOS_PER_MICRO) as u128\n    }\n\n    /// Returns the total number of nanoseconds contained by this `Duration`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # #![feature(duration_as_u128)]\n    /// use std::time::Duration;\n    ///\n    /// let duration = Duration::new(5, 730023852);\n    /// assert_eq!(duration.as_nanos(), 5730023852);\n    /// ```\n    #[unstable(feature = \"duration_as_u128\", issue = \"50202\")]\n    #[inline]\n    pub fn as_nanos(&self) -> u128 {\n        self.secs as u128 * NANOS_PER_SEC as u128 + self.nanos as u128\n    }\n\n    /// Checked `Duration` addition. Computes `self + other`, returning [`None`]\n    /// if overflow occurred.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// assert_eq!(Duration::new(0, 0).checked_add(Duration::new(0, 1)), Some(Duration::new(0, 1)));\n    /// assert_eq!(Duration::new(1, 0).checked_add(Duration::new(std::u64::MAX, 0)), None);\n    /// ```\n    #[stable(feature = \"duration_checked_ops\", since = \"1.16.0\")]\n    #[inline]\n    pub fn checked_add(self, rhs: Duration) -> Option<Duration> {\n        if let Some(mut secs) = self.secs.checked_add(rhs.secs) {\n            let mut nanos = self.nanos + rhs.nanos;\n            if nanos >= NANOS_PER_SEC {\n                nanos -= NANOS_PER_SEC;\n                if let Some(new_secs) = secs.checked_add(1) {\n                    secs = new_secs;\n                } else {\n                    return None;\n                }\n            }\n            debug_assert!(nanos < NANOS_PER_SEC);\n            Some(Duration {\n                secs,\n                nanos,\n            })\n        } else {\n            None\n        }\n    }\n\n    /// Checked `Duration` subtraction. Computes `self - other`, returning [`None`]\n    /// if the result would be negative or if overflow occurred.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// assert_eq!(Duration::new(0, 1).checked_sub(Duration::new(0, 0)), Some(Duration::new(0, 1)));\n    /// assert_eq!(Duration::new(0, 0).checked_sub(Duration::new(0, 1)), None);\n    /// ```\n    #[stable(feature = \"duration_checked_ops\", since = \"1.16.0\")]\n    #[inline]\n    pub fn checked_sub(self, rhs: Duration) -> Option<Duration> {\n        if let Some(mut secs) = self.secs.checked_sub(rhs.secs) {\n            let nanos = if self.nanos >= rhs.nanos {\n                self.nanos - rhs.nanos\n            } else {\n                if let Some(sub_secs) = secs.checked_sub(1) {\n                    secs = sub_secs;\n                    self.nanos + NANOS_PER_SEC - rhs.nanos\n                } else {\n                    return None;\n                }\n            };\n            debug_assert!(nanos < NANOS_PER_SEC);\n            Some(Duration { secs, nanos })\n        } else {\n            None\n        }\n    }\n\n    /// Checked `Duration` multiplication. Computes `self * other`, returning\n    /// [`None`] if overflow occurred.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// assert_eq!(Duration::new(0, 500_000_001).checked_mul(2), Some(Duration::new(1, 2)));\n    /// assert_eq!(Duration::new(std::u64::MAX - 1, 0).checked_mul(2), None);\n    /// ```\n    #[stable(feature = \"duration_checked_ops\", since = \"1.16.0\")]\n    #[inline]\n    pub fn checked_mul(self, rhs: u32) -> Option<Duration> {\n        // Multiply nanoseconds as u64, because it cannot overflow that way.\n        let total_nanos = self.nanos as u64 * rhs as u64;\n        let extra_secs = total_nanos / (NANOS_PER_SEC as u64);\n        let nanos = (total_nanos % (NANOS_PER_SEC as u64)) as u32;\n        if let Some(secs) = self.secs\n            .checked_mul(rhs as u64)\n            .and_then(|s| s.checked_add(extra_secs)) {\n            debug_assert!(nanos < NANOS_PER_SEC);\n            Some(Duration {\n                secs,\n                nanos,\n            })\n        } else {\n            None\n        }\n    }\n\n    /// Checked `Duration` division. Computes `self / other`, returning [`None`]\n    /// if `other == 0`.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::time::Duration;\n    ///\n    /// assert_eq!(Duration::new(2, 0).checked_div(2), Some(Duration::new(1, 0)));\n    /// assert_eq!(Duration::new(1, 0).checked_div(2), Some(Duration::new(0, 500_000_000)));\n    /// assert_eq!(Duration::new(2, 0).checked_div(0), None);\n    /// ```\n    #[stable(feature = \"duration_checked_ops\", since = \"1.16.0\")]\n    #[inline]\n    pub fn checked_div(self, rhs: u32) -> Option<Duration> {\n        if rhs != 0 {\n            let secs = self.secs / (rhs as u64);\n            let carry = self.secs - secs * (rhs as u64);\n            let extra_nanos = carry * (NANOS_PER_SEC as u64) / (rhs as u64);\n            let nanos = self.nanos / rhs + (extra_nanos as u32);\n            debug_assert!(nanos < NANOS_PER_SEC);\n            Some(Duration { secs, nanos })\n        } else {\n            None\n        }\n    }\n\n    /// Returns the number of seconds contained by this `Duration` as `f64`.\n    ///\n    /// The returned value does include the fractional (nanosecond) part of the duration.\n    ///\n    /// # Examples\n    /// ```\n    /// #![feature(duration_float)]\n    /// use std::time::Duration;\n    ///\n    /// let dur = Duration::new(2, 700_000_000);\n    /// assert_eq!(dur.as_float_secs(), 2.7);\n    /// ```\n    #[unstable(feature = \"duration_float\", issue = \"54361\")]\n    #[inline]\n    pub fn as_float_secs(&self) -> f64 {\n        (self.secs as f64) + (self.nanos as f64) / (NANOS_PER_SEC as f64)\n    }\n\n    /// Creates a new `Duration` from the specified number of seconds.\n    ///\n    /// # Panics\n    /// This constructor will panic if `secs` is not finite, negative or overflows `Duration`.\n    ///\n    /// # Examples\n    /// ```\n    /// #![feature(duration_float)]\n    /// use std::time::Duration;\n    ///\n    /// let dur = Duration::from_float_secs(2.7);\n    /// assert_eq!(dur, Duration::new(2, 700_000_000));\n    /// ```\n    #[unstable(feature = \"duration_float\", issue = \"54361\")]\n    #[inline]\n    pub fn from_float_secs(secs: f64) -> Duration {\n        let nanos =  secs * (NANOS_PER_SEC as f64);\n        if !nanos.is_finite() {\n            panic!(\"got non-finite value when converting float to duration\");\n        }\n        if nanos >= MAX_NANOS_F64 {\n            panic!(\"overflow when converting float to duration\");\n        }\n        if nanos < 0.0 {\n            panic!(\"underflow when converting float to duration\");\n        }\n        let nanos =  nanos as u128;\n        Duration {\n            secs: (nanos / (NANOS_PER_SEC as u128)) as u64,\n            nanos: (nanos % (NANOS_PER_SEC as u128)) as u32,\n        }\n    }\n\n    /// Multiply `Duration` by `f64`.\n    ///\n    /// # Panics\n    /// This method will panic if result is not finite, negative or overflows `Duration`.\n    ///\n    /// # Examples\n    /// ```\n    /// #![feature(duration_float)]\n    /// use std::time::Duration;\n    ///\n    /// let dur = Duration::new(2, 700_000_000);\n    /// assert_eq!(dur.mul_f64(3.14), Duration::new(8, 478_000_000));\n    /// assert_eq!(dur.mul_f64(3.14e5), Duration::new(847_800, 0));\n    /// ```\n    #[unstable(feature = \"duration_float\", issue = \"54361\")]\n    #[inline]\n    pub fn mul_f64(self, rhs: f64) -> Duration {\n        Duration::from_float_secs(rhs * self.as_float_secs())\n    }\n\n    /// Divide `Duration` by `f64`.\n    ///\n    /// # Panics\n    /// This method will panic if result is not finite, negative or overflows `Duration`.\n    ///\n    /// # Examples\n    /// ```\n    /// #![feature(duration_float)]\n    /// use std::time::Duration;\n    ///\n    /// let dur = Duration::new(2, 700_000_000);\n    /// assert_eq!(dur.div_f64(3.14), Duration::new(0, 859_872_611));\n    /// // note that truncation is used, not rounding\n    /// assert_eq!(dur.div_f64(3.14e5), Duration::new(0, 8_598));\n    /// ```\n    #[unstable(feature = \"duration_float\", issue = \"54361\")]\n    #[inline]\n    pub fn div_f64(self, rhs: f64) -> Duration {\n        Duration::from_float_secs(self.as_float_secs() / rhs)\n    }\n\n    /// Divide `Duration` by `Duration` and return `f64`.\n    ///\n    /// # Examples\n    /// ```\n    /// #![feature(duration_float)]\n    /// use std::time::Duration;\n    ///\n    /// let dur1 = Duration::new(2, 700_000_000);\n    /// let dur2 = Duration::new(5, 400_000_000);\n    /// assert_eq!(dur1.div_duration(dur2), 0.5);\n    /// ```\n    #[unstable(feature = \"duration_float\", issue = \"54361\")]\n    #[inline]\n    pub fn div_duration(self, rhs: Duration) -> f64 {\n        self.as_float_secs() / rhs.as_float_secs()\n    }\n}\n\n#[stable(feature = \"duration\", since = \"1.3.0\")]\nimpl Add for Duration {\n    type Output = Duration;\n\n    fn add(self, rhs: Duration) -> Duration {\n        self.checked_add(rhs).expect(\"overflow when adding durations\")\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl AddAssign for Duration {\n    fn add_assign(&mut self, rhs: Duration) {\n        *self = *self + rhs;\n    }\n}\n\n#[stable(feature = \"duration\", since = \"1.3.0\")]\nimpl Sub for Duration {\n    type Output = Duration;\n\n    fn sub(self, rhs: Duration) -> Duration {\n        self.checked_sub(rhs).expect(\"overflow when subtracting durations\")\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl SubAssign for Duration {\n    fn sub_assign(&mut self, rhs: Duration) {\n        *self = *self - rhs;\n    }\n}\n\n#[stable(feature = \"duration\", since = \"1.3.0\")]\nimpl Mul<u32> for Duration {\n    type Output = Duration;\n\n    fn mul(self, rhs: u32) -> Duration {\n        self.checked_mul(rhs).expect(\"overflow when multiplying duration by scalar\")\n    }\n}\n\n#[stable(feature = \"symmetric_u32_duration_mul\", since = \"1.31.0\")]\nimpl Mul<Duration> for u32 {\n    type Output = Duration;\n\n    fn mul(self, rhs: Duration) -> Duration {\n        rhs * self\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl MulAssign<u32> for Duration {\n    fn mul_assign(&mut self, rhs: u32) {\n        *self = *self * rhs;\n    }\n}\n\n#[stable(feature = \"duration\", since = \"1.3.0\")]\nimpl Div<u32> for Duration {\n    type Output = Duration;\n\n    fn div(self, rhs: u32) -> Duration {\n        self.checked_div(rhs).expect(\"divide by zero error when dividing duration by scalar\")\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl DivAssign<u32> for Duration {\n    fn div_assign(&mut self, rhs: u32) {\n        *self = *self / rhs;\n    }\n}\n\nmacro_rules! sum_durations {\n    ($iter:expr) => {{\n        let mut total_secs: u64 = 0;\n        let mut total_nanos: u64 = 0;\n\n        for entry in $iter {\n            total_secs = total_secs\n                .checked_add(entry.secs)\n                .expect(\"overflow in iter::sum over durations\");\n            total_nanos = match total_nanos.checked_add(entry.nanos as u64) {\n                Some(n) => n,\n                None => {\n                    total_secs = total_secs\n                        .checked_add(total_nanos / NANOS_PER_SEC as u64)\n                        .expect(\"overflow in iter::sum over durations\");\n                    (total_nanos % NANOS_PER_SEC as u64) + entry.nanos as u64\n                }\n            };\n        }\n        total_secs = total_secs\n            .checked_add(total_nanos / NANOS_PER_SEC as u64)\n            .expect(\"overflow in iter::sum over durations\");\n        total_nanos = total_nanos % NANOS_PER_SEC as u64;\n        Duration {\n            secs: total_secs,\n            nanos: total_nanos as u32,\n        }\n    }};\n}\n\n#[stable(feature = \"duration_sum\", since = \"1.16.0\")]\nimpl Sum for Duration {\n    fn sum<I: Iterator<Item=Duration>>(iter: I) -> Duration {\n        sum_durations!(iter)\n    }\n}\n\n#[stable(feature = \"duration_sum\", since = \"1.16.0\")]\nimpl<'a> Sum<&'a Duration> for Duration {\n    fn sum<I: Iterator<Item=&'a Duration>>(iter: I) -> Duration {\n        sum_durations!(iter)\n    }\n}\n\n#[stable(feature = \"duration_debug_impl\", since = \"1.27.0\")]\nimpl fmt::Debug for Duration {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        /// Formats a floating point number in decimal notation.\n        ///\n        /// The number is given as the `integer_part` and a fractional part.\n        /// The value of the fractional part is `fractional_part / divisor`. So\n        /// `integer_part` = 3, `fractional_part` = 12 and `divisor` = 100\n        /// represents the number `3.012`. Trailing zeros are omitted.\n        ///\n        /// `divisor` must not be above 100_000_000. It also should be a power\n        /// of 10, everything else doesn't make sense. `fractional_part` has\n        /// to be less than `10 * divisor`!\n        fn fmt_decimal(\n            f: &mut fmt::Formatter,\n            mut integer_part: u64,\n            mut fractional_part: u32,\n            mut divisor: u32,\n        ) -> fmt::Result {\n            // Encode the fractional part into a temporary buffer. The buffer\n            // only need to hold 9 elements, because `fractional_part` has to\n            // be smaller than 10^9. The buffer is prefilled with '0' digits\n            // to simplify the code below.\n            let mut buf = [b'0'; 9];\n\n            // The next digit is written at this position\n            let mut pos = 0;\n\n            // We keep writing digits into the buffer while there are non-zero\n            // digits left and we haven't written enough digits yet.\n            while fractional_part > 0 && pos < f.precision().unwrap_or(9) {\n                // Write new digit into the buffer\n                buf[pos] = b'0' + (fractional_part / divisor) as u8;\n\n                fractional_part %= divisor;\n                divisor /= 10;\n                pos += 1;\n            }\n\n            // If a precision < 9 was specified, there may be some non-zero\n            // digits left that weren't written into the buffer. In that case we\n            // need to perform rounding to match the semantics of printing\n            // normal floating point numbers. However, we only need to do work\n            // when rounding up. This happens if the first digit of the\n            // remaining ones is >= 5.\n            if fractional_part > 0 && fractional_part >= divisor * 5 {\n                // Round up the number contained in the buffer. We go through\n                // the buffer backwards and keep track of the carry.\n                let mut rev_pos = pos;\n                let mut carry = true;\n                while carry && rev_pos > 0 {\n                    rev_pos -= 1;\n\n                    // If the digit in the buffer is not '9', we just need to\n                    // increment it and can stop then (since we don't have a\n                    // carry anymore). Otherwise, we set it to '0' (overflow)\n                    // and continue.\n                    if buf[rev_pos] < b'9' {\n                        buf[rev_pos] += 1;\n                        carry = false;\n                    } else {\n                        buf[rev_pos] = b'0';\n                    }\n                }\n\n                // If we still have the carry bit set, that means that we set\n                // the whole buffer to '0's and need to increment the integer\n                // part.\n                if carry {\n                    integer_part += 1;\n                }\n            }\n\n            // Determine the end of the buffer: if precision is set, we just\n            // use as many digits from the buffer (capped to 9). If it isn't\n            // set, we only use all digits up to the last non-zero one.\n            let end = f.precision().map(|p| ::cmp::min(p, 9)).unwrap_or(pos);\n\n            // If we haven't emitted a single fractional digit and the precision\n            // wasn't set to a non-zero value, we don't print the decimal point.\n            if end == 0 {\n                write!(f, \"{}\", integer_part)\n            } else {\n                // We are only writing ASCII digits into the buffer and it was\n                // initialized with '0's, so it contains valid UTF8.\n                let s = unsafe {\n                    ::str::from_utf8_unchecked(&buf[..end])\n                };\n\n                // If the user request a precision > 9, we pad '0's at the end.\n                let w = f.precision().unwrap_or(pos);\n                write!(f, \"{}.{:0<width$}\", integer_part, s, width = w)\n            }\n        }\n\n        // Print leading '+' sign if requested\n        if f.sign_plus() {\n            write!(f, \"+\")?;\n        }\n\n        if self.secs > 0 {\n            fmt_decimal(f, self.secs, self.nanos, 100_000_000)?;\n            f.write_str(\"s\")\n        } else if self.nanos >= 1_000_000 {\n            fmt_decimal(f, self.nanos as u64 / 1_000_000, self.nanos % 1_000_000, 100_000)?;\n            f.write_str(\"ms\")\n        } else if self.nanos >= 1_000 {\n            fmt_decimal(f, self.nanos as u64 / 1_000, self.nanos % 1_000, 100)?;\n            f.write_str(\"\u00b5s\")\n        } else {\n            fmt_decimal(f, self.nanos as u64, 0, 1)?;\n            f.write_str(\"ns\")\n        }\n    }\n}\n","// Copyright 2012 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// The version of the call operator that takes an immutable receiver.\n///\n/// Instances of `Fn` can be called repeatedly without mutating state.\n///\n/// *This trait (`Fn`) is not to be confused with [function pointers][]\n/// (`fn`).*\n///\n/// `Fn` is implemented automatically by closures which only take immutable\n/// references to captured variables or don't capture anything at all, as well\n/// as (safe) [function pointers][] (with some caveats, see their documentation\n/// for more details). Additionally, for any type `F` that implements `Fn`, `&F`\n/// implements `Fn`, too.\n///\n/// Since both [`FnMut`] and [`FnOnce`] are supertraits of `Fn`, any\n/// instance of `Fn` can be used as a parameter where a [`FnMut`] or [`FnOnce`]\n/// is expected.\n///\n/// Use `Fn` as a bound when you want to accept a parameter of function-like\n/// type and need to call it repeatedly and without mutating state (e.g. when\n/// calling it concurrently). If you do not need such strict requirements, use\n/// [`FnMut`] or [`FnOnce`] as bounds.\n///\n/// See the [chapter on closures in *The Rust Programming Language*][book] for\n/// some more information on this topic.\n///\n/// Also of note is the special syntax for `Fn` traits (e.g.\n/// `Fn(usize, bool) -> usize`). Those interested in the technical details of\n/// this can refer to [the relevant section in the *Rustonomicon*][nomicon].\n///\n/// [book]: ../../book/second-edition/ch13-01-closures.html\n/// [`FnMut`]: trait.FnMut.html\n/// [`FnOnce`]: trait.FnOnce.html\n/// [function pointers]: ../../std/primitive.fn.html\n/// [nomicon]: ../../nomicon/hrtb.html\n///\n/// # Examples\n///\n/// ## Calling a closure\n///\n/// ```\n/// let square = |x| x * x;\n/// assert_eq!(square(5), 25);\n/// ```\n///\n/// ## Using a `Fn` parameter\n///\n/// ```\n/// fn call_with_one<F>(func: F) -> usize\n///     where F: Fn(usize) -> usize {\n///     func(1)\n/// }\n///\n/// let double = |x| x * 2;\n/// assert_eq!(call_with_one(double), 2);\n/// ```\n#[lang = \"fn\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_paren_sugar]\n#[rustc_on_unimplemented(\n    on(Args=\"()\", note=\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}\"),\n    message=\"expected a `{Fn}<{Args}>` closure, found `{Self}`\",\n    label=\"expected an `Fn<{Args}>` closure, found `{Self}`\",\n)]\n#[fundamental] // so that regex can rely that `&str: !FnMut`\npub trait Fn<Args> : FnMut<Args> {\n    /// Performs the call operation.\n    #[unstable(feature = \"fn_traits\", issue = \"29625\")]\n    extern \"rust-call\" fn call(&self, args: Args) -> Self::Output;\n}\n\n/// The version of the call operator that takes a mutable receiver.\n///\n/// Instances of `FnMut` can be called repeatedly and may mutate state.\n///\n/// `FnMut` is implemented automatically by closures which take mutable\n/// references to captured variables, as well as all types that implement\n/// [`Fn`], e.g. (safe) [function pointers][] (since `FnMut` is a supertrait of\n/// [`Fn`]). Additionally, for any type `F` that implements `FnMut`, `&mut F`\n/// implements `FnMut`, too.\n///\n/// Since [`FnOnce`] is a supertrait of `FnMut`, any instance of `FnMut` can be\n/// used where a [`FnOnce`] is expected, and since [`Fn`] is a subtrait of\n/// `FnMut`, any instance of [`Fn`] can be used where `FnMut` is expected.\n///\n/// Use `FnMut` as a bound when you want to accept a parameter of function-like\n/// type and need to call it repeatedly, while allowing it to mutate state.\n/// If you don't want the parameter to mutate state, use [`Fn`] as a\n/// bound; if you don't need to call it repeatedly, use [`FnOnce`].\n///\n/// See the [chapter on closures in *The Rust Programming Language*][book] for\n/// some more information on this topic.\n///\n/// Also of note is the special syntax for `Fn` traits (e.g.\n/// `Fn(usize, bool) -> usize`). Those interested in the technical details of\n/// this can refer to [the relevant section in the *Rustonomicon*][nomicon].\n///\n/// [book]: ../../book/second-edition/ch13-01-closures.html\n/// [`Fn`]: trait.Fn.html\n/// [`FnOnce`]: trait.FnOnce.html\n/// [function pointers]: ../../std/primitive.fn.html\n/// [nomicon]: ../../nomicon/hrtb.html\n///\n/// # Examples\n///\n/// ## Calling a mutably capturing closure\n///\n/// ```\n/// let mut x = 5;\n/// {\n///     let mut square_x = || x *= x;\n///     square_x();\n/// }\n/// assert_eq!(x, 25);\n/// ```\n///\n/// ## Using a `FnMut` parameter\n///\n/// ```\n/// fn do_twice<F>(mut func: F)\n///     where F: FnMut()\n/// {\n///     func();\n///     func();\n/// }\n///\n/// let mut x: usize = 1;\n/// {\n///     let add_two_to_x = || x += 2;\n///     do_twice(add_two_to_x);\n/// }\n///\n/// assert_eq!(x, 5);\n/// ```\n#[lang = \"fn_mut\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_paren_sugar]\n#[rustc_on_unimplemented(\n    on(Args=\"()\", note=\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}\"),\n    message=\"expected a `{FnMut}<{Args}>` closure, found `{Self}`\",\n    label=\"expected an `FnMut<{Args}>` closure, found `{Self}`\",\n)]\n#[fundamental] // so that regex can rely that `&str: !FnMut`\npub trait FnMut<Args> : FnOnce<Args> {\n    /// Performs the call operation.\n    #[unstable(feature = \"fn_traits\", issue = \"29625\")]\n    extern \"rust-call\" fn call_mut(&mut self, args: Args) -> Self::Output;\n}\n\n/// The version of the call operator that takes a by-value receiver.\n///\n/// Instances of `FnOnce` can be called, but might not be callable multiple\n/// times. Because of this, if the only thing known about a type is that it\n/// implements `FnOnce`, it can only be called once.\n///\n/// `FnOnce` is implemented automatically by closure that might consume captured\n/// variables, as well as all types that implement [`FnMut`], e.g. (safe)\n/// [function pointers][] (since `FnOnce` is a supertrait of [`FnMut`]).\n///\n/// Since both [`Fn`] and [`FnMut`] are subtraits of `FnOnce`, any instance of\n/// [`Fn`] or [`FnMut`] can be used where a `FnOnce` is expected.\n///\n/// Use `FnOnce` as a bound when you want to accept a parameter of function-like\n/// type and only need to call it once. If you need to call the parameter\n/// repeatedly, use [`FnMut`] as a bound; if you also need it to not mutate\n/// state, use [`Fn`].\n///\n/// See the [chapter on closures in *The Rust Programming Language*][book] for\n/// some more information on this topic.\n///\n/// Also of note is the special syntax for `Fn` traits (e.g.\n/// `Fn(usize, bool) -> usize`). Those interested in the technical details of\n/// this can refer to [the relevant section in the *Rustonomicon*][nomicon].\n///\n/// [book]: ../../book/second-edition/ch13-01-closures.html\n/// [`Fn`]: trait.Fn.html\n/// [`FnMut`]: trait.FnMut.html\n/// [function pointers]: ../../std/primitive.fn.html\n/// [nomicon]: ../../nomicon/hrtb.html\n///\n/// # Examples\n///\n/// ## Calling a by-value closure\n///\n/// ```\n/// let x = 5;\n/// let square_x = move || x * x;\n/// assert_eq!(square_x(), 25);\n/// ```\n///\n/// ## Using a `FnOnce` parameter\n///\n/// ```\n/// fn consume_with_relish<F>(func: F)\n///     where F: FnOnce() -> String\n/// {\n///     // `func` consumes its captured variables, so it cannot be run more\n///     // than once.\n///     println!(\"Consumed: {}\", func());\n///\n///     println!(\"Delicious!\");\n///\n///     // Attempting to invoke `func()` again will throw a `use of moved\n///     // value` error for `func`.\n/// }\n///\n/// let x = String::from(\"x\");\n/// let consume_and_return_x = move || x;\n/// consume_with_relish(consume_and_return_x);\n///\n/// // `consume_and_return_x` can no longer be invoked at this point\n/// ```\n#[lang = \"fn_once\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_paren_sugar]\n#[rustc_on_unimplemented(\n    on(Args=\"()\", note=\"wrap the `{Self}` in a closure with no arguments: `|| {{ /* code */ }}\"),\n    message=\"expected a `{FnOnce}<{Args}>` closure, found `{Self}`\",\n    label=\"expected an `FnOnce<{Args}>` closure, found `{Self}`\",\n)]\n#[fundamental] // so that regex can rely that `&str: !FnMut`\npub trait FnOnce<Args> {\n    /// The returned type after the call operator is used.\n    #[stable(feature = \"fn_once_output\", since = \"1.12.0\")]\n    type Output;\n\n    /// Performs the call operation.\n    #[unstable(feature = \"fn_traits\", issue = \"29625\")]\n    extern \"rust-call\" fn call_once(self, args: Args) -> Self::Output;\n}\n\nmod impls {\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A,F:?Sized> Fn<A> for &F\n        where F : Fn<A>\n    {\n        extern \"rust-call\" fn call(&self, args: A) -> F::Output {\n            (**self).call(args)\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A,F:?Sized> FnMut<A> for &F\n        where F : Fn<A>\n    {\n        extern \"rust-call\" fn call_mut(&mut self, args: A) -> F::Output {\n            (**self).call(args)\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A,F:?Sized> FnOnce<A> for &F\n        where F : Fn<A>\n    {\n        type Output = F::Output;\n\n        extern \"rust-call\" fn call_once(self, args: A) -> F::Output {\n            (*self).call(args)\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A,F:?Sized> FnMut<A> for &mut F\n        where F : FnMut<A>\n    {\n        extern \"rust-call\" fn call_mut(&mut self, args: A) -> F::Output {\n            (*self).call_mut(args)\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    impl<A,F:?Sized> FnOnce<A> for &mut F\n        where F : FnMut<A>\n    {\n        type Output = F::Output;\n        extern \"rust-call\" fn call_once(self, args: A) -> F::Output {\n            (*self).call_mut(args)\n        }\n    }\n}\n","// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! An implementation of SipHash.\n\n#![allow(deprecated)]\n\nuse marker::PhantomData;\nuse ptr;\nuse cmp;\nuse mem;\n\n/// An implementation of SipHash 1-3.\n///\n/// This is currently the default hashing function used by standard library\n/// (eg. `collections::HashMap` uses it by default).\n///\n/// See: <https://131002.net/siphash>\n#[unstable(feature = \"hashmap_internals\", issue = \"0\")]\n#[rustc_deprecated(since = \"1.13.0\",\n                   reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n#[derive(Debug, Clone, Default)]\n#[doc(hidden)]\npub struct SipHasher13 {\n    hasher: Hasher<Sip13Rounds>,\n}\n\n/// An implementation of SipHash 2-4.\n///\n/// See: <https://131002.net/siphash/>\n#[unstable(feature = \"hashmap_internals\", issue = \"0\")]\n#[rustc_deprecated(since = \"1.13.0\",\n                   reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n#[derive(Debug, Clone, Default)]\nstruct SipHasher24 {\n    hasher: Hasher<Sip24Rounds>,\n}\n\n/// An implementation of SipHash 2-4.\n///\n/// See: <https://131002.net/siphash/>\n///\n/// SipHash is a general-purpose hashing function: it runs at a good\n/// speed (competitive with Spooky and City) and permits strong _keyed_\n/// hashing. This lets you key your hashtables from a strong RNG, such as\n/// [`rand::os::OsRng`](https://doc.rust-lang.org/rand/rand/os/struct.OsRng.html).\n///\n/// Although the SipHash algorithm is considered to be generally strong,\n/// it is not intended for cryptographic purposes. As such, all\n/// cryptographic uses of this implementation are _strongly discouraged_.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(since = \"1.13.0\",\n                   reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n#[derive(Debug, Clone, Default)]\npub struct SipHasher(SipHasher24);\n\n#[derive(Debug)]\nstruct Hasher<S: Sip> {\n    k0: u64,\n    k1: u64,\n    length: usize, // how many bytes we've processed\n    state: State, // hash State\n    tail: u64, // unprocessed bytes le\n    ntail: usize, // how many bytes in tail are valid\n    _marker: PhantomData<S>,\n}\n\n#[derive(Debug, Clone, Copy)]\n#[repr(C)]\nstruct State {\n    // v0, v2 and v1, v3 show up in pairs in the algorithm,\n    // and simd implementations of SipHash will use vectors\n    // of v02 and v13. By placing them in this order in the struct,\n    // the compiler can pick up on just a few simd optimizations by itself.\n    v0: u64,\n    v2: u64,\n    v1: u64,\n    v3: u64,\n}\n\nmacro_rules! compress {\n    ($state:expr) => ({\n        compress!($state.v0, $state.v1, $state.v2, $state.v3)\n    });\n    ($v0:expr, $v1:expr, $v2:expr, $v3:expr) =>\n    ({\n        $v0 = $v0.wrapping_add($v1); $v1 = $v1.rotate_left(13); $v1 ^= $v0;\n        $v0 = $v0.rotate_left(32);\n        $v2 = $v2.wrapping_add($v3); $v3 = $v3.rotate_left(16); $v3 ^= $v2;\n        $v0 = $v0.wrapping_add($v3); $v3 = $v3.rotate_left(21); $v3 ^= $v0;\n        $v2 = $v2.wrapping_add($v1); $v1 = $v1.rotate_left(17); $v1 ^= $v2;\n        $v2 = $v2.rotate_left(32);\n    });\n}\n\n/// Load an integer of the desired type from a byte stream, in LE order. Uses\n/// `copy_nonoverlapping` to let the compiler generate the most efficient way\n/// to load it from a possibly unaligned address.\n///\n/// Unsafe because: unchecked indexing at i..i+size_of(int_ty)\nmacro_rules! load_int_le {\n    ($buf:expr, $i:expr, $int_ty:ident) =>\n    ({\n       debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());\n       let mut data = 0 as $int_ty;\n       ptr::copy_nonoverlapping($buf.get_unchecked($i),\n                                &mut data as *mut _ as *mut u8,\n                                mem::size_of::<$int_ty>());\n       data.to_le()\n    });\n}\n\n/// Load an u64 using up to 7 bytes of a byte slice.\n///\n/// Unsafe because: unchecked indexing at start..start+len\n#[inline]\nunsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {\n    debug_assert!(len < 8);\n    let mut i = 0; // current byte index (from LSB) in the output u64\n    let mut out = 0;\n    if i + 3 < len {\n        out = load_int_le!(buf, start + i, u32) as u64;\n        i += 4;\n    }\n    if i + 1 < len {\n        out |= (load_int_le!(buf, start + i, u16) as u64) << (i * 8);\n        i += 2\n    }\n    if i < len {\n        out |= (*buf.get_unchecked(start + i) as u64) << (i * 8);\n        i += 1;\n    }\n    debug_assert_eq!(i, len);\n    out\n}\n\nimpl SipHasher {\n    /// Creates a new `SipHasher` with the two initial keys set to 0.\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.13.0\",\n                       reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n    pub fn new() -> SipHasher {\n        SipHasher::new_with_keys(0, 0)\n    }\n\n    /// Creates a `SipHasher` that is keyed off the provided keys.\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.13.0\",\n                       reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher {\n        SipHasher(SipHasher24 {\n            hasher: Hasher::new_with_keys(key0, key1)\n        })\n    }\n}\n\nimpl SipHasher13 {\n    /// Creates a new `SipHasher13` with the two initial keys set to 0.\n    #[inline]\n    #[unstable(feature = \"hashmap_internals\", issue = \"0\")]\n    #[rustc_deprecated(since = \"1.13.0\",\n                       reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n    pub fn new() -> SipHasher13 {\n        SipHasher13::new_with_keys(0, 0)\n    }\n\n    /// Creates a `SipHasher13` that is keyed off the provided keys.\n    #[inline]\n    #[unstable(feature = \"hashmap_internals\", issue = \"0\")]\n    #[rustc_deprecated(since = \"1.13.0\",\n                       reason = \"use `std::collections::hash_map::DefaultHasher` instead\")]\n    pub fn new_with_keys(key0: u64, key1: u64) -> SipHasher13 {\n        SipHasher13 {\n            hasher: Hasher::new_with_keys(key0, key1)\n        }\n    }\n}\n\nimpl<S: Sip> Hasher<S> {\n    #[inline]\n    fn new_with_keys(key0: u64, key1: u64) -> Hasher<S> {\n        let mut state = Hasher {\n            k0: key0,\n            k1: key1,\n            length: 0,\n            state: State {\n                v0: 0,\n                v1: 0,\n                v2: 0,\n                v3: 0,\n            },\n            tail: 0,\n            ntail: 0,\n            _marker: PhantomData,\n        };\n        state.reset();\n        state\n    }\n\n    #[inline]\n    fn reset(&mut self) {\n        self.length = 0;\n        self.state.v0 = self.k0 ^ 0x736f6d6570736575;\n        self.state.v1 = self.k1 ^ 0x646f72616e646f6d;\n        self.state.v2 = self.k0 ^ 0x6c7967656e657261;\n        self.state.v3 = self.k1 ^ 0x7465646279746573;\n        self.ntail = 0;\n    }\n\n    // Specialized write function that is only valid for buffers with len <= 8.\n    // It's used to force inlining of write_u8 and write_usize, those would normally be inlined\n    // except for composite types (that includes slices and str hashing because of delimiter).\n    // Without this extra push the compiler is very reluctant to inline delimiter writes,\n    // degrading performance substantially for the most common use cases.\n    #[inline]\n    fn short_write(&mut self, msg: &[u8]) {\n        debug_assert!(msg.len() <= 8);\n        let length = msg.len();\n        self.length += length;\n\n        let needed = 8 - self.ntail;\n        let fill = cmp::min(length, needed);\n        if fill == 8 {\n            self.tail = unsafe { load_int_le!(msg, 0, u64) };\n        } else {\n            self.tail |= unsafe { u8to64_le(msg, 0, fill) } << (8 * self.ntail);\n            if length < needed {\n                self.ntail += length;\n                return;\n            }\n        }\n        self.state.v3 ^= self.tail;\n        S::c_rounds(&mut self.state);\n        self.state.v0 ^= self.tail;\n\n        // Buffered tail is now flushed, process new input.\n        self.ntail = length - needed;\n        self.tail = unsafe { u8to64_le(msg, needed, self.ntail) };\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl super::Hasher for SipHasher {\n    #[inline]\n    fn write(&mut self, msg: &[u8]) {\n        self.0.hasher.write(msg)\n    }\n\n    #[inline]\n    fn finish(&self) -> u64 {\n        self.0.hasher.finish()\n    }\n}\n\n#[unstable(feature = \"hashmap_internals\", issue = \"0\")]\nimpl super::Hasher for SipHasher13 {\n    #[inline]\n    fn write(&mut self, msg: &[u8]) {\n        self.hasher.write(msg)\n    }\n\n    #[inline]\n    fn finish(&self) -> u64 {\n        self.hasher.finish()\n    }\n}\n\nimpl<S: Sip> super::Hasher for Hasher<S> {\n    // see short_write comment for explanation\n    #[inline]\n    fn write_usize(&mut self, i: usize) {\n        let bytes = unsafe {\n            ::slice::from_raw_parts(&i as *const usize as *const u8, mem::size_of::<usize>())\n        };\n        self.short_write(bytes);\n    }\n\n    // see short_write comment for explanation\n    #[inline]\n    fn write_u8(&mut self, i: u8) {\n        self.short_write(&[i]);\n    }\n\n    #[inline]\n    fn write(&mut self, msg: &[u8]) {\n        let length = msg.len();\n        self.length += length;\n\n        let mut needed = 0;\n\n        if self.ntail != 0 {\n            needed = 8 - self.ntail;\n            self.tail |= unsafe { u8to64_le(msg, 0, cmp::min(length, needed)) } << 8 * self.ntail;\n            if length < needed {\n                self.ntail += length;\n                return\n            } else {\n                self.state.v3 ^= self.tail;\n                S::c_rounds(&mut self.state);\n                self.state.v0 ^= self.tail;\n                self.ntail = 0;\n            }\n        }\n\n        // Buffered tail is now flushed, process new input.\n        let len = length - needed;\n        let left = len & 0x7;\n\n        let mut i = needed;\n        while i < len - left {\n            let mi = unsafe { load_int_le!(msg, i, u64) };\n\n            self.state.v3 ^= mi;\n            S::c_rounds(&mut self.state);\n            self.state.v0 ^= mi;\n\n            i += 8;\n        }\n\n        self.tail = unsafe { u8to64_le(msg, i, left) };\n        self.ntail = left;\n    }\n\n    #[inline]\n    fn finish(&self) -> u64 {\n        let mut state = self.state;\n\n        let b: u64 = ((self.length as u64 & 0xff) << 56) | self.tail;\n\n        state.v3 ^= b;\n        S::c_rounds(&mut state);\n        state.v0 ^= b;\n\n        state.v2 ^= 0xff;\n        S::d_rounds(&mut state);\n\n        state.v0 ^ state.v1 ^ state.v2 ^ state.v3\n    }\n}\n\nimpl<S: Sip> Clone for Hasher<S> {\n    #[inline]\n    fn clone(&self) -> Hasher<S> {\n        Hasher {\n            k0: self.k0,\n            k1: self.k1,\n            length: self.length,\n            state: self.state,\n            tail: self.tail,\n            ntail: self.ntail,\n            _marker: self._marker,\n        }\n    }\n}\n\nimpl<S: Sip> Default for Hasher<S> {\n    /// Creates a `Hasher<S>` with the two initial keys set to 0.\n    #[inline]\n    fn default() -> Hasher<S> {\n        Hasher::new_with_keys(0, 0)\n    }\n}\n\n#[doc(hidden)]\ntrait Sip {\n    fn c_rounds(_: &mut State);\n    fn d_rounds(_: &mut State);\n}\n\n#[derive(Debug, Clone, Default)]\nstruct Sip13Rounds;\n\nimpl Sip for Sip13Rounds {\n    #[inline]\n    fn c_rounds(state: &mut State) {\n        compress!(state);\n    }\n\n    #[inline]\n    fn d_rounds(state: &mut State) {\n        compress!(state);\n        compress!(state);\n        compress!(state);\n    }\n}\n\n#[derive(Debug, Clone, Default)]\nstruct Sip24Rounds;\n\nimpl Sip for Sip24Rounds {\n    #[inline]\n    fn c_rounds(state: &mut State) {\n        compress!(state);\n        compress!(state);\n    }\n\n    #[inline]\n    fn d_rounds(state: &mut State) {\n        compress!(state);\n        compress!(state);\n        compress!(state);\n        compress!(state);\n    }\n}\n","// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Composable external iteration.\n//!\n//! If you've found yourself with a collection of some kind, and needed to\n//! perform an operation on the elements of said collection, you'll quickly run\n//! into 'iterators'. Iterators are heavily used in idiomatic Rust code, so\n//! it's worth becoming familiar with them.\n//!\n//! Before explaining more, let's talk about how this module is structured:\n//!\n//! # Organization\n//!\n//! This module is largely organized by type:\n//!\n//! * [Traits] are the core portion: these traits define what kind of iterators\n//!   exist and what you can do with them. The methods of these traits are worth\n//!   putting some extra study time into.\n//! * [Functions] provide some helpful ways to create some basic iterators.\n//! * [Structs] are often the return types of the various methods on this\n//!   module's traits. You'll usually want to look at the method that creates\n//!   the `struct`, rather than the `struct` itself. For more detail about why,\n//!   see '[Implementing Iterator](#implementing-iterator)'.\n//!\n//! [Traits]: #traits\n//! [Functions]: #functions\n//! [Structs]: #structs\n//!\n//! That's it! Let's dig into iterators.\n//!\n//! # Iterator\n//!\n//! The heart and soul of this module is the [`Iterator`] trait. The core of\n//! [`Iterator`] looks like this:\n//!\n//! ```\n//! trait Iterator {\n//!     type Item;\n//!     fn next(&mut self) -> Option<Self::Item>;\n//! }\n//! ```\n//!\n//! An iterator has a method, [`next`], which when called, returns an\n//! [`Option`]`<Item>`. [`next`] will return `Some(Item)` as long as there\n//! are elements, and once they've all been exhausted, will return `None` to\n//! indicate that iteration is finished. Individual iterators may choose to\n//! resume iteration, and so calling [`next`] again may or may not eventually\n//! start returning `Some(Item)` again at some point.\n//!\n//! [`Iterator`]'s full definition includes a number of other methods as well,\n//! but they are default methods, built on top of [`next`], and so you get\n//! them for free.\n//!\n//! Iterators are also composable, and it's common to chain them together to do\n//! more complex forms of processing. See the [Adapters](#adapters) section\n//! below for more details.\n//!\n//! [`Iterator`]: trait.Iterator.html\n//! [`next`]: trait.Iterator.html#tymethod.next\n//! [`Option`]: ../../std/option/enum.Option.html\n//!\n//! # The three forms of iteration\n//!\n//! There are three common methods which can create iterators from a collection:\n//!\n//! * `iter()`, which iterates over `&T`.\n//! * `iter_mut()`, which iterates over `&mut T`.\n//! * `into_iter()`, which iterates over `T`.\n//!\n//! Various things in the standard library may implement one or more of the\n//! three, where appropriate.\n//!\n//! # Implementing Iterator\n//!\n//! Creating an iterator of your own involves two steps: creating a `struct` to\n//! hold the iterator's state, and then `impl`ementing [`Iterator`] for that\n//! `struct`. This is why there are so many `struct`s in this module: there is\n//! one for each iterator and iterator adapter.\n//!\n//! Let's make an iterator named `Counter` which counts from `1` to `5`:\n//!\n//! ```\n//! // First, the struct:\n//!\n//! /// An iterator which counts from one to five\n//! struct Counter {\n//!     count: usize,\n//! }\n//!\n//! // we want our count to start at one, so let's add a new() method to help.\n//! // This isn't strictly necessary, but is convenient. Note that we start\n//! // `count` at zero, we'll see why in `next()`'s implementation below.\n//! impl Counter {\n//!     fn new() -> Counter {\n//!         Counter { count: 0 }\n//!     }\n//! }\n//!\n//! // Then, we implement `Iterator` for our `Counter`:\n//!\n//! impl Iterator for Counter {\n//!     // we will be counting with usize\n//!     type Item = usize;\n//!\n//!     // next() is the only required method\n//!     fn next(&mut self) -> Option<usize> {\n//!         // increment our count. This is why we started at zero.\n//!         self.count += 1;\n//!\n//!         // check to see if we've finished counting or not.\n//!         if self.count < 6 {\n//!             Some(self.count)\n//!         } else {\n//!             None\n//!         }\n//!     }\n//! }\n//!\n//! // And now we can use it!\n//!\n//! let mut counter = Counter::new();\n//!\n//! let x = counter.next().unwrap();\n//! println!(\"{}\", x);\n//!\n//! let x = counter.next().unwrap();\n//! println!(\"{}\", x);\n//!\n//! let x = counter.next().unwrap();\n//! println!(\"{}\", x);\n//!\n//! let x = counter.next().unwrap();\n//! println!(\"{}\", x);\n//!\n//! let x = counter.next().unwrap();\n//! println!(\"{}\", x);\n//! ```\n//!\n//! This will print `1` through `5`, each on their own line.\n//!\n//! Calling `next()` this way gets repetitive. Rust has a construct which can\n//! call `next()` on your iterator, until it reaches `None`. Let's go over that\n//! next.\n//!\n//! # for Loops and IntoIterator\n//!\n//! Rust's `for` loop syntax is actually sugar for iterators. Here's a basic\n//! example of `for`:\n//!\n//! ```\n//! let values = vec![1, 2, 3, 4, 5];\n//!\n//! for x in values {\n//!     println!(\"{}\", x);\n//! }\n//! ```\n//!\n//! This will print the numbers one through five, each on their own line. But\n//! you'll notice something here: we never called anything on our vector to\n//! produce an iterator. What gives?\n//!\n//! There's a trait in the standard library for converting something into an\n//! iterator: [`IntoIterator`]. This trait has one method, [`into_iter`],\n//! which converts the thing implementing [`IntoIterator`] into an iterator.\n//! Let's take a look at that `for` loop again, and what the compiler converts\n//! it into:\n//!\n//! [`IntoIterator`]: trait.IntoIterator.html\n//! [`into_iter`]: trait.IntoIterator.html#tymethod.into_iter\n//!\n//! ```\n//! let values = vec![1, 2, 3, 4, 5];\n//!\n//! for x in values {\n//!     println!(\"{}\", x);\n//! }\n//! ```\n//!\n//! Rust de-sugars this into:\n//!\n//! ```\n//! let values = vec![1, 2, 3, 4, 5];\n//! {\n//!     let result = match IntoIterator::into_iter(values) {\n//!         mut iter => loop {\n//!             let next;\n//!             match iter.next() {\n//!                 Some(val) => next = val,\n//!                 None => break,\n//!             };\n//!             let x = next;\n//!             let () = { println!(\"{}\", x); };\n//!         },\n//!     };\n//!     result\n//! }\n//! ```\n//!\n//! First, we call `into_iter()` on the value. Then, we match on the iterator\n//! that returns, calling [`next`] over and over until we see a `None`. At\n//! that point, we `break` out of the loop, and we're done iterating.\n//!\n//! There's one more subtle bit here: the standard library contains an\n//! interesting implementation of [`IntoIterator`]:\n//!\n//! ```ignore (only-for-syntax-highlight)\n//! impl<I: Iterator> IntoIterator for I\n//! ```\n//!\n//! In other words, all [`Iterator`]s implement [`IntoIterator`], by just\n//! returning themselves. This means two things:\n//!\n//! 1. If you're writing an [`Iterator`], you can use it with a `for` loop.\n//! 2. If you're creating a collection, implementing [`IntoIterator`] for it\n//!    will allow your collection to be used with the `for` loop.\n//!\n//! # Adapters\n//!\n//! Functions which take an [`Iterator`] and return another [`Iterator`] are\n//! often called 'iterator adapters', as they're a form of the 'adapter\n//! pattern'.\n//!\n//! Common iterator adapters include [`map`], [`take`], and [`filter`].\n//! For more, see their documentation.\n//!\n//! [`map`]: trait.Iterator.html#method.map\n//! [`take`]: trait.Iterator.html#method.take\n//! [`filter`]: trait.Iterator.html#method.filter\n//!\n//! # Laziness\n//!\n//! Iterators (and iterator [adapters](#adapters)) are *lazy*. This means that\n//! just creating an iterator doesn't _do_ a whole lot. Nothing really happens\n//! until you call [`next`]. This is sometimes a source of confusion when\n//! creating an iterator solely for its side effects. For example, the [`map`]\n//! method calls a closure on each element it iterates over:\n//!\n//! ```\n//! # #![allow(unused_must_use)]\n//! let v = vec![1, 2, 3, 4, 5];\n//! v.iter().map(|x| println!(\"{}\", x));\n//! ```\n//!\n//! This will not print any values, as we only created an iterator, rather than\n//! using it. The compiler will warn us about this kind of behavior:\n//!\n//! ```text\n//! warning: unused result that must be used: iterator adaptors are lazy and\n//! do nothing unless consumed\n//! ```\n//!\n//! The idiomatic way to write a [`map`] for its side effects is to use a\n//! `for` loop instead:\n//!\n//! ```\n//! let v = vec![1, 2, 3, 4, 5];\n//!\n//! for x in &v {\n//!     println!(\"{}\", x);\n//! }\n//! ```\n//!\n//! [`map`]: trait.Iterator.html#method.map\n//!\n//! The two most common ways to evaluate an iterator are to use a `for` loop\n//! like this, or using the [`collect`] method to produce a new collection.\n//!\n//! [`collect`]: trait.Iterator.html#method.collect\n//!\n//! # Infinity\n//!\n//! Iterators do not have to be finite. As an example, an open-ended range is\n//! an infinite iterator:\n//!\n//! ```\n//! let numbers = 0..;\n//! ```\n//!\n//! It is common to use the [`take`] iterator adapter to turn an infinite\n//! iterator into a finite one:\n//!\n//! ```\n//! let numbers = 0..;\n//! let five_numbers = numbers.take(5);\n//!\n//! for number in five_numbers {\n//!     println!(\"{}\", number);\n//! }\n//! ```\n//!\n//! This will print the numbers `0` through `4`, each on their own line.\n//!\n//! Bear in mind that methods on infinite iterators, even those for which a\n//! result can be determined mathematically in finite time, may not terminate.\n//! Specifically, methods such as [`min`], which in the general case require\n//! traversing every element in the iterator, are likely not to return\n//! successfully for any infinite iterators.\n//!\n//! ```no_run\n//! let ones = std::iter::repeat(1);\n//! let least = ones.min().unwrap(); // Oh no! An infinite loop!\n//! // `ones.min()` causes an infinite loop, so we won't reach this point!\n//! println!(\"The smallest number one is {}.\", least);\n//! ```\n//!\n//! [`take`]: trait.Iterator.html#method.take\n//! [`min`]: trait.Iterator.html#method.min\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse cmp;\nuse fmt;\nuse iter_private::TrustedRandomAccess;\nuse ops::{self, Try};\nuse usize;\nuse intrinsics;\nuse mem;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::iterator::Iterator;\n\n#[unstable(feature = \"step_trait\",\n           reason = \"likely to be replaced by finer-grained traits\",\n           issue = \"42168\")]\npub use self::range::Step;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::sources::{Repeat, repeat};\n#[stable(feature = \"iterator_repeat_with\", since = \"1.28.0\")]\npub use self::sources::{RepeatWith, repeat_with};\n#[stable(feature = \"iter_empty\", since = \"1.2.0\")]\npub use self::sources::{Empty, empty};\n#[stable(feature = \"iter_once\", since = \"1.2.0\")]\npub use self::sources::{Once, once};\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::traits::{FromIterator, IntoIterator, DoubleEndedIterator, Extend};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::traits::{ExactSizeIterator, Sum, Product};\n#[stable(feature = \"fused\", since = \"1.26.0\")]\npub use self::traits::FusedIterator;\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\npub use self::traits::TrustedLen;\n\nmod iterator;\nmod range;\nmod sources;\nmod traits;\n\n/// Used to make try_fold closures more like normal loops\n#[derive(PartialEq)]\nenum LoopState<C, B> {\n    Continue(C),\n    Break(B),\n}\n\nimpl<C, B> Try for LoopState<C, B> {\n    type Ok = C;\n    type Error = B;\n    #[inline]\n    fn into_result(self) -> Result<Self::Ok, Self::Error> {\n        match self {\n            LoopState::Continue(y) => Ok(y),\n            LoopState::Break(x) => Err(x),\n        }\n    }\n    #[inline]\n    fn from_error(v: Self::Error) -> Self { LoopState::Break(v) }\n    #[inline]\n    fn from_ok(v: Self::Ok) -> Self { LoopState::Continue(v) }\n}\n\nimpl<C, B> LoopState<C, B> {\n    #[inline]\n    fn break_value(self) -> Option<B> {\n        match self {\n            LoopState::Continue(..) => None,\n            LoopState::Break(x) => Some(x),\n        }\n    }\n}\n\nimpl<R: Try> LoopState<R::Ok, R> {\n    #[inline]\n    fn from_try(r: R) -> Self {\n        match Try::into_result(r) {\n            Ok(v) => LoopState::Continue(v),\n            Err(v) => LoopState::Break(Try::from_error(v)),\n        }\n    }\n    #[inline]\n    fn into_try(self) -> R {\n        match self {\n            LoopState::Continue(v) => Try::from_ok(v),\n            LoopState::Break(v) => v,\n        }\n    }\n}\n\n/// A double-ended iterator with the direction inverted.\n///\n/// This `struct` is created by the [`rev`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`rev`]: trait.Iterator.html#method.rev\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Rev<T> {\n    iter: T\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Rev<I> where I: DoubleEndedIterator {\n    type Item = <I as Iterator>::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next_back() }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() }\n\n    fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        self.iter.try_rfold(init, f)\n    }\n\n    fn fold<Acc, F>(self, init: Acc, f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.iter.rfold(init, f)\n    }\n\n    #[inline]\n    fn find<P>(&mut self, predicate: P) -> Option<Self::Item>\n        where P: FnMut(&Self::Item) -> bool\n    {\n        self.iter.rfind(predicate)\n    }\n\n    #[inline]\n    fn rposition<P>(&mut self, predicate: P) -> Option<usize> where\n        P: FnMut(Self::Item) -> bool\n    {\n        self.iter.position(predicate)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> DoubleEndedIterator for Rev<I> where I: DoubleEndedIterator {\n    #[inline]\n    fn next_back(&mut self) -> Option<<I as Iterator>::Item> { self.iter.next() }\n\n    fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        self.iter.try_fold(init, f)\n    }\n\n    fn rfold<Acc, F>(self, init: Acc, f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.iter.fold(init, f)\n    }\n\n    fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>\n        where P: FnMut(&Self::Item) -> bool\n    {\n        self.iter.find(predicate)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> ExactSizeIterator for Rev<I>\n    where I: ExactSizeIterator + DoubleEndedIterator\n{\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Rev<I>\n    where I: FusedIterator + DoubleEndedIterator {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<I> TrustedLen for Rev<I>\n    where I: TrustedLen + DoubleEndedIterator {}\n\n/// An iterator that clones the elements of an underlying iterator.\n///\n/// This `struct` is created by the [`cloned`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`cloned`]: trait.Iterator.html#method.cloned\n/// [`Iterator`]: trait.Iterator.html\n#[stable(feature = \"iter_cloned\", since = \"1.1.0\")]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[derive(Clone, Debug)]\npub struct Cloned<I> {\n    it: I,\n}\n\n#[stable(feature = \"iter_cloned\", since = \"1.1.0\")]\nimpl<'a, I, T: 'a> Iterator for Cloned<I>\n    where I: Iterator<Item=&'a T>, T: Clone\n{\n    type Item = T;\n\n    fn next(&mut self) -> Option<T> {\n        self.it.next().cloned()\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.it.size_hint()\n    }\n\n    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        self.it.try_fold(init, move |acc, elt| f(acc, elt.clone()))\n    }\n\n    fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.it.fold(init, move |acc, elt| f(acc, elt.clone()))\n    }\n}\n\n#[stable(feature = \"iter_cloned\", since = \"1.1.0\")]\nimpl<'a, I, T: 'a> DoubleEndedIterator for Cloned<I>\n    where I: DoubleEndedIterator<Item=&'a T>, T: Clone\n{\n    fn next_back(&mut self) -> Option<T> {\n        self.it.next_back().cloned()\n    }\n\n    fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        self.it.try_rfold(init, move |acc, elt| f(acc, elt.clone()))\n    }\n\n    fn rfold<Acc, F>(self, init: Acc, mut f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.it.rfold(init, move |acc, elt| f(acc, elt.clone()))\n    }\n}\n\n#[stable(feature = \"iter_cloned\", since = \"1.1.0\")]\nimpl<'a, I, T: 'a> ExactSizeIterator for Cloned<I>\n    where I: ExactSizeIterator<Item=&'a T>, T: Clone\n{\n    fn len(&self) -> usize {\n        self.it.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.it.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, I, T: 'a> FusedIterator for Cloned<I>\n    where I: FusedIterator<Item=&'a T>, T: Clone\n{}\n\n#[doc(hidden)]\nunsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>\n    where I: TrustedRandomAccess<Item=&'a T>, T: Clone\n{\n    default unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {\n        self.it.get_unchecked(i).clone()\n    }\n\n    #[inline]\n    default fn may_have_side_effect() -> bool { true }\n}\n\n#[doc(hidden)]\nunsafe impl<'a, I, T: 'a> TrustedRandomAccess for Cloned<I>\n    where I: TrustedRandomAccess<Item=&'a T>, T: Copy\n{\n    unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {\n        *self.it.get_unchecked(i)\n    }\n\n    #[inline]\n    fn may_have_side_effect() -> bool { false }\n}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<'a, I, T: 'a> TrustedLen for Cloned<I>\n    where I: TrustedLen<Item=&'a T>,\n          T: Clone\n{}\n\n/// An iterator that repeats endlessly.\n///\n/// This `struct` is created by the [`cycle`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`cycle`]: trait.Iterator.html#method.cycle\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Cycle<I> {\n    orig: I,\n    iter: I,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Cycle<I> where I: Clone + Iterator {\n    type Item = <I as Iterator>::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<<I as Iterator>::Item> {\n        match self.iter.next() {\n            None => { self.iter = self.orig.clone(); self.iter.next() }\n            y => y\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        // the cycle iterator is either empty or infinite\n        match self.orig.size_hint() {\n            sz @ (0, Some(0)) => sz,\n            (0, _) => (0, None),\n            _ => (usize::MAX, None)\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Cycle<I> where I: Clone + Iterator {}\n\n/// An iterator for stepping iterators by a custom amount.\n///\n/// This `struct` is created by the [`step_by`] method on [`Iterator`]. See\n/// its documentation for more.\n///\n/// [`step_by`]: trait.Iterator.html#method.step_by\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"iterator_step_by\", since = \"1.28.0\")]\n#[derive(Clone, Debug)]\npub struct StepBy<I> {\n    iter: I,\n    step: usize,\n    first_take: bool,\n}\n\n#[stable(feature = \"iterator_step_by\", since = \"1.28.0\")]\nimpl<I> Iterator for StepBy<I> where I: Iterator {\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<Self::Item> {\n        <Self as StepBySpecIterator>::spec_next(self)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let inner_hint = self.iter.size_hint();\n\n        if self.first_take {\n            let f = |n| if n == 0 { 0 } else { 1 + (n-1)/(self.step+1) };\n            (f(inner_hint.0), inner_hint.1.map(f))\n        } else {\n            let f = |n| n / (self.step+1);\n            (f(inner_hint.0), inner_hint.1.map(f))\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, mut n: usize) -> Option<Self::Item> {\n        if self.first_take {\n            self.first_take = false;\n            let first = self.iter.next();\n            if n == 0 {\n                return first;\n            }\n            n -= 1;\n        }\n        // n and self.step are indices, we need to add 1 to get the amount of elements\n        // When calling `.nth`, we need to subtract 1 again to convert back to an index\n        // step + 1 can't overflow because `.step_by` sets `self.step` to `step - 1`\n        let mut step = self.step + 1;\n        // n + 1 could overflow\n        // thus, if n is usize::MAX, instead of adding one, we call .nth(step)\n        if n == usize::MAX {\n            self.iter.nth(step - 1);\n        } else {\n            n += 1;\n        }\n\n        // overflow handling\n        loop {\n            let mul = n.checked_mul(step);\n            if unsafe { intrinsics::likely(mul.is_some()) } {\n                return self.iter.nth(mul.unwrap() - 1);\n            }\n            let div_n = usize::MAX / n;\n            let div_step = usize::MAX / step;\n            let nth_n = div_n * n;\n            let nth_step = div_step * step;\n            let nth = if nth_n > nth_step {\n                step -= div_n;\n                nth_n\n            } else {\n                n -= div_step;\n                nth_step\n            };\n            self.iter.nth(nth - 1);\n        }\n    }\n}\n\n// hidden trait for specializing iterator methods\n// could be generalized but is currently only used for StepBy\ntrait StepBySpecIterator {\n    type Item;\n    fn spec_next(&mut self) -> Option<Self::Item>;\n}\n\nimpl<I> StepBySpecIterator for StepBy<I>\nwhere\n    I: Iterator,\n{\n    type Item = I::Item;\n\n    #[inline]\n    default fn spec_next(&mut self) -> Option<I::Item> {\n        if self.first_take {\n            self.first_take = false;\n            self.iter.next()\n        } else {\n            self.iter.nth(self.step)\n        }\n    }\n}\n\nimpl<T> StepBySpecIterator for StepBy<ops::Range<T>>\nwhere\n    T: Step,\n{\n    #[inline]\n    fn spec_next(&mut self) -> Option<Self::Item> {\n        self.first_take = false;\n        if !(self.iter.start < self.iter.end) {\n            return None;\n        }\n        // add 1 to self.step to get original step size back\n        // it was decremented for the general case on construction\n        if let Some(n) = self.iter.start.add_usize(self.step+1) {\n            let next = mem::replace(&mut self.iter.start, n);\n            Some(next)\n        } else {\n            let last = self.iter.start.clone();\n            self.iter.start = self.iter.end.clone();\n            Some(last)\n        }\n    }\n}\n\nimpl<T> StepBySpecIterator for StepBy<ops::RangeInclusive<T>>\nwhere\n    T: Step,\n{\n    #[inline]\n    fn spec_next(&mut self) -> Option<Self::Item> {\n        self.first_take = false;\n        self.iter.compute_is_empty();\n        if self.iter.is_empty.unwrap_or_default() {\n            return None;\n        }\n        // add 1 to self.step to get original step size back\n        // it was decremented for the general case on construction\n        if let Some(n) = self.iter.start.add_usize(self.step+1) {\n            self.iter.is_empty = Some(!(n <= self.iter.end));\n            let next = mem::replace(&mut self.iter.start, n);\n            Some(next)\n        } else {\n            let last = self.iter.start.clone();\n            self.iter.is_empty = Some(true);\n            Some(last)\n        }\n    }\n}\n\n// StepBy can only make the iterator shorter, so the len will still fit.\n#[stable(feature = \"iterator_step_by\", since = \"1.28.0\")]\nimpl<I> ExactSizeIterator for StepBy<I> where I: ExactSizeIterator {}\n\n/// An iterator that strings two iterators together.\n///\n/// This `struct` is created by the [`chain`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`chain`]: trait.Iterator.html#method.chain\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Chain<A, B> {\n    a: A,\n    b: B,\n    state: ChainState,\n}\n\n// The iterator protocol specifies that iteration ends with the return value\n// `None` from `.next()` (or `.next_back()`) and it is unspecified what\n// further calls return. The chain adaptor must account for this since it uses\n// two subiterators.\n//\n//  It uses three states:\n//\n//  - Both: `a` and `b` are remaining\n//  - Front: `a` remaining\n//  - Back: `b` remaining\n//\n//  The fourth state (neither iterator is remaining) only occurs after Chain has\n//  returned None once, so we don't need to store this state.\n#[derive(Clone, Debug)]\nenum ChainState {\n    // both front and back iterator are remaining\n    Both,\n    // only front is remaining\n    Front,\n    // only back is remaining\n    Back,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> Iterator for Chain<A, B> where\n    A: Iterator,\n    B: Iterator<Item = A::Item>\n{\n    type Item = A::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<A::Item> {\n        match self.state {\n            ChainState::Both => match self.a.next() {\n                elt @ Some(..) => elt,\n                None => {\n                    self.state = ChainState::Back;\n                    self.b.next()\n                }\n            },\n            ChainState::Front => self.a.next(),\n            ChainState::Back => self.b.next(),\n        }\n    }\n\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn count(self) -> usize {\n        match self.state {\n            ChainState::Both => self.a.count() + self.b.count(),\n            ChainState::Front => self.a.count(),\n            ChainState::Back => self.b.count(),\n        }\n    }\n\n    fn try_fold<Acc, F, R>(&mut self, init: Acc, mut f: F) -> R where\n        Self: Sized, F: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let mut accum = init;\n        match self.state {\n            ChainState::Both | ChainState::Front => {\n                accum = self.a.try_fold(accum, &mut f)?;\n                if let ChainState::Both = self.state {\n                    self.state = ChainState::Back;\n                }\n            }\n            _ => { }\n        }\n        if let ChainState::Back = self.state {\n            accum = self.b.try_fold(accum, &mut f)?;\n        }\n        Try::from_ok(accum)\n    }\n\n    fn fold<Acc, F>(self, init: Acc, mut f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut accum = init;\n        match self.state {\n            ChainState::Both | ChainState::Front => {\n                accum = self.a.fold(accum, &mut f);\n            }\n            _ => { }\n        }\n        match self.state {\n            ChainState::Both | ChainState::Back => {\n                accum = self.b.fold(accum, &mut f);\n            }\n            _ => { }\n        }\n        accum\n    }\n\n    #[inline]\n    fn nth(&mut self, mut n: usize) -> Option<A::Item> {\n        match self.state {\n            ChainState::Both | ChainState::Front => {\n                for x in self.a.by_ref() {\n                    if n == 0 {\n                        return Some(x)\n                    }\n                    n -= 1;\n                }\n                if let ChainState::Both = self.state {\n                    self.state = ChainState::Back;\n                }\n            }\n            ChainState::Back => {}\n        }\n        if let ChainState::Back = self.state {\n            self.b.nth(n)\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn find<P>(&mut self, mut predicate: P) -> Option<Self::Item> where\n        P: FnMut(&Self::Item) -> bool,\n    {\n        match self.state {\n            ChainState::Both => match self.a.find(&mut predicate) {\n                None => {\n                    self.state = ChainState::Back;\n                    self.b.find(predicate)\n                }\n                v => v\n            },\n            ChainState::Front => self.a.find(predicate),\n            ChainState::Back => self.b.find(predicate),\n        }\n    }\n\n    #[inline]\n    fn last(self) -> Option<A::Item> {\n        match self.state {\n            ChainState::Both => {\n                // Must exhaust a before b.\n                let a_last = self.a.last();\n                let b_last = self.b.last();\n                b_last.or(a_last)\n            },\n            ChainState::Front => self.a.last(),\n            ChainState::Back => self.b.last()\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (a_lower, a_upper) = self.a.size_hint();\n        let (b_lower, b_upper) = self.b.size_hint();\n\n        let lower = a_lower.saturating_add(b_lower);\n\n        let upper = match (a_upper, b_upper) {\n            (Some(x), Some(y)) => x.checked_add(y),\n            _ => None\n        };\n\n        (lower, upper)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> DoubleEndedIterator for Chain<A, B> where\n    A: DoubleEndedIterator,\n    B: DoubleEndedIterator<Item=A::Item>,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<A::Item> {\n        match self.state {\n            ChainState::Both => match self.b.next_back() {\n                elt @ Some(..) => elt,\n                None => {\n                    self.state = ChainState::Front;\n                    self.a.next_back()\n                }\n            },\n            ChainState::Front => self.a.next_back(),\n            ChainState::Back => self.b.next_back(),\n        }\n    }\n\n    fn try_rfold<Acc, F, R>(&mut self, init: Acc, mut f: F) -> R where\n        Self: Sized, F: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let mut accum = init;\n        match self.state {\n            ChainState::Both | ChainState::Back => {\n                accum = self.b.try_rfold(accum, &mut f)?;\n                if let ChainState::Both = self.state {\n                    self.state = ChainState::Front;\n                }\n            }\n            _ => { }\n        }\n        if let ChainState::Front = self.state {\n            accum = self.a.try_rfold(accum, &mut f)?;\n        }\n        Try::from_ok(accum)\n    }\n\n    fn rfold<Acc, F>(self, init: Acc, mut f: F) -> Acc\n        where F: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut accum = init;\n        match self.state {\n            ChainState::Both | ChainState::Back => {\n                accum = self.b.rfold(accum, &mut f);\n            }\n            _ => { }\n        }\n        match self.state {\n            ChainState::Both | ChainState::Front => {\n                accum = self.a.rfold(accum, &mut f);\n            }\n            _ => { }\n        }\n        accum\n    }\n\n}\n\n// Note: *both* must be fused to handle double-ended iterators.\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A, B> FusedIterator for Chain<A, B>\n    where A: FusedIterator,\n          B: FusedIterator<Item=A::Item>,\n{}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A, B> TrustedLen for Chain<A, B>\n    where A: TrustedLen, B: TrustedLen<Item=A::Item>,\n{}\n\n/// An iterator that iterates two other iterators simultaneously.\n///\n/// This `struct` is created by the [`zip`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`zip`]: trait.Iterator.html#method.zip\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Zip<A, B> {\n    a: A,\n    b: B,\n    // index and len are only used by the specialized version of zip\n    index: usize,\n    len: usize,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator\n{\n    type Item = (A::Item, B::Item);\n\n    #[inline]\n    fn next(&mut self) -> Option<Self::Item> {\n        ZipImpl::next(self)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        ZipImpl::size_hint(self)\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        ZipImpl::nth(self, n)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> DoubleEndedIterator for Zip<A, B> where\n    A: DoubleEndedIterator + ExactSizeIterator,\n    B: DoubleEndedIterator + ExactSizeIterator,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<(A::Item, B::Item)> {\n        ZipImpl::next_back(self)\n    }\n}\n\n// Zip specialization trait\n#[doc(hidden)]\ntrait ZipImpl<A, B> {\n    type Item;\n    fn new(a: A, b: B) -> Self;\n    fn next(&mut self) -> Option<Self::Item>;\n    fn size_hint(&self) -> (usize, Option<usize>);\n    fn nth(&mut self, n: usize) -> Option<Self::Item>;\n    fn super_nth(&mut self, mut n: usize) -> Option<Self::Item> {\n        while let Some(x) = self.next() {\n            if n == 0 { return Some(x) }\n            n -= 1;\n        }\n        None\n    }\n    fn next_back(&mut self) -> Option<Self::Item>\n        where A: DoubleEndedIterator + ExactSizeIterator,\n              B: DoubleEndedIterator + ExactSizeIterator;\n}\n\n// General Zip impl\n#[doc(hidden)]\nimpl<A, B> ZipImpl<A, B> for Zip<A, B>\n    where A: Iterator, B: Iterator\n{\n    type Item = (A::Item, B::Item);\n    default fn new(a: A, b: B) -> Self {\n        Zip {\n            a,\n            b,\n            index: 0, // unused\n            len: 0, // unused\n        }\n    }\n\n    #[inline]\n    default fn next(&mut self) -> Option<(A::Item, B::Item)> {\n        self.a.next().and_then(|x| {\n            self.b.next().and_then(|y| {\n                Some((x, y))\n            })\n        })\n    }\n\n    #[inline]\n    default fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        self.super_nth(n)\n    }\n\n    #[inline]\n    default fn next_back(&mut self) -> Option<(A::Item, B::Item)>\n        where A: DoubleEndedIterator + ExactSizeIterator,\n              B: DoubleEndedIterator + ExactSizeIterator\n    {\n        let a_sz = self.a.len();\n        let b_sz = self.b.len();\n        if a_sz != b_sz {\n            // Adjust a, b to equal length\n            if a_sz > b_sz {\n                for _ in 0..a_sz - b_sz { self.a.next_back(); }\n            } else {\n                for _ in 0..b_sz - a_sz { self.b.next_back(); }\n            }\n        }\n        match (self.a.next_back(), self.b.next_back()) {\n            (Some(x), Some(y)) => Some((x, y)),\n            (None, None) => None,\n            _ => unreachable!(),\n        }\n    }\n\n    #[inline]\n    default fn size_hint(&self) -> (usize, Option<usize>) {\n        let (a_lower, a_upper) = self.a.size_hint();\n        let (b_lower, b_upper) = self.b.size_hint();\n\n        let lower = cmp::min(a_lower, b_lower);\n\n        let upper = match (a_upper, b_upper) {\n            (Some(x), Some(y)) => Some(cmp::min(x,y)),\n            (Some(x), None) => Some(x),\n            (None, Some(y)) => Some(y),\n            (None, None) => None\n        };\n\n        (lower, upper)\n    }\n}\n\n#[doc(hidden)]\nimpl<A, B> ZipImpl<A, B> for Zip<A, B>\n    where A: TrustedRandomAccess, B: TrustedRandomAccess\n{\n    fn new(a: A, b: B) -> Self {\n        let len = cmp::min(a.len(), b.len());\n        Zip {\n            a,\n            b,\n            index: 0,\n            len,\n        }\n    }\n\n    #[inline]\n    fn next(&mut self) -> Option<(A::Item, B::Item)> {\n        if self.index < self.len {\n            let i = self.index;\n            self.index += 1;\n            unsafe {\n                Some((self.a.get_unchecked(i), self.b.get_unchecked(i)))\n            }\n        } else if A::may_have_side_effect() && self.index < self.a.len() {\n            // match the base implementation's potential side effects\n            unsafe {\n                self.a.get_unchecked(self.index);\n            }\n            self.index += 1;\n            None\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let len = self.len - self.index;\n        (len, Some(len))\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<Self::Item> {\n        let delta = cmp::min(n, self.len - self.index);\n        let end = self.index + delta;\n        while self.index < end {\n            let i = self.index;\n            self.index += 1;\n            if A::may_have_side_effect() {\n                unsafe { self.a.get_unchecked(i); }\n            }\n            if B::may_have_side_effect() {\n                unsafe { self.b.get_unchecked(i); }\n            }\n        }\n\n        self.super_nth(n - delta)\n    }\n\n    #[inline]\n    fn next_back(&mut self) -> Option<(A::Item, B::Item)>\n        where A: DoubleEndedIterator + ExactSizeIterator,\n              B: DoubleEndedIterator + ExactSizeIterator\n    {\n        // Adjust a, b to equal length\n        if A::may_have_side_effect() {\n            let sz = self.a.len();\n            if sz > self.len {\n                for _ in 0..sz - cmp::max(self.len, self.index) {\n                    self.a.next_back();\n                }\n            }\n        }\n        if B::may_have_side_effect() {\n            let sz = self.b.len();\n            if sz > self.len {\n                for _ in 0..sz - self.len {\n                    self.b.next_back();\n                }\n            }\n        }\n        if self.index < self.len {\n            self.len -= 1;\n            let i = self.len;\n            unsafe {\n                Some((self.a.get_unchecked(i), self.b.get_unchecked(i)))\n            }\n        } else {\n            None\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<A, B> ExactSizeIterator for Zip<A, B>\n    where A: ExactSizeIterator, B: ExactSizeIterator {}\n\n#[doc(hidden)]\nunsafe impl<A, B> TrustedRandomAccess for Zip<A, B>\n    where A: TrustedRandomAccess,\n          B: TrustedRandomAccess,\n{\n    unsafe fn get_unchecked(&mut self, i: usize) -> (A::Item, B::Item) {\n        (self.a.get_unchecked(i), self.b.get_unchecked(i))\n    }\n\n    fn may_have_side_effect() -> bool {\n        A::may_have_side_effect() || B::may_have_side_effect()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<A, B> FusedIterator for Zip<A, B>\n    where A: FusedIterator, B: FusedIterator, {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<A, B> TrustedLen for Zip<A, B>\n    where A: TrustedLen, B: TrustedLen,\n{}\n\n/// An iterator that maps the values of `iter` with `f`.\n///\n/// This `struct` is created by the [`map`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`map`]: trait.Iterator.html#method.map\n/// [`Iterator`]: trait.Iterator.html\n///\n/// # Notes about side effects\n///\n/// The [`map`] iterator implements [`DoubleEndedIterator`], meaning that\n/// you can also [`map`] backwards:\n///\n/// ```rust\n/// let v: Vec<i32> = vec![1, 2, 3].into_iter().map(|x| x + 1).rev().collect();\n///\n/// assert_eq!(v, [4, 3, 2]);\n/// ```\n///\n/// [`DoubleEndedIterator`]: trait.DoubleEndedIterator.html\n///\n/// But if your closure has state, iterating backwards may act in a way you do\n/// not expect. Let's go through an example. First, in the forward direction:\n///\n/// ```rust\n/// let mut c = 0;\n///\n/// for pair in vec!['a', 'b', 'c'].into_iter()\n///                                .map(|letter| { c += 1; (letter, c) }) {\n///     println!(\"{:?}\", pair);\n/// }\n/// ```\n///\n/// This will print \"('a', 1), ('b', 2), ('c', 3)\".\n///\n/// Now consider this twist where we add a call to `rev`. This version will\n/// print `('c', 1), ('b', 2), ('a', 3)`. Note that the letters are reversed,\n/// but the values of the counter still go in order. This is because `map()` is\n/// still being called lazily on each item, but we are popping items off the\n/// back of the vector now, instead of shifting them from the front.\n///\n/// ```rust\n/// let mut c = 0;\n///\n/// for pair in vec!['a', 'b', 'c'].into_iter()\n///                                .map(|letter| { c += 1; (letter, c) })\n///                                .rev() {\n///     println!(\"{:?}\", pair);\n/// }\n/// ```\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct Map<I, F> {\n    iter: I,\n    f: F,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, F> fmt::Debug for Map<I, F> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Map\")\n            .field(\"iter\", &self.iter)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I: Iterator, F> Iterator for Map<I, F> where F: FnMut(I::Item) -> B {\n    type Item = B;\n\n    #[inline]\n    fn next(&mut self) -> Option<B> {\n        self.iter.next().map(&mut self.f)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n\n    fn try_fold<Acc, G, R>(&mut self, init: Acc, mut g: G) -> R where\n        Self: Sized, G: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_fold(init, move |acc, elt| g(acc, f(elt)))\n    }\n\n    fn fold<Acc, G>(self, init: Acc, mut g: G) -> Acc\n        where G: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.fold(init, move |acc, elt| g(acc, f(elt)))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for Map<I, F> where\n    F: FnMut(I::Item) -> B,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<B> {\n        self.iter.next_back().map(&mut self.f)\n    }\n\n    fn try_rfold<Acc, G, R>(&mut self, init: Acc, mut g: G) -> R where\n        Self: Sized, G: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_rfold(init, move |acc, elt| g(acc, f(elt)))\n    }\n\n    fn rfold<Acc, G>(self, init: Acc, mut g: G) -> Acc\n        where G: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.rfold(init, move |acc, elt| g(acc, f(elt)))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I: ExactSizeIterator, F> ExactSizeIterator for Map<I, F>\n    where F: FnMut(I::Item) -> B\n{\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<B, I: FusedIterator, F> FusedIterator for Map<I, F>\n    where F: FnMut(I::Item) -> B {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<B, I, F> TrustedLen for Map<I, F>\n    where I: TrustedLen,\n          F: FnMut(I::Item) -> B {}\n\n#[doc(hidden)]\nunsafe impl<B, I, F> TrustedRandomAccess for Map<I, F>\n    where I: TrustedRandomAccess,\n          F: FnMut(I::Item) -> B,\n{\n    unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {\n        (self.f)(self.iter.get_unchecked(i))\n    }\n    #[inline]\n    fn may_have_side_effect() -> bool { true }\n}\n\n/// An iterator that filters the elements of `iter` with `predicate`.\n///\n/// This `struct` is created by the [`filter`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`filter`]: trait.Iterator.html#method.filter\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct Filter<I, P> {\n    iter: I,\n    predicate: P,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, P> fmt::Debug for Filter<I, P> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Filter\")\n            .field(\"iter\", &self.iter)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator, P> Iterator for Filter<I, P> where P: FnMut(&I::Item) -> bool {\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        for x in &mut self.iter {\n            if (self.predicate)(&x) {\n                return Some(x);\n            }\n        }\n        None\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (_, upper) = self.iter.size_hint();\n        (0, upper) // can't know a lower bound, due to the predicate\n    }\n\n    // this special case allows the compiler to make `.filter(_).count()`\n    // branchless. Barring perfect branch prediction (which is unattainable in\n    // the general case), this will be much faster in >90% of cases (containing\n    // virtually all real workloads) and only a tiny bit slower in the rest.\n    //\n    // Having this specialization thus allows us to write `.filter(p).count()`\n    // where we would otherwise write `.map(|x| p(x) as usize).sum()`, which is\n    // less readable and also less backwards-compatible to Rust before 1.10.\n    //\n    // Using the branchless version will also simplify the LLVM byte code, thus\n    // leaving more budget for LLVM optimizations.\n    #[inline]\n    fn count(mut self) -> usize {\n        let mut count = 0;\n        for x in &mut self.iter {\n            count += (self.predicate)(&x) as usize;\n        }\n        count\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let predicate = &mut self.predicate;\n        self.iter.try_fold(init, move |acc, item| if predicate(&item) {\n            fold(acc, item)\n        } else {\n            Try::from_ok(acc)\n        })\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut predicate = self.predicate;\n        self.iter.fold(init, move |acc, item| if predicate(&item) {\n            fold(acc, item)\n        } else {\n            acc\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: DoubleEndedIterator, P> DoubleEndedIterator for Filter<I, P>\n    where P: FnMut(&I::Item) -> bool,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<I::Item> {\n        for x in self.iter.by_ref().rev() {\n            if (self.predicate)(&x) {\n                return Some(x);\n            }\n        }\n        None\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let predicate = &mut self.predicate;\n        self.iter.try_rfold(init, move |acc, item| if predicate(&item) {\n            fold(acc, item)\n        } else {\n            Try::from_ok(acc)\n        })\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut predicate = self.predicate;\n        self.iter.rfold(init, move |acc, item| if predicate(&item) {\n            fold(acc, item)\n        } else {\n            acc\n        })\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I: FusedIterator, P> FusedIterator for Filter<I, P>\n    where P: FnMut(&I::Item) -> bool {}\n\n/// An iterator that uses `f` to both filter and map elements from `iter`.\n///\n/// This `struct` is created by the [`filter_map`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`filter_map`]: trait.Iterator.html#method.filter_map\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct FilterMap<I, F> {\n    iter: I,\n    f: F,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, F> fmt::Debug for FilterMap<I, F> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"FilterMap\")\n            .field(\"iter\", &self.iter)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I: Iterator, F> Iterator for FilterMap<I, F>\n    where F: FnMut(I::Item) -> Option<B>,\n{\n    type Item = B;\n\n    #[inline]\n    fn next(&mut self) -> Option<B> {\n        for x in self.iter.by_ref() {\n            if let Some(y) = (self.f)(x) {\n                return Some(y);\n            }\n        }\n        None\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (_, upper) = self.iter.size_hint();\n        (0, upper) // can't know a lower bound, due to the predicate\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_fold(init, move |acc, item| match f(item) {\n            Some(x) => fold(acc, x),\n            None => Try::from_ok(acc),\n        })\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.fold(init, move |acc, item| match f(item) {\n            Some(x) => fold(acc, x),\n            None => acc,\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I: DoubleEndedIterator, F> DoubleEndedIterator for FilterMap<I, F>\n    where F: FnMut(I::Item) -> Option<B>,\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<B> {\n        for x in self.iter.by_ref().rev() {\n            if let Some(y) = (self.f)(x) {\n                return Some(y);\n            }\n        }\n        None\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_rfold(init, move |acc, item| match f(item) {\n            Some(x) => fold(acc, x),\n            None => Try::from_ok(acc),\n        })\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.rfold(init, move |acc, item| match f(item) {\n            Some(x) => fold(acc, x),\n            None => acc,\n        })\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<B, I: FusedIterator, F> FusedIterator for FilterMap<I, F>\n    where F: FnMut(I::Item) -> Option<B> {}\n\n/// An iterator that yields the current count and the element during iteration.\n///\n/// This `struct` is created by the [`enumerate`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`enumerate`]: trait.Iterator.html#method.enumerate\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Enumerate<I> {\n    iter: I,\n    count: usize,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Enumerate<I> where I: Iterator {\n    type Item = (usize, <I as Iterator>::Item);\n\n    /// # Overflow Behavior\n    ///\n    /// The method does no guarding against overflows, so enumerating more than\n    /// `usize::MAX` elements either produces the wrong result or panics. If\n    /// debug assertions are enabled, a panic is guaranteed.\n    ///\n    /// # Panics\n    ///\n    /// Might panic if the index of the element overflows a `usize`.\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn next(&mut self) -> Option<(usize, <I as Iterator>::Item)> {\n        self.iter.next().map(|a| {\n            let ret = (self.count, a);\n            // Possible undefined overflow.\n            self.count += 1;\n            ret\n        })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn nth(&mut self, n: usize) -> Option<(usize, I::Item)> {\n        self.iter.nth(n).map(|a| {\n            let i = self.count + n;\n            self.count = i + 1;\n            (i, a)\n        })\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.iter.count()\n    }\n\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let count = &mut self.count;\n        self.iter.try_fold(init, move |acc, item| {\n            let acc = fold(acc, (*count, item));\n            *count += 1;\n            acc\n        })\n    }\n\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut count = self.count;\n        self.iter.fold(init, move |acc, item| {\n            let acc = fold(acc, (count, item));\n            count += 1;\n            acc\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> DoubleEndedIterator for Enumerate<I> where\n    I: ExactSizeIterator + DoubleEndedIterator\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<(usize, <I as Iterator>::Item)> {\n        self.iter.next_back().map(|a| {\n            let len = self.iter.len();\n            // Can safely add, `ExactSizeIterator` promises that the number of\n            // elements fits into a `usize`.\n            (self.count + len, a)\n        })\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        // Can safely add and subtract the count, as `ExactSizeIterator` promises\n        // that the number of elements fits into a `usize`.\n        let mut count = self.count + self.iter.len();\n        self.iter.try_rfold(init, move |acc, item| {\n            count -= 1;\n            fold(acc, (count, item))\n        })\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        // Can safely add and subtract the count, as `ExactSizeIterator` promises\n        // that the number of elements fits into a `usize`.\n        let mut count = self.count + self.iter.len();\n        self.iter.rfold(init, move |acc, item| {\n            count -= 1;\n            fold(acc, (count, item))\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> ExactSizeIterator for Enumerate<I> where I: ExactSizeIterator {\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n#[doc(hidden)]\nunsafe impl<I> TrustedRandomAccess for Enumerate<I>\n    where I: TrustedRandomAccess\n{\n    unsafe fn get_unchecked(&mut self, i: usize) -> (usize, I::Item) {\n        (self.count + i, self.iter.get_unchecked(i))\n    }\n\n    fn may_have_side_effect() -> bool {\n        I::may_have_side_effect()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Enumerate<I> where I: FusedIterator {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<I> TrustedLen for Enumerate<I>\n    where I: TrustedLen,\n{}\n\n\n/// An iterator with a `peek()` that returns an optional reference to the next\n/// element.\n///\n/// This `struct` is created by the [`peekable`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`peekable`]: trait.Iterator.html#method.peekable\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Peekable<I: Iterator> {\n    iter: I,\n    /// Remember a peeked value, even if it was None.\n    peeked: Option<Option<I::Item>>,\n}\n\n// Peekable must remember if a None has been seen in the `.peek()` method.\n// It ensures that `.peek(); .peek();` or `.peek(); .next();` only advances the\n// underlying iterator at most once. This does not by itself make the iterator\n// fused.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator> Iterator for Peekable<I> {\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        match self.peeked.take() {\n            Some(v) => v,\n            None => self.iter.next(),\n        }\n    }\n\n    #[inline]\n    #[rustc_inherit_overflow_checks]\n    fn count(mut self) -> usize {\n        match self.peeked.take() {\n            Some(None) => 0,\n            Some(Some(_)) => 1 + self.iter.count(),\n            None => self.iter.count(),\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<I::Item> {\n        // FIXME(#43234): merge these when borrow-checking gets better.\n        if n == 0 {\n            match self.peeked.take() {\n                Some(v) => v,\n                None => self.iter.nth(n),\n            }\n        } else {\n            match self.peeked.take() {\n                Some(None) => None,\n                Some(Some(_)) => self.iter.nth(n - 1),\n                None => self.iter.nth(n),\n            }\n        }\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<I::Item> {\n        let peek_opt = match self.peeked.take() {\n            Some(None) => return None,\n            Some(v) => v,\n            None => None,\n        };\n        self.iter.last().or(peek_opt)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let peek_len = match self.peeked {\n            Some(None) => return (0, Some(0)),\n            Some(Some(_)) => 1,\n            None => 0,\n        };\n        let (lo, hi) = self.iter.size_hint();\n        let lo = lo.saturating_add(peek_len);\n        let hi = hi.and_then(|x| x.checked_add(peek_len));\n        (lo, hi)\n    }\n\n    #[inline]\n    fn try_fold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        let acc = match self.peeked.take() {\n            Some(None) => return Try::from_ok(init),\n            Some(Some(v)) => f(init, v)?,\n            None => init,\n        };\n        self.iter.try_fold(acc, f)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let acc = match self.peeked {\n            Some(None) => return init,\n            Some(Some(v)) => fold(init, v),\n            None => init,\n        };\n        self.iter.fold(acc, fold)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: ExactSizeIterator> ExactSizeIterator for Peekable<I> {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I: FusedIterator> FusedIterator for Peekable<I> {}\n\nimpl<I: Iterator> Peekable<I> {\n    /// Returns a reference to the next() value without advancing the iterator.\n    ///\n    /// Like [`next`], if there is a value, it is wrapped in a `Some(T)`.\n    /// But if the iteration is over, `None` is returned.\n    ///\n    /// [`next`]: trait.Iterator.html#tymethod.next\n    ///\n    /// Because `peek()` returns a reference, and many iterators iterate over\n    /// references, there can be a possibly confusing situation where the\n    /// return value is a double reference. You can see this effect in the\n    /// examples below.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let xs = [1, 2, 3];\n    ///\n    /// let mut iter = xs.iter().peekable();\n    ///\n    /// // peek() lets us see into the future\n    /// assert_eq!(iter.peek(), Some(&&1));\n    /// assert_eq!(iter.next(), Some(&1));\n    ///\n    /// assert_eq!(iter.next(), Some(&2));\n    ///\n    /// // The iterator does not advance even if we `peek` multiple times\n    /// assert_eq!(iter.peek(), Some(&&3));\n    /// assert_eq!(iter.peek(), Some(&&3));\n    ///\n    /// assert_eq!(iter.next(), Some(&3));\n    ///\n    /// // After the iterator is finished, so is `peek()`\n    /// assert_eq!(iter.peek(), None);\n    /// assert_eq!(iter.next(), None);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn peek(&mut self) -> Option<&I::Item> {\n        if self.peeked.is_none() {\n            self.peeked = Some(self.iter.next());\n        }\n        match self.peeked {\n            Some(Some(ref value)) => Some(value),\n            Some(None) => None,\n            _ => unreachable!(),\n        }\n    }\n}\n\n/// An iterator that rejects elements while `predicate` is true.\n///\n/// This `struct` is created by the [`skip_while`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`skip_while`]: trait.Iterator.html#method.skip_while\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct SkipWhile<I, P> {\n    iter: I,\n    flag: bool,\n    predicate: P,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, P> fmt::Debug for SkipWhile<I, P> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"SkipWhile\")\n            .field(\"iter\", &self.iter)\n            .field(\"flag\", &self.flag)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator, P> Iterator for SkipWhile<I, P>\n    where P: FnMut(&I::Item) -> bool\n{\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        let flag = &mut self.flag;\n        let pred = &mut self.predicate;\n        self.iter.find(move |x| {\n            if *flag || !pred(x) {\n                *flag = true;\n                true\n            } else {\n                false\n            }\n        })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (_, upper) = self.iter.size_hint();\n        (0, upper) // can't know a lower bound, due to the predicate\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if !self.flag {\n            match self.next() {\n                Some(v) => init = fold(init, v)?,\n                None => return Try::from_ok(init),\n            }\n        }\n        self.iter.try_fold(init, fold)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(mut self, mut init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        if !self.flag {\n            match self.next() {\n                Some(v) => init = fold(init, v),\n                None => return init,\n            }\n        }\n        self.iter.fold(init, fold)\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I, P> FusedIterator for SkipWhile<I, P>\n    where I: FusedIterator, P: FnMut(&I::Item) -> bool {}\n\n/// An iterator that only accepts elements while `predicate` is true.\n///\n/// This `struct` is created by the [`take_while`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`take_while`]: trait.Iterator.html#method.take_while\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct TakeWhile<I, P> {\n    iter: I,\n    flag: bool,\n    predicate: P,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, P> fmt::Debug for TakeWhile<I, P> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"TakeWhile\")\n            .field(\"iter\", &self.iter)\n            .field(\"flag\", &self.flag)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator, P> Iterator for TakeWhile<I, P>\n    where P: FnMut(&I::Item) -> bool\n{\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        if self.flag {\n            None\n        } else {\n            self.iter.next().and_then(|x| {\n                if (self.predicate)(&x) {\n                    Some(x)\n                } else {\n                    self.flag = true;\n                    None\n                }\n            })\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (_, upper) = self.iter.size_hint();\n        (0, upper) // can't know a lower bound, due to the predicate\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if self.flag {\n            Try::from_ok(init)\n        } else {\n            let flag = &mut self.flag;\n            let p = &mut self.predicate;\n            self.iter.try_fold(init, move |acc, x|{\n                if p(&x) {\n                    LoopState::from_try(fold(acc, x))\n                } else {\n                    *flag = true;\n                    LoopState::Break(Try::from_ok(acc))\n                }\n            }).into_try()\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I, P> FusedIterator for TakeWhile<I, P>\n    where I: FusedIterator, P: FnMut(&I::Item) -> bool {}\n\n/// An iterator that skips over `n` elements of `iter`.\n///\n/// This `struct` is created by the [`skip`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`skip`]: trait.Iterator.html#method.skip\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Skip<I> {\n    iter: I,\n    n: usize\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Skip<I> where I: Iterator {\n    type Item = <I as Iterator>::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        if self.n == 0 {\n            self.iter.next()\n        } else {\n            let old_n = self.n;\n            self.n = 0;\n            self.iter.nth(old_n)\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<I::Item> {\n        // Can't just add n + self.n due to overflow.\n        if self.n == 0 {\n            self.iter.nth(n)\n        } else {\n            let to_skip = self.n;\n            self.n = 0;\n            // nth(n) skips n+1\n            if self.iter.nth(to_skip-1).is_none() {\n                return None;\n            }\n            self.iter.nth(n)\n        }\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.iter.count().saturating_sub(self.n)\n    }\n\n    #[inline]\n    fn last(mut self) -> Option<I::Item> {\n        if self.n == 0 {\n            self.iter.last()\n        } else {\n            let next = self.next();\n            if next.is_some() {\n                // recurse. n should be 0.\n                self.last().or(next)\n            } else {\n                None\n            }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (lower, upper) = self.iter.size_hint();\n\n        let lower = lower.saturating_sub(self.n);\n        let upper = upper.map(|x| x.saturating_sub(self.n));\n\n        (lower, upper)\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let n = self.n;\n        self.n = 0;\n        if n > 0 {\n            // nth(n) skips n+1\n            if self.iter.nth(n - 1).is_none() {\n                return Try::from_ok(init);\n            }\n        }\n        self.iter.try_fold(init, fold)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(mut self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        if self.n > 0 {\n            // nth(n) skips n+1\n            if self.iter.nth(self.n - 1).is_none() {\n                return init;\n            }\n        }\n        self.iter.fold(init, fold)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> ExactSizeIterator for Skip<I> where I: ExactSizeIterator {}\n\n#[stable(feature = \"double_ended_skip_iterator\", since = \"1.9.0\")]\nimpl<I> DoubleEndedIterator for Skip<I> where I: DoubleEndedIterator + ExactSizeIterator {\n    fn next_back(&mut self) -> Option<Self::Item> {\n        if self.len() > 0 {\n            self.iter.next_back()\n        } else {\n            None\n        }\n    }\n\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let mut n = self.len();\n        if n == 0 {\n            Try::from_ok(init)\n        } else {\n            self.iter.try_rfold(init, move |acc, x| {\n                n -= 1;\n                let r = fold(acc, x);\n                if n == 0 { LoopState::Break(r) }\n                else { LoopState::from_try(r) }\n            }).into_try()\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Skip<I> where I: FusedIterator {}\n\n/// An iterator that only iterates over the first `n` iterations of `iter`.\n///\n/// This `struct` is created by the [`take`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`take`]: trait.Iterator.html#method.take\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Take<I> {\n    iter: I,\n    n: usize\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Take<I> where I: Iterator{\n    type Item = <I as Iterator>::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<<I as Iterator>::Item> {\n        if self.n != 0 {\n            self.n -= 1;\n            self.iter.next()\n        } else {\n            None\n        }\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<I::Item> {\n        if self.n > n {\n            self.n -= n + 1;\n            self.iter.nth(n)\n        } else {\n            if self.n > 0 {\n                self.iter.nth(self.n - 1);\n                self.n = 0;\n            }\n            None\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (lower, upper) = self.iter.size_hint();\n\n        let lower = cmp::min(lower, self.n);\n\n        let upper = match upper {\n            Some(x) if x < self.n => Some(x),\n            _ => Some(self.n)\n        };\n\n        (lower, upper)\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if self.n == 0 {\n            Try::from_ok(init)\n        } else {\n            let n = &mut self.n;\n            self.iter.try_fold(init, move |acc, x| {\n                *n -= 1;\n                let r = fold(acc, x);\n                if *n == 0 { LoopState::Break(r) }\n                else { LoopState::from_try(r) }\n            }).into_try()\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> ExactSizeIterator for Take<I> where I: ExactSizeIterator {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Take<I> where I: FusedIterator {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<I: TrustedLen> TrustedLen for Take<I> {}\n\n/// An iterator to maintain state while iterating another iterator.\n///\n/// This `struct` is created by the [`scan`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`scan`]: trait.Iterator.html#method.scan\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct Scan<I, St, F> {\n    iter: I,\n    f: F,\n    state: St,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, St: fmt::Debug, F> fmt::Debug for Scan<I, St, F> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Scan\")\n            .field(\"iter\", &self.iter)\n            .field(\"state\", &self.state)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B, I, St, F> Iterator for Scan<I, St, F> where\n    I: Iterator,\n    F: FnMut(&mut St, I::Item) -> Option<B>,\n{\n    type Item = B;\n\n    #[inline]\n    fn next(&mut self) -> Option<B> {\n        self.iter.next().and_then(|a| (self.f)(&mut self.state, a))\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (_, upper) = self.iter.size_hint();\n        (0, upper) // can't know a lower bound, due to the scan function\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let state = &mut self.state;\n        let f = &mut self.f;\n        self.iter.try_fold(init, move |acc, x| {\n            match f(state, x) {\n                None => LoopState::Break(Try::from_ok(acc)),\n                Some(x) => LoopState::from_try(fold(acc, x)),\n            }\n        }).into_try()\n    }\n}\n\n/// An iterator that maps each element to an iterator, and yields the elements\n/// of the produced iterators.\n///\n/// This `struct` is created by the [`flat_map`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`flat_map`]: trait.Iterator.html#method.flat_map\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct FlatMap<I, U: IntoIterator, F> {\n    inner: FlattenCompat<Map<I, F>, <U as IntoIterator>::IntoIter>\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Clone, U: Clone + IntoIterator, F: Clone> Clone for FlatMap<I, U, F>\n    where <U as IntoIterator>::IntoIter: Clone\n{\n    fn clone(&self) -> Self { FlatMap { inner: self.inner.clone() } }\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, U: IntoIterator, F> fmt::Debug for FlatMap<I, U, F>\n    where U::IntoIter: fmt::Debug\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"FlatMap\").field(\"inner\", &self.inner).finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator, U: IntoIterator, F> Iterator for FlatMap<I, U, F>\n    where F: FnMut(I::Item) -> U,\n{\n    type Item = U::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<U::Item> { self.inner.next() }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.inner.try_fold(init, fold)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.inner.fold(init, fold)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: DoubleEndedIterator, U, F> DoubleEndedIterator for FlatMap<I, U, F>\n    where F: FnMut(I::Item) -> U,\n          U: IntoIterator,\n          U::IntoIter: DoubleEndedIterator\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<U::Item> { self.inner.next_back() }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.inner.try_rfold(init, fold)\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.inner.rfold(init, fold)\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I, U, F> FusedIterator for FlatMap<I, U, F>\n    where I: FusedIterator, U: IntoIterator, F: FnMut(I::Item) -> U {}\n\n/// An iterator that flattens one level of nesting in an iterator of things\n/// that can be turned into iterators.\n///\n/// This `struct` is created by the [`flatten`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`flatten`]: trait.Iterator.html#method.flatten\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\npub struct Flatten<I: Iterator>\nwhere I::Item: IntoIterator {\n    inner: FlattenCompat<I, <I::Item as IntoIterator>::IntoIter>,\n}\n\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\nimpl<I, U> fmt::Debug for Flatten<I>\n    where I: Iterator + fmt::Debug, U: Iterator + fmt::Debug,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>,\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Flatten\").field(\"inner\", &self.inner).finish()\n    }\n}\n\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\nimpl<I, U> Clone for Flatten<I>\n    where I: Iterator + Clone, U: Iterator + Clone,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>,\n{\n    fn clone(&self) -> Self { Flatten { inner: self.inner.clone() } }\n}\n\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\nimpl<I, U> Iterator for Flatten<I>\n    where I: Iterator, U: Iterator,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>\n{\n    type Item = U::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<U::Item> { self.inner.next() }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.inner.try_fold(init, fold)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.inner.fold(init, fold)\n    }\n}\n\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\nimpl<I, U> DoubleEndedIterator for Flatten<I>\n    where I: DoubleEndedIterator, U: DoubleEndedIterator,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<U::Item> { self.inner.next_back() }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.inner.try_rfold(init, fold)\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.inner.rfold(init, fold)\n    }\n}\n\n#[stable(feature = \"iterator_flatten\", since = \"1.29.0\")]\nimpl<I, U> FusedIterator for Flatten<I>\n    where I: FusedIterator, U: Iterator,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item> {}\n\n/// Adapts an iterator by flattening it, for use in `flatten()` and `flat_map()`.\nfn flatten_compat<I, U>(iter: I) -> FlattenCompat<I, U> {\n    FlattenCompat { iter, frontiter: None, backiter: None }\n}\n\n/// Real logic of both `Flatten` and `FlatMap` which simply delegate to\n/// this type.\n#[derive(Clone, Debug)]\nstruct FlattenCompat<I, U> {\n    iter: I,\n    frontiter: Option<U>,\n    backiter: Option<U>,\n}\n\nimpl<I, U> Iterator for FlattenCompat<I, U>\n    where I: Iterator, U: Iterator,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>\n{\n    type Item = U::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<U::Item> {\n        loop {\n            if let Some(ref mut inner) = self.frontiter {\n                if let elt@Some(_) = inner.next() { return elt }\n            }\n            match self.iter.next() {\n                None => return self.backiter.as_mut().and_then(|it| it.next()),\n                Some(inner) => self.frontiter = Some(inner.into_iter()),\n            }\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (flo, fhi) = self.frontiter.as_ref().map_or((0, Some(0)), |it| it.size_hint());\n        let (blo, bhi) = self.backiter.as_ref().map_or((0, Some(0)), |it| it.size_hint());\n        let lo = flo.saturating_add(blo);\n        match (self.iter.size_hint(), fhi, bhi) {\n            ((0, Some(0)), Some(a), Some(b)) => (lo, a.checked_add(b)),\n            _ => (lo, None)\n        }\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if let Some(ref mut front) = self.frontiter {\n            init = front.try_fold(init, &mut fold)?;\n        }\n        self.frontiter = None;\n\n        {\n            let frontiter = &mut self.frontiter;\n            init = self.iter.try_fold(init, |acc, x| {\n                let mut mid = x.into_iter();\n                let r = mid.try_fold(acc, &mut fold);\n                *frontiter = Some(mid);\n                r\n            })?;\n        }\n        self.frontiter = None;\n\n        if let Some(ref mut back) = self.backiter {\n            init = back.try_fold(init, &mut fold)?;\n        }\n        self.backiter = None;\n\n        Try::from_ok(init)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.frontiter.into_iter()\n            .chain(self.iter.map(IntoIterator::into_iter))\n            .chain(self.backiter)\n            .fold(init, |acc, iter| iter.fold(acc, &mut fold))\n    }\n}\n\nimpl<I, U> DoubleEndedIterator for FlattenCompat<I, U>\n    where I: DoubleEndedIterator, U: DoubleEndedIterator,\n          I::Item: IntoIterator<IntoIter = U, Item = U::Item>\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<U::Item> {\n        loop {\n            if let Some(ref mut inner) = self.backiter {\n                if let elt@Some(_) = inner.next_back() { return elt }\n            }\n            match self.iter.next_back() {\n                None => return self.frontiter.as_mut().and_then(|it| it.next_back()),\n                next => self.backiter = next.map(IntoIterator::into_iter),\n            }\n        }\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, mut init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if let Some(ref mut back) = self.backiter {\n            init = back.try_rfold(init, &mut fold)?;\n        }\n        self.backiter = None;\n\n        {\n            let backiter = &mut self.backiter;\n            init = self.iter.try_rfold(init, |acc, x| {\n                let mut mid = x.into_iter();\n                let r = mid.try_rfold(acc, &mut fold);\n                *backiter = Some(mid);\n                r\n            })?;\n        }\n        self.backiter = None;\n\n        if let Some(ref mut front) = self.frontiter {\n            init = front.try_rfold(init, &mut fold)?;\n        }\n        self.frontiter = None;\n\n        Try::from_ok(init)\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.frontiter.into_iter()\n            .chain(self.iter.map(IntoIterator::into_iter))\n            .chain(self.backiter)\n            .rfold(init, |acc, iter| iter.rfold(acc, &mut fold))\n    }\n}\n\n/// An iterator that yields `None` forever after the underlying iterator\n/// yields `None` once.\n///\n/// This `struct` is created by the [`fuse`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`fuse`]: trait.Iterator.html#method.fuse\n/// [`Iterator`]: trait.Iterator.html\n#[derive(Clone, Debug)]\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Fuse<I> {\n    iter: I,\n    done: bool\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> FusedIterator for Fuse<I> where I: Iterator {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> Iterator for Fuse<I> where I: Iterator {\n    type Item = <I as Iterator>::Item;\n\n    #[inline]\n    default fn next(&mut self) -> Option<<I as Iterator>::Item> {\n        if self.done {\n            None\n        } else {\n            let next = self.iter.next();\n            self.done = next.is_none();\n            next\n        }\n    }\n\n    #[inline]\n    default fn nth(&mut self, n: usize) -> Option<I::Item> {\n        if self.done {\n            None\n        } else {\n            let nth = self.iter.nth(n);\n            self.done = nth.is_none();\n            nth\n        }\n    }\n\n    #[inline]\n    default fn last(self) -> Option<I::Item> {\n        if self.done {\n            None\n        } else {\n            self.iter.last()\n        }\n    }\n\n    #[inline]\n    default fn count(self) -> usize {\n        if self.done {\n            0\n        } else {\n            self.iter.count()\n        }\n    }\n\n    #[inline]\n    default fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.done {\n            (0, Some(0))\n        } else {\n            self.iter.size_hint()\n        }\n    }\n\n    #[inline]\n    default fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if self.done {\n            Try::from_ok(init)\n        } else {\n            let acc = self.iter.try_fold(init, fold)?;\n            self.done = true;\n            Try::from_ok(acc)\n        }\n    }\n\n    #[inline]\n    default fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        if self.done {\n            init\n        } else {\n            self.iter.fold(init, fold)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> DoubleEndedIterator for Fuse<I> where I: DoubleEndedIterator {\n    #[inline]\n    default fn next_back(&mut self) -> Option<<I as Iterator>::Item> {\n        if self.done {\n            None\n        } else {\n            let next = self.iter.next_back();\n            self.done = next.is_none();\n            next\n        }\n    }\n\n    #[inline]\n    default fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        if self.done {\n            Try::from_ok(init)\n        } else {\n            let acc = self.iter.try_rfold(init, fold)?;\n            self.done = true;\n            Try::from_ok(acc)\n        }\n    }\n\n    #[inline]\n    default fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        if self.done {\n            init\n        } else {\n            self.iter.rfold(init, fold)\n        }\n    }\n}\n\nunsafe impl<I> TrustedRandomAccess for Fuse<I>\n    where I: TrustedRandomAccess,\n{\n    unsafe fn get_unchecked(&mut self, i: usize) -> I::Item {\n        self.iter.get_unchecked(i)\n    }\n\n    fn may_have_side_effect() -> bool {\n        I::may_have_side_effect()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> Iterator for Fuse<I> where I: FusedIterator {\n    #[inline]\n    fn next(&mut self) -> Option<<I as Iterator>::Item> {\n        self.iter.next()\n    }\n\n    #[inline]\n    fn nth(&mut self, n: usize) -> Option<I::Item> {\n        self.iter.nth(n)\n    }\n\n    #[inline]\n    fn last(self) -> Option<I::Item> {\n        self.iter.last()\n    }\n\n    #[inline]\n    fn count(self) -> usize {\n        self.iter.count()\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.iter.try_fold(init, fold)\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.iter.fold(init, fold)\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I> DoubleEndedIterator for Fuse<I>\n    where I: DoubleEndedIterator + FusedIterator\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<<I as Iterator>::Item> {\n        self.iter.next_back()\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        self.iter.try_rfold(init, fold)\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        self.iter.rfold(init, fold)\n    }\n}\n\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I> ExactSizeIterator for Fuse<I> where I: ExactSizeIterator {\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n/// An iterator that calls a function with a reference to each element before\n/// yielding it.\n///\n/// This `struct` is created by the [`inspect`] method on [`Iterator`]. See its\n/// documentation for more.\n///\n/// [`inspect`]: trait.Iterator.html#method.inspect\n/// [`Iterator`]: trait.Iterator.html\n#[must_use = \"iterator adaptors are lazy and do nothing unless consumed\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct Inspect<I, F> {\n    iter: I,\n    f: F,\n}\n\n#[stable(feature = \"core_impl_debug\", since = \"1.9.0\")]\nimpl<I: fmt::Debug, F> fmt::Debug for Inspect<I, F> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Inspect\")\n            .field(\"iter\", &self.iter)\n            .finish()\n    }\n}\n\nimpl<I: Iterator, F> Inspect<I, F> where F: FnMut(&I::Item) {\n    #[inline]\n    fn do_inspect(&mut self, elt: Option<I::Item>) -> Option<I::Item> {\n        if let Some(ref a) = elt {\n            (self.f)(a);\n        }\n\n        elt\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator, F> Iterator for Inspect<I, F> where F: FnMut(&I::Item) {\n    type Item = I::Item;\n\n    #[inline]\n    fn next(&mut self) -> Option<I::Item> {\n        let next = self.iter.next();\n        self.do_inspect(next)\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n\n    #[inline]\n    fn try_fold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_fold(init, move |acc, item| { f(&item); fold(acc, item) })\n    }\n\n    #[inline]\n    fn fold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.fold(init, move |acc, item| { f(&item); fold(acc, item) })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: DoubleEndedIterator, F> DoubleEndedIterator for Inspect<I, F>\n    where F: FnMut(&I::Item),\n{\n    #[inline]\n    fn next_back(&mut self) -> Option<I::Item> {\n        let next = self.iter.next_back();\n        self.do_inspect(next)\n    }\n\n    #[inline]\n    fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, mut fold: Fold) -> R where\n        Self: Sized, Fold: FnMut(Acc, Self::Item) -> R, R: Try<Ok=Acc>\n    {\n        let f = &mut self.f;\n        self.iter.try_rfold(init, move |acc, item| { f(&item); fold(acc, item) })\n    }\n\n    #[inline]\n    fn rfold<Acc, Fold>(self, init: Acc, mut fold: Fold) -> Acc\n        where Fold: FnMut(Acc, Self::Item) -> Acc,\n    {\n        let mut f = self.f;\n        self.iter.rfold(init, move |acc, item| { f(&item); fold(acc, item) })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: ExactSizeIterator, F> ExactSizeIterator for Inspect<I, F>\n    where F: FnMut(&I::Item)\n{\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n\n    fn is_empty(&self) -> bool {\n        self.iter.is_empty()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I: FusedIterator, F> FusedIterator for Inspect<I, F>\n    where F: FnMut(&I::Item) {}\n","// Copyright 2013-2016 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\nuse ops::{Mul, Add, Try};\nuse num::Wrapping;\n\nuse super::LoopState;\n\n/// Conversion from an `Iterator`.\n///\n/// By implementing `FromIterator` for a type, you define how it will be\n/// created from an iterator. This is common for types which describe a\n/// collection of some kind.\n///\n/// `FromIterator`'s [`from_iter`] is rarely called explicitly, and is instead\n/// used through [`Iterator`]'s [`collect`] method. See [`collect`]'s\n/// documentation for more examples.\n///\n/// [`from_iter`]: #tymethod.from_iter\n/// [`Iterator`]: trait.Iterator.html\n/// [`collect`]: trait.Iterator.html#method.collect\n///\n/// See also: [`IntoIterator`].\n///\n/// [`IntoIterator`]: trait.IntoIterator.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::iter::FromIterator;\n///\n/// let five_fives = std::iter::repeat(5).take(5);\n///\n/// let v = Vec::from_iter(five_fives);\n///\n/// assert_eq!(v, vec![5, 5, 5, 5, 5]);\n/// ```\n///\n/// Using [`collect`] to implicitly use `FromIterator`:\n///\n/// ```\n/// let five_fives = std::iter::repeat(5).take(5);\n///\n/// let v: Vec<i32> = five_fives.collect();\n///\n/// assert_eq!(v, vec![5, 5, 5, 5, 5]);\n/// ```\n///\n/// Implementing `FromIterator` for your type:\n///\n/// ```\n/// use std::iter::FromIterator;\n///\n/// // A sample collection, that's just a wrapper over Vec<T>\n/// #[derive(Debug)]\n/// struct MyCollection(Vec<i32>);\n///\n/// // Let's give it some methods so we can create one and add things\n/// // to it.\n/// impl MyCollection {\n///     fn new() -> MyCollection {\n///         MyCollection(Vec::new())\n///     }\n///\n///     fn add(&mut self, elem: i32) {\n///         self.0.push(elem);\n///     }\n/// }\n///\n/// // and we'll implement FromIterator\n/// impl FromIterator<i32> for MyCollection {\n///     fn from_iter<I: IntoIterator<Item=i32>>(iter: I) -> Self {\n///         let mut c = MyCollection::new();\n///\n///         for i in iter {\n///             c.add(i);\n///         }\n///\n///         c\n///     }\n/// }\n///\n/// // Now we can make a new iterator...\n/// let iter = (0..5).into_iter();\n///\n/// // ... and make a MyCollection out of it\n/// let c = MyCollection::from_iter(iter);\n///\n/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);\n///\n/// // collect works too!\n///\n/// let iter = (0..5).into_iter();\n/// let c: MyCollection = iter.collect();\n///\n/// assert_eq!(c.0, vec![0, 1, 2, 3, 4]);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(\n    message=\"a collection of type `{Self}` cannot be built from an iterator \\\n             over elements of type `{A}`\",\n    label=\"a collection of type `{Self}` cannot be built from `std::iter::Iterator<Item={A}>`\",\n)]\npub trait FromIterator<A>: Sized {\n    /// Creates a value from an iterator.\n    ///\n    /// See the [module-level documentation] for more.\n    ///\n    /// [module-level documentation]: index.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::iter::FromIterator;\n    ///\n    /// let five_fives = std::iter::repeat(5).take(5);\n    ///\n    /// let v = Vec::from_iter(five_fives);\n    ///\n    /// assert_eq!(v, vec![5, 5, 5, 5, 5]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn from_iter<T: IntoIterator<Item=A>>(iter: T) -> Self;\n}\n\n/// Conversion into an `Iterator`.\n///\n/// By implementing `IntoIterator` for a type, you define how it will be\n/// converted to an iterator. This is common for types which describe a\n/// collection of some kind.\n///\n/// One benefit of implementing `IntoIterator` is that your type will [work\n/// with Rust's `for` loop syntax](index.html#for-loops-and-intoiterator).\n///\n/// See also: [`FromIterator`].\n///\n/// [`FromIterator`]: trait.FromIterator.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let v = vec![1, 2, 3];\n/// let mut iter = v.into_iter();\n///\n/// assert_eq!(Some(1), iter.next());\n/// assert_eq!(Some(2), iter.next());\n/// assert_eq!(Some(3), iter.next());\n/// assert_eq!(None, iter.next());\n/// ```\n/// Implementing `IntoIterator` for your type:\n///\n/// ```\n/// // A sample collection, that's just a wrapper over Vec<T>\n/// #[derive(Debug)]\n/// struct MyCollection(Vec<i32>);\n///\n/// // Let's give it some methods so we can create one and add things\n/// // to it.\n/// impl MyCollection {\n///     fn new() -> MyCollection {\n///         MyCollection(Vec::new())\n///     }\n///\n///     fn add(&mut self, elem: i32) {\n///         self.0.push(elem);\n///     }\n/// }\n///\n/// // and we'll implement IntoIterator\n/// impl IntoIterator for MyCollection {\n///     type Item = i32;\n///     type IntoIter = ::std::vec::IntoIter<i32>;\n///\n///     fn into_iter(self) -> Self::IntoIter {\n///         self.0.into_iter()\n///     }\n/// }\n///\n/// // Now we can make a new collection...\n/// let mut c = MyCollection::new();\n///\n/// // ... add some stuff to it ...\n/// c.add(0);\n/// c.add(1);\n/// c.add(2);\n///\n/// // ... and then turn it into an Iterator:\n/// for (i, n) in c.into_iter().enumerate() {\n///     assert_eq!(i as i32, n);\n/// }\n/// ```\n///\n/// It is common to use `IntoIterator` as a trait bound. This allows\n/// the input collection type to change, so long as it is still an\n/// iterator. Additional bounds can be specified by restricting on\n/// `Item`:\n///\n/// ```rust\n/// fn collect_as_strings<T>(collection: T) -> Vec<String>\n///     where T: IntoIterator,\n///           T::Item : std::fmt::Debug,\n/// {\n///     collection\n///         .into_iter()\n///         .map(|item| format!(\"{:?}\", item))\n///         .collect()\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait IntoIterator {\n    /// The type of the elements being iterated over.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Item;\n\n    /// Which kind of iterator are we turning this into?\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type IntoIter: Iterator<Item=Self::Item>;\n\n    /// Creates an iterator from a value.\n    ///\n    /// See the [module-level documentation] for more.\n    ///\n    /// [module-level documentation]: index.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let v = vec![1, 2, 3];\n    /// let mut iter = v.into_iter();\n    ///\n    /// assert_eq!(Some(1), iter.next());\n    /// assert_eq!(Some(2), iter.next());\n    /// assert_eq!(Some(3), iter.next());\n    /// assert_eq!(None, iter.next());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn into_iter(self) -> Self::IntoIter;\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: Iterator> IntoIterator for I {\n    type Item = I::Item;\n    type IntoIter = I;\n\n    fn into_iter(self) -> I {\n        self\n    }\n}\n\n/// Extend a collection with the contents of an iterator.\n///\n/// Iterators produce a series of values, and collections can also be thought\n/// of as a series of values. The `Extend` trait bridges this gap, allowing you\n/// to extend a collection by including the contents of that iterator. When\n/// extending a collection with an already existing key, that entry is updated\n/// or, in the case of collections that permit multiple entries with equal\n/// keys, that entry is inserted.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // You can extend a String with some chars:\n/// let mut message = String::from(\"The first three letters are: \");\n///\n/// message.extend(&['a', 'b', 'c']);\n///\n/// assert_eq!(\"abc\", &message[29..32]);\n/// ```\n///\n/// Implementing `Extend`:\n///\n/// ```\n/// // A sample collection, that's just a wrapper over Vec<T>\n/// #[derive(Debug)]\n/// struct MyCollection(Vec<i32>);\n///\n/// // Let's give it some methods so we can create one and add things\n/// // to it.\n/// impl MyCollection {\n///     fn new() -> MyCollection {\n///         MyCollection(Vec::new())\n///     }\n///\n///     fn add(&mut self, elem: i32) {\n///         self.0.push(elem);\n///     }\n/// }\n///\n/// // since MyCollection has a list of i32s, we implement Extend for i32\n/// impl Extend<i32> for MyCollection {\n///\n///     // This is a bit simpler with the concrete type signature: we can call\n///     // extend on anything which can be turned into an Iterator which gives\n///     // us i32s. Because we need i32s to put into MyCollection.\n///     fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {\n///\n///         // The implementation is very straightforward: loop through the\n///         // iterator, and add() each element to ourselves.\n///         for elem in iter {\n///             self.add(elem);\n///         }\n///     }\n/// }\n///\n/// let mut c = MyCollection::new();\n///\n/// c.add(5);\n/// c.add(6);\n/// c.add(7);\n///\n/// // let's extend our collection with three more numbers\n/// c.extend(vec![1, 2, 3]);\n///\n/// // we've added these elements onto the end\n/// assert_eq!(\"MyCollection([5, 6, 7, 1, 2, 3])\", format!(\"{:?}\", c));\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Extend<A> {\n    /// Extends a collection with the contents of an iterator.\n    ///\n    /// As this is the only method for this trait, the [trait-level] docs\n    /// contain more details.\n    ///\n    /// [trait-level]: trait.Extend.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // You can extend a String with some chars:\n    /// let mut message = String::from(\"abc\");\n    ///\n    /// message.extend(['d', 'e', 'f'].iter());\n    ///\n    /// assert_eq!(\"abcdef\", &message);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn extend<T: IntoIterator<Item=A>>(&mut self, iter: T);\n}\n\n#[stable(feature = \"extend_for_unit\", since = \"1.28.0\")]\nimpl Extend<()> for () {\n    fn extend<T: IntoIterator<Item = ()>>(&mut self, iter: T) {\n        iter.into_iter().for_each(drop)\n    }\n}\n\n/// An iterator able to yield elements from both ends.\n///\n/// Something that implements `DoubleEndedIterator` has one extra capability\n/// over something that implements [`Iterator`]: the ability to also take\n/// `Item`s from the back, as well as the front.\n///\n/// It is important to note that both back and forth work on the same range,\n/// and do not cross: iteration is over when they meet in the middle.\n///\n/// In a similar fashion to the [`Iterator`] protocol, once a\n/// `DoubleEndedIterator` returns `None` from a `next_back()`, calling it again\n/// may or may not ever return `Some` again. `next()` and `next_back()` are\n/// interchangeable for this purpose.\n///\n/// [`Iterator`]: trait.Iterator.html\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let numbers = vec![1, 2, 3, 4, 5, 6];\n///\n/// let mut iter = numbers.iter();\n///\n/// assert_eq!(Some(&1), iter.next());\n/// assert_eq!(Some(&6), iter.next_back());\n/// assert_eq!(Some(&5), iter.next_back());\n/// assert_eq!(Some(&2), iter.next());\n/// assert_eq!(Some(&3), iter.next());\n/// assert_eq!(Some(&4), iter.next());\n/// assert_eq!(None, iter.next());\n/// assert_eq!(None, iter.next_back());\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait DoubleEndedIterator: Iterator {\n    /// Removes and returns an element from the end of the iterator.\n    ///\n    /// Returns `None` when there are no more elements.\n    ///\n    /// The [trait-level] docs contain more details.\n    ///\n    /// [trait-level]: trait.DoubleEndedIterator.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let numbers = vec![1, 2, 3, 4, 5, 6];\n    ///\n    /// let mut iter = numbers.iter();\n    ///\n    /// assert_eq!(Some(&1), iter.next());\n    /// assert_eq!(Some(&6), iter.next_back());\n    /// assert_eq!(Some(&5), iter.next_back());\n    /// assert_eq!(Some(&2), iter.next());\n    /// assert_eq!(Some(&3), iter.next());\n    /// assert_eq!(Some(&4), iter.next());\n    /// assert_eq!(None, iter.next());\n    /// assert_eq!(None, iter.next_back());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn next_back(&mut self) -> Option<Self::Item>;\n\n    /// This is the reverse version of [`try_fold()`]: it takes elements\n    /// starting from the back of the iterator.\n    ///\n    /// [`try_fold()`]: trait.Iterator.html#method.try_fold\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [\"1\", \"2\", \"3\"];\n    /// let sum = a.iter()\n    ///     .map(|&s| s.parse::<i32>())\n    ///     .try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y)));\n    /// assert_eq!(sum, Ok(6));\n    /// ```\n    ///\n    /// Short-circuiting:\n    ///\n    /// ```\n    /// let a = [\"1\", \"rust\", \"3\"];\n    /// let mut it = a.iter();\n    /// let sum = it\n    ///     .by_ref()\n    ///     .map(|&s| s.parse::<i32>())\n    ///     .try_rfold(0, |acc, x| x.and_then(|y| Ok(acc + y)));\n    /// assert!(sum.is_err());\n    ///\n    /// // Because it short-circuited, the remaining elements are still\n    /// // available through the iterator.\n    /// assert_eq!(it.next_back(), Some(&\"1\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iterator_try_fold\", since = \"1.27.0\")]\n    fn try_rfold<B, F, R>(&mut self, init: B, mut f: F) -> R where\n        Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Ok=B>\n    {\n        let mut accum = init;\n        while let Some(x) = self.next_back() {\n            accum = f(accum, x)?;\n        }\n        Try::from_ok(accum)\n    }\n\n    /// An iterator method that reduces the iterator's elements to a single,\n    /// final value, starting from the back.\n    ///\n    /// This is the reverse version of [`fold()`]: it takes elements starting from\n    /// the back of the iterator.\n    ///\n    /// `rfold()` takes two arguments: an initial value, and a closure with two\n    /// arguments: an 'accumulator', and an element. The closure returns the value that\n    /// the accumulator should have for the next iteration.\n    ///\n    /// The initial value is the value the accumulator will have on the first\n    /// call.\n    ///\n    /// After applying this closure to every element of the iterator, `rfold()`\n    /// returns the accumulator.\n    ///\n    /// This operation is sometimes called 'reduce' or 'inject'.\n    ///\n    /// Folding is useful whenever you have a collection of something, and want\n    /// to produce a single value from it.\n    ///\n    /// [`fold()`]: trait.Iterator.html#method.fold\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// // the sum of all of the elements of a\n    /// let sum = a.iter()\n    ///            .rfold(0, |acc, &x| acc + x);\n    ///\n    /// assert_eq!(sum, 6);\n    /// ```\n    ///\n    /// This example builds a string, starting with an initial value\n    /// and continuing with each element from the back until the front:\n    ///\n    /// ```\n    /// let numbers = [1, 2, 3, 4, 5];\n    ///\n    /// let zero = \"0\".to_string();\n    ///\n    /// let result = numbers.iter().rfold(zero, |acc, &x| {\n    ///     format!(\"({} + {})\", x, acc)\n    /// });\n    ///\n    /// assert_eq!(result, \"(1 + (2 + (3 + (4 + (5 + 0)))))\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"iter_rfold\", since = \"1.27.0\")]\n    fn rfold<B, F>(mut self, accum: B, mut f: F) -> B where\n        Self: Sized, F: FnMut(B, Self::Item) -> B,\n    {\n        self.try_rfold(accum, move |acc, x| Ok::<B, !>(f(acc, x))).unwrap()\n    }\n\n    /// Searches for an element of an iterator from the back that satisfies a predicate.\n    ///\n    /// `rfind()` takes a closure that returns `true` or `false`. It applies\n    /// this closure to each element of the iterator, starting at the end, and if any\n    /// of them return `true`, then `rfind()` returns [`Some(element)`]. If they all return\n    /// `false`, it returns [`None`].\n    ///\n    /// `rfind()` is short-circuiting; in other words, it will stop processing\n    /// as soon as the closure returns `true`.\n    ///\n    /// Because `rfind()` takes a reference, and many iterators iterate over\n    /// references, this leads to a possibly confusing situation where the\n    /// argument is a double reference. You can see this effect in the\n    /// examples below, with `&&x`.\n    ///\n    /// [`Some(element)`]: ../../std/option/enum.Option.html#variant.Some\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// assert_eq!(a.iter().rfind(|&&x| x == 2), Some(&2));\n    ///\n    /// assert_eq!(a.iter().rfind(|&&x| x == 5), None);\n    /// ```\n    ///\n    /// Stopping at the first `true`:\n    ///\n    /// ```\n    /// let a = [1, 2, 3];\n    ///\n    /// let mut iter = a.iter();\n    ///\n    /// assert_eq!(iter.rfind(|&&x| x == 2), Some(&2));\n    ///\n    /// // we can still use `iter`, as there are more elements.\n    /// assert_eq!(iter.next_back(), Some(&1));\n    /// ```\n    #[inline]\n    #[stable(feature = \"iter_rfind\", since = \"1.27.0\")]\n    fn rfind<P>(&mut self, mut predicate: P) -> Option<Self::Item> where\n        Self: Sized,\n        P: FnMut(&Self::Item) -> bool\n    {\n        self.try_rfold((), move |(), x| {\n            if predicate(&x) { LoopState::Break(x) }\n            else { LoopState::Continue(()) }\n        }).break_value()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for &'a mut I {\n    fn next_back(&mut self) -> Option<I::Item> { (**self).next_back() }\n}\n\n/// An iterator that knows its exact length.\n///\n/// Many [`Iterator`]s don't know how many times they will iterate, but some do.\n/// If an iterator knows how many times it can iterate, providing access to\n/// that information can be useful. For example, if you want to iterate\n/// backwards, a good start is to know where the end is.\n///\n/// When implementing an `ExactSizeIterator`, you must also implement\n/// [`Iterator`]. When doing so, the implementation of [`size_hint`] *must*\n/// return the exact size of the iterator.\n///\n/// [`Iterator`]: trait.Iterator.html\n/// [`size_hint`]: trait.Iterator.html#method.size_hint\n///\n/// The [`len`] method has a default implementation, so you usually shouldn't\n/// implement it. However, you may be able to provide a more performant\n/// implementation than the default, so overriding it in this case makes sense.\n///\n/// [`len`]: #method.len\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// // a finite range knows exactly how many times it will iterate\n/// let five = 0..5;\n///\n/// assert_eq!(5, five.len());\n/// ```\n///\n/// In the [module level docs][moddocs], we implemented an [`Iterator`],\n/// `Counter`. Let's implement `ExactSizeIterator` for it as well:\n///\n/// [moddocs]: index.html\n///\n/// ```\n/// # struct Counter {\n/// #     count: usize,\n/// # }\n/// # impl Counter {\n/// #     fn new() -> Counter {\n/// #         Counter { count: 0 }\n/// #     }\n/// # }\n/// # impl Iterator for Counter {\n/// #     type Item = usize;\n/// #     fn next(&mut self) -> Option<usize> {\n/// #         self.count += 1;\n/// #         if self.count < 6 {\n/// #             Some(self.count)\n/// #         } else {\n/// #             None\n/// #         }\n/// #     }\n/// # }\n/// impl ExactSizeIterator for Counter {\n///     // We can easily calculate the remaining number of iterations.\n///     fn len(&self) -> usize {\n///         5 - self.count\n///     }\n/// }\n///\n/// // And now we can use it!\n///\n/// let counter = Counter::new();\n///\n/// assert_eq!(5, counter.len());\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait ExactSizeIterator: Iterator {\n    /// Returns the exact number of times the iterator will iterate.\n    ///\n    /// This method has a default implementation, so you usually should not\n    /// implement it directly. However, if you can provide a more efficient\n    /// implementation, you can do so. See the [trait-level] docs for an\n    /// example.\n    ///\n    /// This function has the same safety guarantees as the [`size_hint`]\n    /// function.\n    ///\n    /// [trait-level]: trait.ExactSizeIterator.html\n    /// [`size_hint`]: trait.Iterator.html#method.size_hint\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// // a finite range knows exactly how many times it will iterate\n    /// let five = 0..5;\n    ///\n    /// assert_eq!(5, five.len());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn len(&self) -> usize {\n        let (lower, upper) = self.size_hint();\n        // Note: This assertion is overly defensive, but it checks the invariant\n        // guaranteed by the trait. If this trait were rust-internal,\n        // we could use debug_assert!; assert_eq! will check all Rust user\n        // implementations too.\n        assert_eq!(upper, Some(lower));\n        lower\n    }\n\n    /// Returns whether the iterator is empty.\n    ///\n    /// This method has a default implementation using `self.len()`, so you\n    /// don't need to implement it yourself.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(exact_size_is_empty)]\n    ///\n    /// let mut one_element = std::iter::once(0);\n    /// assert!(!one_element.is_empty());\n    ///\n    /// assert_eq!(one_element.next(), Some(0));\n    /// assert!(one_element.is_empty());\n    ///\n    /// assert_eq!(one_element.next(), None);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"exact_size_is_empty\", issue = \"35428\")]\n    fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for &mut I {\n    fn len(&self) -> usize {\n        (**self).len()\n    }\n    fn is_empty(&self) -> bool {\n        (**self).is_empty()\n    }\n}\n\n/// Trait to represent types that can be created by summing up an iterator.\n///\n/// This trait is used to implement the [`sum`] method on iterators. Types which\n/// implement the trait can be generated by the [`sum`] method. Like\n/// [`FromIterator`] this trait should rarely be called directly and instead\n/// interacted with through [`Iterator::sum`].\n///\n/// [`sum`]: ../../std/iter/trait.Sum.html#tymethod.sum\n/// [`FromIterator`]: ../../std/iter/trait.FromIterator.html\n/// [`Iterator::sum`]: ../../std/iter/trait.Iterator.html#method.sum\n#[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\npub trait Sum<A = Self>: Sized {\n    /// Method which takes an iterator and generates `Self` from the elements by\n    /// \"summing up\" the items.\n    #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n    fn sum<I: Iterator<Item=A>>(iter: I) -> Self;\n}\n\n/// Trait to represent types that can be created by multiplying elements of an\n/// iterator.\n///\n/// This trait is used to implement the [`product`] method on iterators. Types\n/// which implement the trait can be generated by the [`product`] method. Like\n/// [`FromIterator`] this trait should rarely be called directly and instead\n/// interacted with through [`Iterator::product`].\n///\n/// [`product`]: ../../std/iter/trait.Product.html#tymethod.product\n/// [`FromIterator`]: ../../std/iter/trait.FromIterator.html\n/// [`Iterator::product`]: ../../std/iter/trait.Iterator.html#method.product\n#[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\npub trait Product<A = Self>: Sized {\n    /// Method which takes an iterator and generates `Self` from the elements by\n    /// multiplying the items.\n    #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n    fn product<I: Iterator<Item=A>>(iter: I) -> Self;\n}\n\n// NB: explicitly use Add and Mul here to inherit overflow checks\nmacro_rules! integer_sum_product {\n    (@impls $zero:expr, $one:expr, #[$attr:meta], $($a:ty)*) => ($(\n        #[$attr]\n        impl Sum for $a {\n            fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {\n                iter.fold($zero, Add::add)\n            }\n        }\n\n        #[$attr]\n        impl Product for $a {\n            fn product<I: Iterator<Item=$a>>(iter: I) -> $a {\n                iter.fold($one, Mul::mul)\n            }\n        }\n\n        #[$attr]\n        impl<'a> Sum<&'a $a> for $a {\n            fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {\n                iter.fold($zero, Add::add)\n            }\n        }\n\n        #[$attr]\n        impl<'a> Product<&'a $a> for $a {\n            fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {\n                iter.fold($one, Mul::mul)\n            }\n        }\n    )*);\n    ($($a:ty)*) => (\n        integer_sum_product!(@impls 0, 1,\n                #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")],\n                $($a)+);\n        integer_sum_product!(@impls Wrapping(0), Wrapping(1),\n                #[stable(feature = \"wrapping_iter_arith\", since = \"1.14.0\")],\n                $(Wrapping<$a>)+);\n    );\n}\n\nmacro_rules! float_sum_product {\n    ($($a:ident)*) => ($(\n        #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n        impl Sum for $a {\n            fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {\n                iter.fold(0.0, |a, b| a + b)\n            }\n        }\n\n        #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n        impl Product for $a {\n            fn product<I: Iterator<Item=$a>>(iter: I) -> $a {\n                iter.fold(1.0, |a, b| a * b)\n            }\n        }\n\n        #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n        impl<'a> Sum<&'a $a> for $a {\n            fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {\n                iter.fold(0.0, |a, b| a + *b)\n            }\n        }\n\n        #[stable(feature = \"iter_arith_traits\", since = \"1.12.0\")]\n        impl<'a> Product<&'a $a> for $a {\n            fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {\n                iter.fold(1.0, |a, b| a * *b)\n            }\n        }\n    )*)\n}\n\ninteger_sum_product! { i8 i16 i32 i64 i128 isize u8 u16 u32 u64 u128 usize }\nfloat_sum_product! { f32 f64 }\n\n/// An iterator adapter that produces output as long as the underlying\n/// iterator produces `Result::Ok` values.\n///\n/// If an error is encountered, the iterator stops and the error is\n/// stored. The error may be recovered later via `reconstruct`.\nstruct ResultShunt<I, E> {\n    iter: I,\n    error: Option<E>,\n}\n\nimpl<I, T, E> ResultShunt<I, E>\n    where I: Iterator<Item = Result<T, E>>\n{\n    /// Process the given iterator as if it yielded a `T` instead of a\n    /// `Result<T, _>`. Any errors will stop the inner iterator and\n    /// the overall result will be an error.\n    pub fn process<F, U>(iter: I, mut f: F) -> Result<U, E>\n        where F: FnMut(&mut Self) -> U\n    {\n        let mut shunt = ResultShunt::new(iter);\n        let value = f(shunt.by_ref());\n        shunt.reconstruct(value)\n    }\n\n    fn new(iter: I) -> Self {\n        ResultShunt {\n            iter,\n            error: None,\n        }\n    }\n\n    /// Consume the adapter and rebuild a `Result` value. This should\n    /// *always* be called, otherwise any potential error would be\n    /// lost.\n    fn reconstruct<U>(self, val: U) -> Result<U, E> {\n        match self.error {\n            None => Ok(val),\n            Some(e) => Err(e),\n        }\n    }\n}\n\nimpl<I, T, E> Iterator for ResultShunt<I, E>\n    where I: Iterator<Item = Result<T, E>>\n{\n    type Item = T;\n\n    fn next(&mut self) -> Option<Self::Item> {\n        match self.iter.next() {\n            Some(Ok(v)) => Some(v),\n            Some(Err(e)) => {\n                self.error = Some(e);\n                None\n            }\n            None => None,\n        }\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        if self.error.is_some() {\n            (0, Some(0))\n        } else {\n            let (_, upper) = self.iter.size_hint();\n            (0, upper)\n        }\n    }\n}\n\n#[stable(feature = \"iter_arith_traits_result\", since=\"1.16.0\")]\nimpl<T, U, E> Sum<Result<U, E>> for Result<T, E>\n    where T: Sum<U>,\n{\n    /// Takes each element in the `Iterator`: if it is an `Err`, no further\n    /// elements are taken, and the `Err` is returned. Should no `Err` occur,\n    /// the sum of all elements is returned.\n    ///\n    /// # Examples\n    ///\n    /// This sums up every integer in a vector, rejecting the sum if a negative\n    /// element is encountered:\n    ///\n    /// ```\n    /// let v = vec![1, 2];\n    /// let res: Result<i32, &'static str> = v.iter().map(|&x: &i32|\n    ///     if x < 0 { Err(\"Negative element found\") }\n    ///     else { Ok(x) }\n    /// ).sum();\n    /// assert_eq!(res, Ok(3));\n    /// ```\n    fn sum<I>(iter: I) -> Result<T, E>\n        where I: Iterator<Item = Result<U, E>>,\n    {\n        ResultShunt::process(iter, |i| i.sum())\n    }\n}\n\n#[stable(feature = \"iter_arith_traits_result\", since=\"1.16.0\")]\nimpl<T, U, E> Product<Result<U, E>> for Result<T, E>\n    where T: Product<U>,\n{\n    /// Takes each element in the `Iterator`: if it is an `Err`, no further\n    /// elements are taken, and the `Err` is returned. Should no `Err` occur,\n    /// the product of all elements is returned.\n    fn product<I>(iter: I) -> Result<T, E>\n        where I: Iterator<Item = Result<U, E>>,\n    {\n        ResultShunt::process(iter, |i| i.product())\n    }\n}\n\n/// An iterator that always continues to yield `None` when exhausted.\n///\n/// Calling next on a fused iterator that has returned `None` once is guaranteed\n/// to return [`None`] again. This trait should be implemented by all iterators\n/// that behave this way because it allows for some significant optimizations.\n///\n/// Note: In general, you should not use `FusedIterator` in generic bounds if\n/// you need a fused iterator. Instead, you should just call [`Iterator::fuse`]\n/// on the iterator. If the iterator is already fused, the additional [`Fuse`]\n/// wrapper will be a no-op with no performance penalty.\n///\n/// [`None`]: ../../std/option/enum.Option.html#variant.None\n/// [`Iterator::fuse`]: ../../std/iter/trait.Iterator.html#method.fuse\n/// [`Fuse`]: ../../std/iter/struct.Fuse.html\n#[stable(feature = \"fused\", since = \"1.26.0\")]\npub trait FusedIterator: Iterator {}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<I: FusedIterator + ?Sized> FusedIterator for &mut I {}\n\n/// An iterator that reports an accurate length using size_hint.\n///\n/// The iterator reports a size hint where it is either exact\n/// (lower bound is equal to upper bound), or the upper bound is [`None`].\n/// The upper bound must only be [`None`] if the actual iterator length is\n/// larger than [`usize::MAX`]. In that case, the lower bound must be\n/// [`usize::MAX`], resulting in a [`.size_hint`] of `(usize::MAX, None)`.\n///\n/// The iterator must produce exactly the number of elements it reported\n/// or diverge before reaching the end.\n///\n/// # Safety\n///\n/// This trait must only be implemented when the contract is upheld.\n/// Consumers of this trait must inspect [`.size_hint`]\u2019s upper bound.\n///\n/// [`None`]: ../../std/option/enum.Option.html#variant.None\n/// [`usize::MAX`]: ../../std/usize/constant.MAX.html\n/// [`.size_hint`]: ../../std/iter/trait.Iterator.html#method.size_hint\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\npub unsafe trait TrustedLen : Iterator {}\n\n#[unstable(feature = \"trusted_len\", issue = \"37572\")]\nunsafe impl<I: TrustedLen + ?Sized> TrustedLen for &mut I {}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Implementations of things like `Eq` for fixed-length arrays\n//! up to a certain length. Eventually we should able to generalize\n//! to all lengths.\n//!\n//! *[See also the array primitive type](../../std/primitive.array.html).*\n\n#![unstable(feature = \"fixed_size_array\",\n            reason = \"traits and impls are better expressed through generic \\\n                      integer constants\",\n            issue = \"27778\")]\n\nuse borrow::{Borrow, BorrowMut};\nuse cmp::Ordering;\nuse convert::TryFrom;\nuse fmt;\nuse hash::{Hash, self};\nuse marker::Unsize;\nuse slice::{Iter, IterMut};\n\n/// Utility trait implemented only on arrays of fixed size\n///\n/// This trait can be used to implement other traits on fixed-size arrays\n/// without causing much metadata bloat.\n///\n/// The trait is marked unsafe in order to restrict implementors to fixed-size\n/// arrays. User of this trait can assume that implementors have the exact\n/// layout in memory of a fixed size array (for example, for unsafe\n/// initialization).\n///\n/// Note that the traits AsRef and AsMut provide similar methods for types that\n/// may not be fixed-size arrays. Implementors should prefer those traits\n/// instead.\npub unsafe trait FixedSizeArray<T> {\n    /// Converts the array to immutable slice\n    fn as_slice(&self) -> &[T];\n    /// Converts the array to mutable slice\n    fn as_mut_slice(&mut self) -> &mut [T];\n}\n\nunsafe impl<T, A: Unsize<[T]>> FixedSizeArray<T> for A {\n    #[inline]\n    fn as_slice(&self) -> &[T] {\n        self\n    }\n    #[inline]\n    fn as_mut_slice(&mut self) -> &mut [T] {\n        self\n    }\n}\n\n/// The error type returned when a conversion from a slice to an array fails.\n#[unstable(feature = \"try_from\", issue = \"33417\")]\n#[derive(Debug, Copy, Clone)]\npub struct TryFromSliceError(());\n\nimpl fmt::Display for TryFromSliceError {\n    #[inline]\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self.__description(), f)\n    }\n}\n\nimpl TryFromSliceError {\n    #[unstable(feature = \"array_error_internals\",\n           reason = \"available through Error trait and this method should not \\\n                     be exposed publicly\",\n           issue = \"0\")]\n    #[inline]\n    #[doc(hidden)]\n    pub fn __description(&self) -> &str {\n        \"could not convert slice to array\"\n    }\n}\n\nmacro_rules! __impl_slice_eq1 {\n    ($Lhs: ty, $Rhs: ty) => {\n        __impl_slice_eq1! { $Lhs, $Rhs, Sized }\n    };\n    ($Lhs: ty, $Rhs: ty, $Bound: ident) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {\n            #[inline]\n            fn eq(&self, other: &$Rhs) -> bool { self[..] == other[..] }\n            #[inline]\n            fn ne(&self, other: &$Rhs) -> bool { self[..] != other[..] }\n        }\n    }\n}\n\nmacro_rules! __impl_slice_eq2 {\n    ($Lhs: ty, $Rhs: ty) => {\n        __impl_slice_eq2! { $Lhs, $Rhs, Sized }\n    };\n    ($Lhs: ty, $Rhs: ty, $Bound: ident) => {\n        __impl_slice_eq1!($Lhs, $Rhs, $Bound);\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl<'a, 'b, A: $Bound, B> PartialEq<$Lhs> for $Rhs where B: PartialEq<A> {\n            #[inline]\n            fn eq(&self, other: &$Lhs) -> bool { self[..] == other[..] }\n            #[inline]\n            fn ne(&self, other: &$Lhs) -> bool { self[..] != other[..] }\n        }\n    }\n}\n\n// macro for implementing n-element array functions and operations\nmacro_rules! array_impls {\n    ($($N:expr)+) => {\n        $(\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T> AsRef<[T]> for [T; $N] {\n                #[inline]\n                fn as_ref(&self) -> &[T] {\n                    &self[..]\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T> AsMut<[T]> for [T; $N] {\n                #[inline]\n                fn as_mut(&mut self) -> &mut [T] {\n                    &mut self[..]\n                }\n            }\n\n            #[stable(feature = \"array_borrow\", since = \"1.4.0\")]\n            impl<T> Borrow<[T]> for [T; $N] {\n                fn borrow(&self) -> &[T] {\n                    self\n                }\n            }\n\n            #[stable(feature = \"array_borrow\", since = \"1.4.0\")]\n            impl<T> BorrowMut<[T]> for [T; $N] {\n                fn borrow_mut(&mut self) -> &mut [T] {\n                    self\n                }\n            }\n\n            #[unstable(feature = \"try_from\", issue = \"33417\")]\n            impl<'a, T> TryFrom<&'a [T]> for &'a [T; $N] {\n                type Error = TryFromSliceError;\n\n                fn try_from(slice: &[T]) -> Result<&[T; $N], TryFromSliceError> {\n                    if slice.len() == $N {\n                        let ptr = slice.as_ptr() as *const [T; $N];\n                        unsafe { Ok(&*ptr) }\n                    } else {\n                        Err(TryFromSliceError(()))\n                    }\n                }\n            }\n\n            #[unstable(feature = \"try_from\", issue = \"33417\")]\n            impl<'a, T> TryFrom<&'a mut [T]> for &'a mut [T; $N] {\n                type Error = TryFromSliceError;\n\n                fn try_from(slice: &mut [T]) -> Result<&mut [T; $N], TryFromSliceError> {\n                    if slice.len() == $N {\n                        let ptr = slice.as_mut_ptr() as *mut [T; $N];\n                        unsafe { Ok(&mut *ptr) }\n                    } else {\n                        Err(TryFromSliceError(()))\n                    }\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T: Hash> Hash for [T; $N] {\n                fn hash<H: hash::Hasher>(&self, state: &mut H) {\n                    Hash::hash(&self[..], state)\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T: fmt::Debug> fmt::Debug for [T; $N] {\n                fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                    fmt::Debug::fmt(&&self[..], f)\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<'a, T> IntoIterator for &'a [T; $N] {\n                type Item = &'a T;\n                type IntoIter = Iter<'a, T>;\n\n                fn into_iter(self) -> Iter<'a, T> {\n                    self.iter()\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<'a, T> IntoIterator for &'a mut [T; $N] {\n                type Item = &'a mut T;\n                type IntoIter = IterMut<'a, T>;\n\n                fn into_iter(self) -> IterMut<'a, T> {\n                    self.iter_mut()\n                }\n            }\n\n            // NOTE: some less important impls are omitted to reduce code bloat\n            __impl_slice_eq1! { [A; $N], [B; $N] }\n            __impl_slice_eq2! { [A; $N], [B] }\n            __impl_slice_eq2! { [A; $N], &'b [B] }\n            __impl_slice_eq2! { [A; $N], &'b mut [B] }\n            // __impl_slice_eq2! { [A; $N], &'b [B; $N] }\n            // __impl_slice_eq2! { [A; $N], &'b mut [B; $N] }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T:Eq> Eq for [T; $N] { }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T:PartialOrd> PartialOrd for [T; $N] {\n                #[inline]\n                fn partial_cmp(&self, other: &[T; $N]) -> Option<Ordering> {\n                    PartialOrd::partial_cmp(&&self[..], &&other[..])\n                }\n                #[inline]\n                fn lt(&self, other: &[T; $N]) -> bool {\n                    PartialOrd::lt(&&self[..], &&other[..])\n                }\n                #[inline]\n                fn le(&self, other: &[T; $N]) -> bool {\n                    PartialOrd::le(&&self[..], &&other[..])\n                }\n                #[inline]\n                fn ge(&self, other: &[T; $N]) -> bool {\n                    PartialOrd::ge(&&self[..], &&other[..])\n                }\n                #[inline]\n                fn gt(&self, other: &[T; $N]) -> bool {\n                    PartialOrd::gt(&&self[..], &&other[..])\n                }\n            }\n\n            #[stable(feature = \"rust1\", since = \"1.0.0\")]\n            impl<T:Ord> Ord for [T; $N] {\n                #[inline]\n                fn cmp(&self, other: &[T; $N]) -> Ordering {\n                    Ord::cmp(&&self[..], &&other[..])\n                }\n            }\n        )+\n    }\n}\n\narray_impls! {\n     0  1  2  3  4  5  6  7  8  9\n    10 11 12 13 14 15 16 17 18 19\n    20 21 22 23 24 25 26 27 28 29\n    30 31 32\n}\n\n// The Default impls cannot be generated using the array_impls! macro because\n// they require array literals.\n\nmacro_rules! array_impl_default {\n    {$n:expr, $t:ident $($ts:ident)*} => {\n        #[stable(since = \"1.4.0\", feature = \"array_default\")]\n        impl<T> Default for [T; $n] where T: Default {\n            fn default() -> [T; $n] {\n                [$t::default(), $($ts::default()),*]\n            }\n        }\n        array_impl_default!{($n - 1), $($ts)*}\n    };\n    {$n:expr,} => {\n        #[stable(since = \"1.4.0\", feature = \"array_default\")]\n        impl<T> Default for [T; $n] {\n            fn default() -> [T; $n] { [] }\n        }\n    };\n}\n\narray_impl_default!{32, T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n//! Thread-safe reference-counting pointers.\n//!\n//! See the [`Arc<T>`][arc] documentation for more details.\n//!\n//! [arc]: struct.Arc.html\n\nuse core::any::Any;\nuse core::sync::atomic;\nuse core::sync::atomic::Ordering::{Acquire, Relaxed, Release, SeqCst};\nuse core::borrow;\nuse core::fmt;\nuse core::cmp::Ordering;\nuse core::intrinsics::abort;\nuse core::mem::{self, align_of_val, size_of_val};\nuse core::ops::Deref;\nuse core::ops::{CoerceUnsized, DispatchFromDyn};\nuse core::pin::Pin;\nuse core::ptr::{self, NonNull};\nuse core::marker::{Unpin, Unsize, PhantomData};\nuse core::hash::{Hash, Hasher};\nuse core::{isize, usize};\nuse core::convert::From;\n\nuse alloc::{Global, Alloc, Layout, box_free, handle_alloc_error};\nuse boxed::Box;\nuse rc::is_dangling;\nuse string::String;\nuse vec::Vec;\n\n/// A soft limit on the amount of references that may be made to an `Arc`.\n///\n/// Going above this limit will abort your program (although not\n/// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references.\nconst MAX_REFCOUNT: usize = (isize::MAX) as usize;\n\n/// A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically\n/// Reference Counted'.\n///\n/// The type `Arc<T>` provides shared ownership of a value of type `T`,\n/// allocated in the heap. Invoking [`clone`][clone] on `Arc` produces\n/// a new `Arc` instance, which points to the same value on the heap as the\n/// source `Arc`, while increasing a reference count. When the last `Arc`\n/// pointer to a given value is destroyed, the pointed-to value is also\n/// destroyed.\n///\n/// Shared references in Rust disallow mutation by default, and `Arc` is no\n/// exception: you cannot generally obtain a mutable reference to something\n/// inside an `Arc`. If you need to mutate through an `Arc`, use\n/// [`Mutex`][mutex], [`RwLock`][rwlock], or one of the [`Atomic`][atomic]\n/// types.\n///\n/// ## Thread Safety\n///\n/// Unlike [`Rc<T>`], `Arc<T>` uses atomic operations for its reference\n/// counting. This means that it is thread-safe. The disadvantage is that\n/// atomic operations are more expensive than ordinary memory accesses. If you\n/// are not sharing reference-counted values between threads, consider using\n/// [`Rc<T>`] for lower overhead. [`Rc<T>`] is a safe default, because the\n/// compiler will catch any attempt to send an [`Rc<T>`] between threads.\n/// However, a library might choose `Arc<T>` in order to give library consumers\n/// more flexibility.\n///\n/// `Arc<T>` will implement [`Send`] and [`Sync`] as long as the `T` implements\n/// [`Send`] and [`Sync`]. Why can't you put a non-thread-safe type `T` in an\n/// `Arc<T>` to make it thread-safe? This may be a bit counter-intuitive at\n/// first: after all, isn't the point of `Arc<T>` thread safety? The key is\n/// this: `Arc<T>` makes it thread safe to have multiple ownership of the same\n/// data, but it  doesn't add thread safety to its data. Consider\n/// `Arc<`[`RefCell<T>`]`>`. [`RefCell<T>`] isn't [`Sync`], and if `Arc<T>` was always\n/// [`Send`], `Arc<`[`RefCell<T>`]`>` would be as well. But then we'd have a problem:\n/// [`RefCell<T>`] is not thread safe; it keeps track of the borrowing count using\n/// non-atomic operations.\n///\n/// In the end, this means that you may need to pair `Arc<T>` with some sort of\n/// [`std::sync`] type, usually [`Mutex<T>`][mutex].\n///\n/// ## Breaking cycles with `Weak`\n///\n/// The [`downgrade`][downgrade] method can be used to create a non-owning\n/// [`Weak`][weak] pointer. A [`Weak`][weak] pointer can be [`upgrade`][upgrade]d\n/// to an `Arc`, but this will return [`None`] if the value has already been\n/// dropped.\n///\n/// A cycle between `Arc` pointers will never be deallocated. For this reason,\n/// [`Weak`][weak] is used to break cycles. For example, a tree could have\n/// strong `Arc` pointers from parent nodes to children, and [`Weak`][weak]\n/// pointers from children back to their parents.\n///\n/// # Cloning references\n///\n/// Creating a new reference from an existing reference counted pointer is done using the\n/// `Clone` trait implemented for [`Arc<T>`][arc] and [`Weak<T>`][weak].\n///\n/// ```\n/// use std::sync::Arc;\n/// let foo = Arc::new(vec![1.0, 2.0, 3.0]);\n/// // The two syntaxes below are equivalent.\n/// let a = foo.clone();\n/// let b = Arc::clone(&foo);\n/// // a, b, and foo are all Arcs that point to the same memory location\n/// ```\n///\n/// The [`Arc::clone(&from)`] syntax is the most idiomatic because it conveys more explicitly\n/// the meaning of the code. In the example above, this syntax makes it easier to see that\n/// this code is creating a new reference rather than copying the whole content of foo.\n///\n/// ## `Deref` behavior\n///\n/// `Arc<T>` automatically dereferences to `T` (via the [`Deref`][deref] trait),\n/// so you can call `T`'s methods on a value of type `Arc<T>`. To avoid name\n/// clashes with `T`'s methods, the methods of `Arc<T>` itself are [associated\n/// functions][assoc], called using function-like syntax:\n///\n/// ```\n/// use std::sync::Arc;\n/// let my_arc = Arc::new(());\n///\n/// Arc::downgrade(&my_arc);\n/// ```\n///\n/// [`Weak<T>`][weak] does not auto-dereference to `T`, because the value may have\n/// already been destroyed.\n///\n/// [arc]: struct.Arc.html\n/// [weak]: struct.Weak.html\n/// [`Rc<T>`]: ../../std/rc/struct.Rc.html\n/// [clone]: ../../std/clone/trait.Clone.html#tymethod.clone\n/// [mutex]: ../../std/sync/struct.Mutex.html\n/// [rwlock]: ../../std/sync/struct.RwLock.html\n/// [atomic]: ../../std/sync/atomic/index.html\n/// [`Send`]: ../../std/marker/trait.Send.html\n/// [`Sync`]: ../../std/marker/trait.Sync.html\n/// [deref]: ../../std/ops/trait.Deref.html\n/// [downgrade]: struct.Arc.html#method.downgrade\n/// [upgrade]: struct.Weak.html#method.upgrade\n/// [`None`]: ../../std/option/enum.Option.html#variant.None\n/// [assoc]: ../../book/first-edition/method-syntax.html#associated-functions\n/// [`RefCell<T>`]: ../../std/cell/struct.RefCell.html\n/// [`std::sync`]: ../../std/sync/index.html\n/// [`Arc::clone(&from)`]: #method.clone\n///\n/// # Examples\n///\n/// Sharing some immutable data between threads:\n///\n// Note that we **do not** run these tests here. The windows builders get super\n// unhappy if a thread outlives the main thread and then exits at the same time\n// (something deadlocks) so we just avoid this entirely by not running these\n// tests.\n/// ```no_run\n/// use std::sync::Arc;\n/// use std::thread;\n///\n/// let five = Arc::new(5);\n///\n/// for _ in 0..10 {\n///     let five = Arc::clone(&five);\n///\n///     thread::spawn(move || {\n///         println!(\"{:?}\", five);\n///     });\n/// }\n/// ```\n///\n/// Sharing a mutable [`AtomicUsize`]:\n///\n/// [`AtomicUsize`]: ../../std/sync/atomic/struct.AtomicUsize.html\n///\n/// ```no_run\n/// use std::sync::Arc;\n/// use std::sync::atomic::{AtomicUsize, Ordering};\n/// use std::thread;\n///\n/// let val = Arc::new(AtomicUsize::new(5));\n///\n/// for _ in 0..10 {\n///     let val = Arc::clone(&val);\n///\n///     thread::spawn(move || {\n///         let v = val.fetch_add(1, Ordering::SeqCst);\n///         println!(\"{:?}\", v);\n///     });\n/// }\n/// ```\n///\n/// See the [`rc` documentation][rc_examples] for more examples of reference\n/// counting in general.\n///\n/// [rc_examples]: ../../std/rc/index.html#examples\n#[cfg_attr(not(test), lang = \"arc\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Arc<T: ?Sized> {\n    ptr: NonNull<ArcInner<T>>,\n    phantom: PhantomData<T>,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized + Sync + Send> Send for Arc<T> {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized + Sync + Send> Sync for Arc<T> {}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Arc<U>> for Arc<T> {}\n\n#[unstable(feature = \"dispatch_from_dyn\", issue = \"0\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Arc<U>> for Arc<T> {}\n\n/// `Weak` is a version of [`Arc`] that holds a non-owning reference to the\n/// managed value. The value is accessed by calling [`upgrade`] on the `Weak`\n/// pointer, which returns an [`Option`]`<`[`Arc`]`<T>>`.\n///\n/// Since a `Weak` reference does not count towards ownership, it will not\n/// prevent the inner value from being dropped, and `Weak` itself makes no\n/// guarantees about the value still being present and may return [`None`]\n/// when [`upgrade`]d.\n///\n/// A `Weak` pointer is useful for keeping a temporary reference to the value\n/// within [`Arc`] without extending its lifetime. It is also used to prevent\n/// circular references between [`Arc`] pointers, since mutual owning references\n/// would never allow either [`Arc`] to be dropped. For example, a tree could\n/// have strong [`Arc`] pointers from parent nodes to children, and `Weak`\n/// pointers from children back to their parents.\n///\n/// The typical way to obtain a `Weak` pointer is to call [`Arc::downgrade`].\n///\n/// [`Arc`]: struct.Arc.html\n/// [`Arc::downgrade`]: struct.Arc.html#method.downgrade\n/// [`upgrade`]: struct.Weak.html#method.upgrade\n/// [`Option`]: ../../std/option/enum.Option.html\n/// [`None`]: ../../std/option/enum.Option.html#variant.None\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\npub struct Weak<T: ?Sized> {\n    // This is a `NonNull` to allow optimizing the size of this type in enums,\n    // but it is not necessarily a valid pointer.\n    // `Weak::new` sets this to `usize::MAX` so that it doesn\u2019t need\n    // to allocate space on the heap.  That's not a value a real pointer\n    // will ever have because RcBox has alignment at least 2.\n    ptr: NonNull<ArcInner<T>>,\n}\n\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\nunsafe impl<T: ?Sized + Sync + Send> Send for Weak<T> {}\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\nunsafe impl<T: ?Sized + Sync + Send> Sync for Weak<T> {}\n\n#[unstable(feature = \"coerce_unsized\", issue = \"27732\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Weak<U>> for Weak<T> {}\n#[unstable(feature = \"dispatch_from_dyn\", issue = \"0\")]\nimpl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Weak<U>> for Weak<T> {}\n\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\nimpl<T: ?Sized + fmt::Debug> fmt::Debug for Weak<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"(Weak)\")\n    }\n}\n\nstruct ArcInner<T: ?Sized> {\n    strong: atomic::AtomicUsize,\n\n    // the value usize::MAX acts as a sentinel for temporarily \"locking\" the\n    // ability to upgrade weak pointers or downgrade strong ones; this is used\n    // to avoid races in `make_mut` and `get_mut`.\n    weak: atomic::AtomicUsize,\n\n    data: T,\n}\n\nunsafe impl<T: ?Sized + Sync + Send> Send for ArcInner<T> {}\nunsafe impl<T: ?Sized + Sync + Send> Sync for ArcInner<T> {}\n\nimpl<T> Arc<T> {\n    /// Constructs a new `Arc<T>`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(data: T) -> Arc<T> {\n        // Start the weak pointer count as 1 which is the weak pointer that's\n        // held by all the strong pointers (kinda), see std/rc.rs for more info\n        let x: Box<_> = box ArcInner {\n            strong: atomic::AtomicUsize::new(1),\n            weak: atomic::AtomicUsize::new(1),\n            data,\n        };\n        Arc { ptr: Box::into_raw_non_null(x), phantom: PhantomData }\n    }\n\n    #[unstable(feature = \"pin\", issue = \"49150\")]\n    pub fn pinned(data: T) -> Pin<Arc<T>> {\n        unsafe { Pin::new_unchecked(Arc::new(data)) }\n    }\n\n    /// Returns the contained value, if the `Arc` has exactly one strong reference.\n    ///\n    /// Otherwise, an [`Err`][result] is returned with the same `Arc` that was\n    /// passed in.\n    ///\n    /// This will succeed even if there are outstanding weak references.\n    ///\n    /// [result]: ../../std/result/enum.Result.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let x = Arc::new(3);\n    /// assert_eq!(Arc::try_unwrap(x), Ok(3));\n    ///\n    /// let x = Arc::new(4);\n    /// let _y = Arc::clone(&x);\n    /// assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);\n    /// ```\n    #[inline]\n    #[stable(feature = \"arc_unique\", since = \"1.4.0\")]\n    pub fn try_unwrap(this: Self) -> Result<T, Self> {\n        // See `drop` for why all these atomics are like this\n        if this.inner().strong.compare_exchange(1, 0, Release, Relaxed).is_err() {\n            return Err(this);\n        }\n\n        atomic::fence(Acquire);\n\n        unsafe {\n            let elem = ptr::read(&this.ptr.as_ref().data);\n\n            // Make a weak pointer to clean up the implicit strong-weak reference\n            let _weak = Weak { ptr: this.ptr };\n            mem::forget(this);\n\n            Ok(elem)\n        }\n    }\n}\n\nimpl<T: ?Sized> Arc<T> {\n    /// Consumes the `Arc`, returning the wrapped pointer.\n    ///\n    /// To avoid a memory leak the pointer must be converted back to an `Arc` using\n    /// [`Arc::from_raw`][from_raw].\n    ///\n    /// [from_raw]: struct.Arc.html#method.from_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let x = Arc::new(10);\n    /// let x_ptr = Arc::into_raw(x);\n    /// assert_eq!(unsafe { *x_ptr }, 10);\n    /// ```\n    #[stable(feature = \"rc_raw\", since = \"1.17.0\")]\n    pub fn into_raw(this: Self) -> *const T {\n        let ptr: *const T = &*this;\n        mem::forget(this);\n        ptr\n    }\n\n    /// Constructs an `Arc` from a raw pointer.\n    ///\n    /// The raw pointer must have been previously returned by a call to a\n    /// [`Arc::into_raw`][into_raw].\n    ///\n    /// This function is unsafe because improper use may lead to memory problems. For example, a\n    /// double-free may occur if the function is called twice on the same raw pointer.\n    ///\n    /// [into_raw]: struct.Arc.html#method.into_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let x = Arc::new(10);\n    /// let x_ptr = Arc::into_raw(x);\n    ///\n    /// unsafe {\n    ///     // Convert back to an `Arc` to prevent leak.\n    ///     let x = Arc::from_raw(x_ptr);\n    ///     assert_eq!(*x, 10);\n    ///\n    ///     // Further calls to `Arc::from_raw(x_ptr)` would be memory unsafe.\n    /// }\n    ///\n    /// // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!\n    /// ```\n    #[stable(feature = \"rc_raw\", since = \"1.17.0\")]\n    pub unsafe fn from_raw(ptr: *const T) -> Self {\n        // Align the unsized value to the end of the ArcInner.\n        // Because it is ?Sized, it will always be the last field in memory.\n        let align = align_of_val(&*ptr);\n        let layout = Layout::new::<ArcInner<()>>();\n        let offset = (layout.size() + layout.padding_needed_for(align)) as isize;\n\n        // Reverse the offset to find the original ArcInner.\n        let fake_ptr = ptr as *mut ArcInner<T>;\n        let arc_ptr = set_data_ptr(fake_ptr, (ptr as *mut u8).offset(-offset));\n\n        Arc {\n            ptr: NonNull::new_unchecked(arc_ptr),\n            phantom: PhantomData,\n        }\n    }\n\n    /// Creates a new [`Weak`][weak] pointer to this value.\n    ///\n    /// [weak]: struct.Weak.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// let weak_five = Arc::downgrade(&five);\n    /// ```\n    #[stable(feature = \"arc_weak\", since = \"1.4.0\")]\n    pub fn downgrade(this: &Self) -> Weak<T> {\n        // This Relaxed is OK because we're checking the value in the CAS\n        // below.\n        let mut cur = this.inner().weak.load(Relaxed);\n\n        loop {\n            // check if the weak counter is currently \"locked\"; if so, spin.\n            if cur == usize::MAX {\n                cur = this.inner().weak.load(Relaxed);\n                continue;\n            }\n\n            // NOTE: this code currently ignores the possibility of overflow\n            // into usize::MAX; in general both Rc and Arc need to be adjusted\n            // to deal with overflow.\n\n            // Unlike with Clone(), we need this to be an Acquire read to\n            // synchronize with the write coming from `is_unique`, so that the\n            // events prior to that write happen before this read.\n            match this.inner().weak.compare_exchange_weak(cur, cur + 1, Acquire, Relaxed) {\n                Ok(_) => {\n                    // Make sure we do not create a dangling Weak\n                    debug_assert!(!is_dangling(this.ptr));\n                    return Weak { ptr: this.ptr };\n                }\n                Err(old) => cur = old,\n            }\n        }\n    }\n\n    /// Gets the number of [`Weak`][weak] pointers to this value.\n    ///\n    /// [weak]: struct.Weak.html\n    ///\n    /// # Safety\n    ///\n    /// This method by itself is safe, but using it correctly requires extra care.\n    /// Another thread can change the weak count at any time,\n    /// including potentially between calling this method and acting on the result.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    /// let _weak_five = Arc::downgrade(&five);\n    ///\n    /// // This assertion is deterministic because we haven't shared\n    /// // the `Arc` or `Weak` between threads.\n    /// assert_eq!(1, Arc::weak_count(&five));\n    /// ```\n    #[inline]\n    #[stable(feature = \"arc_counts\", since = \"1.15.0\")]\n    pub fn weak_count(this: &Self) -> usize {\n        let cnt = this.inner().weak.load(SeqCst);\n        // If the weak count is currently locked, the value of the\n        // count was 0 just before taking the lock.\n        if cnt == usize::MAX { 0 } else { cnt - 1 }\n    }\n\n    /// Gets the number of strong (`Arc`) pointers to this value.\n    ///\n    /// # Safety\n    ///\n    /// This method by itself is safe, but using it correctly requires extra care.\n    /// Another thread can change the strong count at any time,\n    /// including potentially between calling this method and acting on the result.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    /// let _also_five = Arc::clone(&five);\n    ///\n    /// // This assertion is deterministic because we haven't shared\n    /// // the `Arc` between threads.\n    /// assert_eq!(2, Arc::strong_count(&five));\n    /// ```\n    #[inline]\n    #[stable(feature = \"arc_counts\", since = \"1.15.0\")]\n    pub fn strong_count(this: &Self) -> usize {\n        this.inner().strong.load(SeqCst)\n    }\n\n    #[inline]\n    fn inner(&self) -> &ArcInner<T> {\n        // This unsafety is ok because while this arc is alive we're guaranteed\n        // that the inner pointer is valid. Furthermore, we know that the\n        // `ArcInner` structure itself is `Sync` because the inner data is\n        // `Sync` as well, so we're ok loaning out an immutable pointer to these\n        // contents.\n        unsafe { self.ptr.as_ref() }\n    }\n\n    // Non-inlined part of `drop`.\n    #[inline(never)]\n    unsafe fn drop_slow(&mut self) {\n        // Destroy the data at this time, even though we may not free the box\n        // allocation itself (there may still be weak pointers lying around).\n        ptr::drop_in_place(&mut self.ptr.as_mut().data);\n\n        if self.inner().weak.fetch_sub(1, Release) == 1 {\n            atomic::fence(Acquire);\n            Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref()))\n        }\n    }\n\n    #[inline]\n    #[stable(feature = \"ptr_eq\", since = \"1.17.0\")]\n    /// Returns true if the two `Arc`s point to the same value (not\n    /// just values that compare as equal).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    /// let same_five = Arc::clone(&five);\n    /// let other_five = Arc::new(5);\n    ///\n    /// assert!(Arc::ptr_eq(&five, &same_five));\n    /// assert!(!Arc::ptr_eq(&five, &other_five));\n    /// ```\n    pub fn ptr_eq(this: &Self, other: &Self) -> bool {\n        this.ptr.as_ptr() == other.ptr.as_ptr()\n    }\n}\n\nimpl<T: ?Sized> Arc<T> {\n    // Allocates an `ArcInner<T>` with sufficient space for an unsized value\n    unsafe fn allocate_for_ptr(ptr: *const T) -> *mut ArcInner<T> {\n        // Calculate layout using the given value.\n        // Previously, layout was calculated on the expression\n        // `&*(ptr as *const ArcInner<T>)`, but this created a misaligned\n        // reference (see #54908).\n        let (layout, _) = Layout::new::<ArcInner<()>>()\n            .extend(Layout::for_value(&*ptr)).unwrap();\n\n        let mem = Global.alloc(layout)\n            .unwrap_or_else(|_| handle_alloc_error(layout));\n\n        // Initialize the ArcInner\n        let inner = set_data_ptr(ptr as *mut T, mem.as_ptr() as *mut u8) as *mut ArcInner<T>;\n\n        ptr::write(&mut (*inner).strong, atomic::AtomicUsize::new(1));\n        ptr::write(&mut (*inner).weak, atomic::AtomicUsize::new(1));\n\n        inner\n    }\n\n    fn from_box(v: Box<T>) -> Arc<T> {\n        unsafe {\n            let box_unique = Box::into_unique(v);\n            let bptr = box_unique.as_ptr();\n\n            let value_size = size_of_val(&*bptr);\n            let ptr = Self::allocate_for_ptr(bptr);\n\n            // Copy value as bytes\n            ptr::copy_nonoverlapping(\n                bptr as *const T as *const u8,\n                &mut (*ptr).data as *mut _ as *mut u8,\n                value_size);\n\n            // Free the allocation without dropping its contents\n            box_free(box_unique);\n\n            Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }\n        }\n    }\n}\n\n// Sets the data pointer of a `?Sized` raw pointer.\n//\n// For a slice/trait object, this sets the `data` field and leaves the rest\n// unchanged. For a sized raw pointer, this simply sets the pointer.\nunsafe fn set_data_ptr<T: ?Sized, U>(mut ptr: *mut T, data: *mut U) -> *mut T {\n    ptr::write(&mut ptr as *mut _ as *mut *mut u8, data as *mut u8);\n    ptr\n}\n\nimpl<T> Arc<[T]> {\n    // Copy elements from slice into newly allocated Arc<[T]>\n    //\n    // Unsafe because the caller must either take ownership or bind `T: Copy`\n    unsafe fn copy_from_slice(v: &[T]) -> Arc<[T]> {\n        let v_ptr = v as *const [T];\n        let ptr = Self::allocate_for_ptr(v_ptr);\n\n        ptr::copy_nonoverlapping(\n            v.as_ptr(),\n            &mut (*ptr).data as *mut [T] as *mut T,\n            v.len());\n\n        Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }\n    }\n}\n\n// Specialization trait used for From<&[T]>\ntrait ArcFromSlice<T> {\n    fn from_slice(slice: &[T]) -> Self;\n}\n\nimpl<T: Clone> ArcFromSlice<T> for Arc<[T]> {\n    #[inline]\n    default fn from_slice(v: &[T]) -> Self {\n        // Panic guard while cloning T elements.\n        // In the event of a panic, elements that have been written\n        // into the new ArcInner will be dropped, then the memory freed.\n        struct Guard<T> {\n            mem: NonNull<u8>,\n            elems: *mut T,\n            layout: Layout,\n            n_elems: usize,\n        }\n\n        impl<T> Drop for Guard<T> {\n            fn drop(&mut self) {\n                use core::slice::from_raw_parts_mut;\n\n                unsafe {\n                    let slice = from_raw_parts_mut(self.elems, self.n_elems);\n                    ptr::drop_in_place(slice);\n\n                    Global.dealloc(self.mem.cast(), self.layout.clone());\n                }\n            }\n        }\n\n        unsafe {\n            let v_ptr = v as *const [T];\n            let ptr = Self::allocate_for_ptr(v_ptr);\n\n            let mem = ptr as *mut _ as *mut u8;\n            let layout = Layout::for_value(&*ptr);\n\n            // Pointer to first element\n            let elems = &mut (*ptr).data as *mut [T] as *mut T;\n\n            let mut guard = Guard{\n                mem: NonNull::new_unchecked(mem),\n                elems: elems,\n                layout: layout,\n                n_elems: 0,\n            };\n\n            for (i, item) in v.iter().enumerate() {\n                ptr::write(elems.add(i), item.clone());\n                guard.n_elems += 1;\n            }\n\n            // All clear. Forget the guard so it doesn't free the new ArcInner.\n            mem::forget(guard);\n\n            Arc { ptr: NonNull::new_unchecked(ptr), phantom: PhantomData }\n        }\n    }\n}\n\nimpl<T: Copy> ArcFromSlice<T> for Arc<[T]> {\n    #[inline]\n    fn from_slice(v: &[T]) -> Self {\n        unsafe { Arc::copy_from_slice(v) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Clone for Arc<T> {\n    /// Makes a clone of the `Arc` pointer.\n    ///\n    /// This creates another pointer to the same inner value, increasing the\n    /// strong reference count.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// let _ = Arc::clone(&five);\n    /// ```\n    #[inline]\n    fn clone(&self) -> Arc<T> {\n        // Using a relaxed ordering is alright here, as knowledge of the\n        // original reference prevents other threads from erroneously deleting\n        // the object.\n        //\n        // As explained in the [Boost documentation][1], Increasing the\n        // reference counter can always be done with memory_order_relaxed: New\n        // references to an object can only be formed from an existing\n        // reference, and passing an existing reference from one thread to\n        // another must already provide any required synchronization.\n        //\n        // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)\n        let old_size = self.inner().strong.fetch_add(1, Relaxed);\n\n        // However we need to guard against massive refcounts in case someone\n        // is `mem::forget`ing Arcs. If we don't do this the count can overflow\n        // and users will use-after free. We racily saturate to `isize::MAX` on\n        // the assumption that there aren't ~2 billion threads incrementing\n        // the reference count at once. This branch will never be taken in\n        // any realistic program.\n        //\n        // We abort because such a program is incredibly degenerate, and we\n        // don't care to support it.\n        if old_size > MAX_REFCOUNT {\n            unsafe {\n                abort();\n            }\n        }\n\n        Arc { ptr: self.ptr, phantom: PhantomData }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> Deref for Arc<T> {\n    type Target = T;\n\n    #[inline]\n    fn deref(&self) -> &T {\n        &self.inner().data\n    }\n}\n\nimpl<T: Clone> Arc<T> {\n    /// Makes a mutable reference into the given `Arc`.\n    ///\n    /// If there are other `Arc` or [`Weak`][weak] pointers to the same value,\n    /// then `make_mut` will invoke [`clone`][clone] on the inner value to\n    /// ensure unique ownership. This is also referred to as clone-on-write.\n    ///\n    /// See also [`get_mut`][get_mut], which will fail rather than cloning.\n    ///\n    /// [weak]: struct.Weak.html\n    /// [clone]: ../../std/clone/trait.Clone.html#tymethod.clone\n    /// [get_mut]: struct.Arc.html#method.get_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let mut data = Arc::new(5);\n    ///\n    /// *Arc::make_mut(&mut data) += 1;         // Won't clone anything\n    /// let mut other_data = Arc::clone(&data); // Won't clone inner data\n    /// *Arc::make_mut(&mut data) += 1;         // Clones inner data\n    /// *Arc::make_mut(&mut data) += 1;         // Won't clone anything\n    /// *Arc::make_mut(&mut other_data) *= 2;   // Won't clone anything\n    ///\n    /// // Now `data` and `other_data` point to different values.\n    /// assert_eq!(*data, 8);\n    /// assert_eq!(*other_data, 12);\n    /// ```\n    #[inline]\n    #[stable(feature = \"arc_unique\", since = \"1.4.0\")]\n    pub fn make_mut(this: &mut Self) -> &mut T {\n        // Note that we hold both a strong reference and a weak reference.\n        // Thus, releasing our strong reference only will not, by itself, cause\n        // the memory to be deallocated.\n        //\n        // Use Acquire to ensure that we see any writes to `weak` that happen\n        // before release writes (i.e., decrements) to `strong`. Since we hold a\n        // weak count, there's no chance the ArcInner itself could be\n        // deallocated.\n        if this.inner().strong.compare_exchange(1, 0, Acquire, Relaxed).is_err() {\n            // Another strong pointer exists; clone\n            *this = Arc::new((**this).clone());\n        } else if this.inner().weak.load(Relaxed) != 1 {\n            // Relaxed suffices in the above because this is fundamentally an\n            // optimization: we are always racing with weak pointers being\n            // dropped. Worst case, we end up allocated a new Arc unnecessarily.\n\n            // We removed the last strong ref, but there are additional weak\n            // refs remaining. We'll move the contents to a new Arc, and\n            // invalidate the other weak refs.\n\n            // Note that it is not possible for the read of `weak` to yield\n            // usize::MAX (i.e., locked), since the weak count can only be\n            // locked by a thread with a strong reference.\n\n            // Materialize our own implicit weak pointer, so that it can clean\n            // up the ArcInner as needed.\n            let weak = Weak { ptr: this.ptr };\n\n            // mark the data itself as already deallocated\n            unsafe {\n                // there is no data race in the implicit write caused by `read`\n                // here (due to zeroing) because data is no longer accessed by\n                // other threads (due to there being no more strong refs at this\n                // point).\n                let mut swap = Arc::new(ptr::read(&weak.ptr.as_ref().data));\n                mem::swap(this, &mut swap);\n                mem::forget(swap);\n            }\n        } else {\n            // We were the sole reference of either kind; bump back up the\n            // strong ref count.\n            this.inner().strong.store(1, Release);\n        }\n\n        // As with `get_mut()`, the unsafety is ok because our reference was\n        // either unique to begin with, or became one upon cloning the contents.\n        unsafe {\n            &mut this.ptr.as_mut().data\n        }\n    }\n}\n\nimpl<T: ?Sized> Arc<T> {\n    /// Returns a mutable reference to the inner value, if there are\n    /// no other `Arc` or [`Weak`][weak] pointers to the same value.\n    ///\n    /// Returns [`None`][option] otherwise, because it is not safe to\n    /// mutate a shared value.\n    ///\n    /// See also [`make_mut`][make_mut], which will [`clone`][clone]\n    /// the inner value when it's shared.\n    ///\n    /// [weak]: struct.Weak.html\n    /// [option]: ../../std/option/enum.Option.html\n    /// [make_mut]: struct.Arc.html#method.make_mut\n    /// [clone]: ../../std/clone/trait.Clone.html#tymethod.clone\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let mut x = Arc::new(3);\n    /// *Arc::get_mut(&mut x).unwrap() = 4;\n    /// assert_eq!(*x, 4);\n    ///\n    /// let _y = Arc::clone(&x);\n    /// assert!(Arc::get_mut(&mut x).is_none());\n    /// ```\n    #[inline]\n    #[stable(feature = \"arc_unique\", since = \"1.4.0\")]\n    pub fn get_mut(this: &mut Self) -> Option<&mut T> {\n        if this.is_unique() {\n            // This unsafety is ok because we're guaranteed that the pointer\n            // returned is the *only* pointer that will ever be returned to T. Our\n            // reference count is guaranteed to be 1 at this point, and we required\n            // the Arc itself to be `mut`, so we're returning the only possible\n            // reference to the inner data.\n            unsafe {\n                Some(&mut this.ptr.as_mut().data)\n            }\n        } else {\n            None\n        }\n    }\n\n    /// Determine whether this is the unique reference (including weak refs) to\n    /// the underlying data.\n    ///\n    /// Note that this requires locking the weak ref count.\n    fn is_unique(&mut self) -> bool {\n        // lock the weak pointer count if we appear to be the sole weak pointer\n        // holder.\n        //\n        // The acquire label here ensures a happens-before relationship with any\n        // writes to `strong` (in particular in `Weak::upgrade`) prior to decrements\n        // of the `weak` count (via `Weak::drop`, which uses release).  If the upgraded\n        // weak ref was never dropped, the CAS here will fail so we do not care to synchronize.\n        if self.inner().weak.compare_exchange(1, usize::MAX, Acquire, Relaxed).is_ok() {\n            // This needs to be an `Acquire` to synchronize with the decrement of the `strong`\n            // counter in `drop` -- the only access that happens when any but the last reference\n            // is being dropped.\n            let unique = self.inner().strong.load(Acquire) == 1;\n\n            // The release write here synchronizes with a read in `downgrade`,\n            // effectively preventing the above read of `strong` from happening\n            // after the write.\n            self.inner().weak.store(1, Release); // release the lock\n            unique\n        } else {\n            false\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<#[may_dangle] T: ?Sized> Drop for Arc<T> {\n    /// Drops the `Arc`.\n    ///\n    /// This will decrement the strong reference count. If the strong reference\n    /// count reaches zero then the only other references (if any) are\n    /// [`Weak`], so we `drop` the inner value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// struct Foo;\n    ///\n    /// impl Drop for Foo {\n    ///     fn drop(&mut self) {\n    ///         println!(\"dropped!\");\n    ///     }\n    /// }\n    ///\n    /// let foo  = Arc::new(Foo);\n    /// let foo2 = Arc::clone(&foo);\n    ///\n    /// drop(foo);    // Doesn't print anything\n    /// drop(foo2);   // Prints \"dropped!\"\n    /// ```\n    #[inline]\n    fn drop(&mut self) {\n        // Because `fetch_sub` is already atomic, we do not need to synchronize\n        // with other threads unless we are going to delete the object. This\n        // same logic applies to the below `fetch_sub` to the `weak` count.\n        if self.inner().strong.fetch_sub(1, Release) != 1 {\n            return;\n        }\n\n        // This fence is needed to prevent reordering of use of the data and\n        // deletion of the data.  Because it is marked `Release`, the decreasing\n        // of the reference count synchronizes with this `Acquire` fence. This\n        // means that use of the data happens before decreasing the reference\n        // count, which happens before this fence, which happens before the\n        // deletion of the data.\n        //\n        // As explained in the [Boost documentation][1],\n        //\n        // > It is important to enforce any possible access to the object in one\n        // > thread (through an existing reference) to *happen before* deleting\n        // > the object in a different thread. This is achieved by a \"release\"\n        // > operation after dropping a reference (any access to the object\n        // > through this reference must obviously happened before), and an\n        // > \"acquire\" operation before deleting the object.\n        //\n        // In particular, while the contents of an Arc are usually immutable, it's\n        // possible to have interior writes to something like a Mutex<T>. Since a\n        // Mutex is not acquired when it is deleted, we can't rely on its\n        // synchronization logic to make writes in thread A visible to a destructor\n        // running in thread B.\n        //\n        // Also note that the Acquire fence here could probably be replaced with an\n        // Acquire load, which could improve performance in highly-contended\n        // situations. See [2].\n        //\n        // [1]: (www.boost.org/doc/libs/1_55_0/doc/html/atomic/usage_examples.html)\n        // [2]: (https://github.com/rust-lang/rust/pull/41714)\n        atomic::fence(Acquire);\n\n        unsafe {\n            self.drop_slow();\n        }\n    }\n}\n\nimpl Arc<dyn Any + Send + Sync> {\n    #[inline]\n    #[stable(feature = \"rc_downcast\", since = \"1.29.0\")]\n    /// Attempt to downcast the `Arc<dyn Any + Send + Sync>` to a concrete type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::any::Any;\n    /// use std::sync::Arc;\n    ///\n    /// fn print_if_string(value: Arc<dyn Any + Send + Sync>) {\n    ///     if let Ok(string) = value.downcast::<String>() {\n    ///         println!(\"String ({}): {}\", string.len(), string);\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     let my_string = \"Hello World\".to_string();\n    ///     print_if_string(Arc::new(my_string));\n    ///     print_if_string(Arc::new(0i8));\n    /// }\n    /// ```\n    pub fn downcast<T>(self) -> Result<Arc<T>, Self>\n    where\n        T: Any + Send + Sync + 'static,\n    {\n        if (*self).is::<T>() {\n            let ptr = self.ptr.cast::<ArcInner<T>>();\n            mem::forget(self);\n            Ok(Arc { ptr, phantom: PhantomData })\n        } else {\n            Err(self)\n        }\n    }\n}\n\nimpl<T> Weak<T> {\n    /// Constructs a new `Weak<T>`, without allocating any memory.\n    /// Calling [`upgrade`] on the return value always gives [`None`].\n    ///\n    /// [`upgrade`]: struct.Weak.html#method.upgrade\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Weak;\n    ///\n    /// let empty: Weak<i64> = Weak::new();\n    /// assert!(empty.upgrade().is_none());\n    /// ```\n    #[stable(feature = \"downgraded_weak\", since = \"1.10.0\")]\n    pub fn new() -> Weak<T> {\n        Weak {\n            ptr: NonNull::new(usize::MAX as *mut ArcInner<T>).expect(\"MAX is not 0\"),\n        }\n    }\n}\n\nimpl<T: ?Sized> Weak<T> {\n    /// Attempts to upgrade the `Weak` pointer to an [`Arc`], extending\n    /// the lifetime of the value if successful.\n    ///\n    /// Returns [`None`] if the value has since been dropped.\n    ///\n    /// [`Arc`]: struct.Arc.html\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// let weak_five = Arc::downgrade(&five);\n    ///\n    /// let strong_five: Option<Arc<_>> = weak_five.upgrade();\n    /// assert!(strong_five.is_some());\n    ///\n    /// // Destroy all strong pointers.\n    /// drop(strong_five);\n    /// drop(five);\n    ///\n    /// assert!(weak_five.upgrade().is_none());\n    /// ```\n    #[stable(feature = \"arc_weak\", since = \"1.4.0\")]\n    pub fn upgrade(&self) -> Option<Arc<T>> {\n        // We use a CAS loop to increment the strong count instead of a\n        // fetch_add because once the count hits 0 it must never be above 0.\n        let inner = self.inner()?;\n\n        // Relaxed load because any write of 0 that we can observe\n        // leaves the field in a permanently zero state (so a\n        // \"stale\" read of 0 is fine), and any other value is\n        // confirmed via the CAS below.\n        let mut n = inner.strong.load(Relaxed);\n\n        loop {\n            if n == 0 {\n                return None;\n            }\n\n            // See comments in `Arc::clone` for why we do this (for `mem::forget`).\n            if n > MAX_REFCOUNT {\n                unsafe {\n                    abort();\n                }\n            }\n\n            // Relaxed is valid for the same reason it is on Arc's Clone impl\n            match inner.strong.compare_exchange_weak(n, n + 1, Relaxed, Relaxed) {\n                Ok(_) => return Some(Arc {\n                    // null checked above\n                    ptr: self.ptr,\n                    phantom: PhantomData,\n                }),\n                Err(old) => n = old,\n            }\n        }\n    }\n\n    /// Return `None` when the pointer is dangling and there is no allocated `ArcInner`,\n    /// i.e. this `Weak` was created by `Weak::new`\n    #[inline]\n    fn inner(&self) -> Option<&ArcInner<T>> {\n        if is_dangling(self.ptr) {\n            None\n        } else {\n            Some(unsafe { self.ptr.as_ref() })\n        }\n    }\n}\n\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\nimpl<T: ?Sized> Clone for Weak<T> {\n    /// Makes a clone of the `Weak` pointer that points to the same value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Weak};\n    ///\n    /// let weak_five = Arc::downgrade(&Arc::new(5));\n    ///\n    /// let _ = Weak::clone(&weak_five);\n    /// ```\n    #[inline]\n    fn clone(&self) -> Weak<T> {\n        let inner = if let Some(inner) = self.inner() {\n            inner\n        } else {\n            return Weak { ptr: self.ptr };\n        };\n        // See comments in Arc::clone() for why this is relaxed.  This can use a\n        // fetch_add (ignoring the lock) because the weak count is only locked\n        // where are *no other* weak pointers in existence. (So we can't be\n        // running this code in that case).\n        let old_size = inner.weak.fetch_add(1, Relaxed);\n\n        // See comments in Arc::clone() for why we do this (for mem::forget).\n        if old_size > MAX_REFCOUNT {\n            unsafe {\n                abort();\n            }\n        }\n\n        return Weak { ptr: self.ptr };\n    }\n}\n\n#[stable(feature = \"downgraded_weak\", since = \"1.10.0\")]\nimpl<T> Default for Weak<T> {\n    /// Constructs a new `Weak<T>`, without allocating memory.\n    /// Calling [`upgrade`][Weak::upgrade] on the return value always\n    /// gives [`None`].\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Weak;\n    ///\n    /// let empty: Weak<i64> = Default::default();\n    /// assert!(empty.upgrade().is_none());\n    /// ```\n    fn default() -> Weak<T> {\n        Weak::new()\n    }\n}\n\n#[stable(feature = \"arc_weak\", since = \"1.4.0\")]\nimpl<T: ?Sized> Drop for Weak<T> {\n    /// Drops the `Weak` pointer.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Weak};\n    ///\n    /// struct Foo;\n    ///\n    /// impl Drop for Foo {\n    ///     fn drop(&mut self) {\n    ///         println!(\"dropped!\");\n    ///     }\n    /// }\n    ///\n    /// let foo = Arc::new(Foo);\n    /// let weak_foo = Arc::downgrade(&foo);\n    /// let other_weak_foo = Weak::clone(&weak_foo);\n    ///\n    /// drop(weak_foo);   // Doesn't print anything\n    /// drop(foo);        // Prints \"dropped!\"\n    ///\n    /// assert!(other_weak_foo.upgrade().is_none());\n    /// ```\n    fn drop(&mut self) {\n        // If we find out that we were the last weak pointer, then its time to\n        // deallocate the data entirely. See the discussion in Arc::drop() about\n        // the memory orderings\n        //\n        // It's not necessary to check for the locked state here, because the\n        // weak count can only be locked if there was precisely one weak ref,\n        // meaning that drop could only subsequently run ON that remaining weak\n        // ref, which can only happen after the lock is released.\n        let inner = if let Some(inner) = self.inner() {\n            inner\n        } else {\n            return\n        };\n\n        if inner.weak.fetch_sub(1, Release) == 1 {\n            atomic::fence(Acquire);\n            unsafe {\n                Global.dealloc(self.ptr.cast(), Layout::for_value(self.ptr.as_ref()))\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + PartialEq> PartialEq for Arc<T> {\n    /// Equality for two `Arc`s.\n    ///\n    /// Two `Arc`s are equal if their inner values are equal.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five == Arc::new(5));\n    /// ```\n    fn eq(&self, other: &Arc<T>) -> bool {\n        *(*self) == *(*other)\n    }\n\n    /// Inequality for two `Arc`s.\n    ///\n    /// Two `Arc`s are unequal if their inner values are unequal.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five != Arc::new(6));\n    /// ```\n    fn ne(&self, other: &Arc<T>) -> bool {\n        *(*self) != *(*other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + PartialOrd> PartialOrd for Arc<T> {\n    /// Partial comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `partial_cmp()` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    /// use std::cmp::Ordering;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));\n    /// ```\n    fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering> {\n        (**self).partial_cmp(&**other)\n    }\n\n    /// Less-than comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `<` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five < Arc::new(6));\n    /// ```\n    fn lt(&self, other: &Arc<T>) -> bool {\n        *(*self) < *(*other)\n    }\n\n    /// 'Less than or equal to' comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `<=` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five <= Arc::new(5));\n    /// ```\n    fn le(&self, other: &Arc<T>) -> bool {\n        *(*self) <= *(*other)\n    }\n\n    /// Greater-than comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `>` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five > Arc::new(4));\n    /// ```\n    fn gt(&self, other: &Arc<T>) -> bool {\n        *(*self) > *(*other)\n    }\n\n    /// 'Greater than or equal to' comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `>=` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert!(five >= Arc::new(5));\n    /// ```\n    fn ge(&self, other: &Arc<T>) -> bool {\n        *(*self) >= *(*other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Ord> Ord for Arc<T> {\n    /// Comparison for two `Arc`s.\n    ///\n    /// The two are compared by calling `cmp()` on their inner values.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    /// use std::cmp::Ordering;\n    ///\n    /// let five = Arc::new(5);\n    ///\n    /// assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));\n    /// ```\n    fn cmp(&self, other: &Arc<T>) -> Ordering {\n        (**self).cmp(&**other)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Eq> Eq for Arc<T> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + fmt::Display> fmt::Display for Arc<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + fmt::Debug> fmt::Debug for Arc<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> fmt::Pointer for Arc<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Pointer::fmt(&(&**self as *const T), f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Default> Default for Arc<T> {\n    /// Creates a new `Arc<T>`, with the `Default` value for `T`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Arc;\n    ///\n    /// let x: Arc<i32> = Default::default();\n    /// assert_eq!(*x, 0);\n    /// ```\n    fn default() -> Arc<T> {\n        Arc::new(Default::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + Hash> Hash for Arc<T> {\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        (**self).hash(state)\n    }\n}\n\n#[stable(feature = \"from_for_ptrs\", since = \"1.6.0\")]\nimpl<T> From<T> for Arc<T> {\n    fn from(t: T) -> Self {\n        Arc::new(t)\n    }\n}\n\n#[stable(feature = \"shared_from_slice\", since = \"1.21.0\")]\nimpl<'a, T: Clone> From<&'a [T]> for Arc<[T]> {\n    #[inline]\n    fn from(v: &[T]) -> Arc<[T]> {\n        <Self as ArcFromSlice<T>>::from_slice(v)\n    }\n}\n\n#[stable(feature = \"shared_from_slice\", since = \"1.21.0\")]\nimpl<'a> From<&'a str> for Arc<str> {\n    #[inline]\n    fn from(v: &str) -> Arc<str> {\n        let arc = Arc::<[u8]>::from(v.as_bytes());\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const str) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice\", since = \"1.21.0\")]\nimpl From<String> for Arc<str> {\n    #[inline]\n    fn from(v: String) -> Arc<str> {\n        Arc::from(&v[..])\n    }\n}\n\n#[stable(feature = \"shared_from_slice\", since = \"1.21.0\")]\nimpl<T: ?Sized> From<Box<T>> for Arc<T> {\n    #[inline]\n    fn from(v: Box<T>) -> Arc<T> {\n        Arc::from_box(v)\n    }\n}\n\n#[stable(feature = \"shared_from_slice\", since = \"1.21.0\")]\nimpl<T> From<Vec<T>> for Arc<[T]> {\n    #[inline]\n    fn from(mut v: Vec<T>) -> Arc<[T]> {\n        unsafe {\n            let arc = Arc::copy_from_slice(&v);\n\n            // Allow the Vec to free its memory, but not destroy its contents\n            v.set_len(0);\n\n            arc\n        }\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use std::boxed::Box;\n    use std::clone::Clone;\n    use std::sync::mpsc::channel;\n    use std::mem::drop;\n    use std::ops::Drop;\n    use std::option::Option;\n    use std::option::Option::{None, Some};\n    use std::sync::atomic;\n    use std::sync::atomic::Ordering::{Acquire, SeqCst};\n    use std::thread;\n    use std::sync::Mutex;\n    use std::convert::From;\n\n    use super::{Arc, Weak};\n    use vec::Vec;\n\n    struct Canary(*mut atomic::AtomicUsize);\n\n    impl Drop for Canary {\n        fn drop(&mut self) {\n            unsafe {\n                match *self {\n                    Canary(c) => {\n                        (*c).fetch_add(1, SeqCst);\n                    }\n                }\n            }\n        }\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn manually_share_arc() {\n        let v = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];\n        let arc_v = Arc::new(v);\n\n        let (tx, rx) = channel();\n\n        let _t = thread::spawn(move || {\n            let arc_v: Arc<Vec<i32>> = rx.recv().unwrap();\n            assert_eq!((*arc_v)[3], 4);\n        });\n\n        tx.send(arc_v.clone()).unwrap();\n\n        assert_eq!((*arc_v)[2], 3);\n        assert_eq!((*arc_v)[4], 5);\n    }\n\n    #[test]\n    fn test_arc_get_mut() {\n        let mut x = Arc::new(3);\n        *Arc::get_mut(&mut x).unwrap() = 4;\n        assert_eq!(*x, 4);\n        let y = x.clone();\n        assert!(Arc::get_mut(&mut x).is_none());\n        drop(y);\n        assert!(Arc::get_mut(&mut x).is_some());\n        let _w = Arc::downgrade(&x);\n        assert!(Arc::get_mut(&mut x).is_none());\n    }\n\n    #[test]\n    fn try_unwrap() {\n        let x = Arc::new(3);\n        assert_eq!(Arc::try_unwrap(x), Ok(3));\n        let x = Arc::new(4);\n        let _y = x.clone();\n        assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4)));\n        let x = Arc::new(5);\n        let _w = Arc::downgrade(&x);\n        assert_eq!(Arc::try_unwrap(x), Ok(5));\n    }\n\n    #[test]\n    fn into_from_raw() {\n        let x = Arc::new(box \"hello\");\n        let y = x.clone();\n\n        let x_ptr = Arc::into_raw(x);\n        drop(y);\n        unsafe {\n            assert_eq!(**x_ptr, \"hello\");\n\n            let x = Arc::from_raw(x_ptr);\n            assert_eq!(**x, \"hello\");\n\n            assert_eq!(Arc::try_unwrap(x).map(|x| *x), Ok(\"hello\"));\n        }\n    }\n\n    #[test]\n    fn test_into_from_raw_unsized() {\n        use std::fmt::Display;\n        use std::string::ToString;\n\n        let arc: Arc<str> = Arc::from(\"foo\");\n\n        let ptr = Arc::into_raw(arc.clone());\n        let arc2 = unsafe { Arc::from_raw(ptr) };\n\n        assert_eq!(unsafe { &*ptr }, \"foo\");\n        assert_eq!(arc, arc2);\n\n        let arc: Arc<dyn Display> = Arc::new(123);\n\n        let ptr = Arc::into_raw(arc.clone());\n        let arc2 = unsafe { Arc::from_raw(ptr) };\n\n        assert_eq!(unsafe { &*ptr }.to_string(), \"123\");\n        assert_eq!(arc2.to_string(), \"123\");\n    }\n\n    #[test]\n    fn test_cowarc_clone_make_mut() {\n        let mut cow0 = Arc::new(75);\n        let mut cow1 = cow0.clone();\n        let mut cow2 = cow1.clone();\n\n        assert!(75 == *Arc::make_mut(&mut cow0));\n        assert!(75 == *Arc::make_mut(&mut cow1));\n        assert!(75 == *Arc::make_mut(&mut cow2));\n\n        *Arc::make_mut(&mut cow0) += 1;\n        *Arc::make_mut(&mut cow1) += 2;\n        *Arc::make_mut(&mut cow2) += 3;\n\n        assert!(76 == *cow0);\n        assert!(77 == *cow1);\n        assert!(78 == *cow2);\n\n        // none should point to the same backing memory\n        assert!(*cow0 != *cow1);\n        assert!(*cow0 != *cow2);\n        assert!(*cow1 != *cow2);\n    }\n\n    #[test]\n    fn test_cowarc_clone_unique2() {\n        let mut cow0 = Arc::new(75);\n        let cow1 = cow0.clone();\n        let cow2 = cow1.clone();\n\n        assert!(75 == *cow0);\n        assert!(75 == *cow1);\n        assert!(75 == *cow2);\n\n        *Arc::make_mut(&mut cow0) += 1;\n        assert!(76 == *cow0);\n        assert!(75 == *cow1);\n        assert!(75 == *cow2);\n\n        // cow1 and cow2 should share the same contents\n        // cow0 should have a unique reference\n        assert!(*cow0 != *cow1);\n        assert!(*cow0 != *cow2);\n        assert!(*cow1 == *cow2);\n    }\n\n    #[test]\n    fn test_cowarc_clone_weak() {\n        let mut cow0 = Arc::new(75);\n        let cow1_weak = Arc::downgrade(&cow0);\n\n        assert!(75 == *cow0);\n        assert!(75 == *cow1_weak.upgrade().unwrap());\n\n        *Arc::make_mut(&mut cow0) += 1;\n\n        assert!(76 == *cow0);\n        assert!(cow1_weak.upgrade().is_none());\n    }\n\n    #[test]\n    fn test_live() {\n        let x = Arc::new(5);\n        let y = Arc::downgrade(&x);\n        assert!(y.upgrade().is_some());\n    }\n\n    #[test]\n    fn test_dead() {\n        let x = Arc::new(5);\n        let y = Arc::downgrade(&x);\n        drop(x);\n        assert!(y.upgrade().is_none());\n    }\n\n    #[test]\n    fn weak_self_cyclic() {\n        struct Cycle {\n            x: Mutex<Option<Weak<Cycle>>>,\n        }\n\n        let a = Arc::new(Cycle { x: Mutex::new(None) });\n        let b = Arc::downgrade(&a.clone());\n        *a.x.lock().unwrap() = Some(b);\n\n        // hopefully we don't double-free (or leak)...\n    }\n\n    #[test]\n    fn drop_arc() {\n        let mut canary = atomic::AtomicUsize::new(0);\n        let x = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));\n        drop(x);\n        assert!(canary.load(Acquire) == 1);\n    }\n\n    #[test]\n    fn drop_arc_weak() {\n        let mut canary = atomic::AtomicUsize::new(0);\n        let arc = Arc::new(Canary(&mut canary as *mut atomic::AtomicUsize));\n        let arc_weak = Arc::downgrade(&arc);\n        assert!(canary.load(Acquire) == 0);\n        drop(arc);\n        assert!(canary.load(Acquire) == 1);\n        drop(arc_weak);\n    }\n\n    #[test]\n    fn test_strong_count() {\n        let a = Arc::new(0);\n        assert!(Arc::strong_count(&a) == 1);\n        let w = Arc::downgrade(&a);\n        assert!(Arc::strong_count(&a) == 1);\n        let b = w.upgrade().expect(\"\");\n        assert!(Arc::strong_count(&b) == 2);\n        assert!(Arc::strong_count(&a) == 2);\n        drop(w);\n        drop(a);\n        assert!(Arc::strong_count(&b) == 1);\n        let c = b.clone();\n        assert!(Arc::strong_count(&b) == 2);\n        assert!(Arc::strong_count(&c) == 2);\n    }\n\n    #[test]\n    fn test_weak_count() {\n        let a = Arc::new(0);\n        assert!(Arc::strong_count(&a) == 1);\n        assert!(Arc::weak_count(&a) == 0);\n        let w = Arc::downgrade(&a);\n        assert!(Arc::strong_count(&a) == 1);\n        assert!(Arc::weak_count(&a) == 1);\n        let x = w.clone();\n        assert!(Arc::weak_count(&a) == 2);\n        drop(w);\n        drop(x);\n        assert!(Arc::strong_count(&a) == 1);\n        assert!(Arc::weak_count(&a) == 0);\n        let c = a.clone();\n        assert!(Arc::strong_count(&a) == 2);\n        assert!(Arc::weak_count(&a) == 0);\n        let d = Arc::downgrade(&c);\n        assert!(Arc::weak_count(&c) == 1);\n        assert!(Arc::strong_count(&c) == 2);\n\n        drop(a);\n        drop(c);\n        drop(d);\n    }\n\n    #[test]\n    fn show_arc() {\n        let a = Arc::new(5);\n        assert_eq!(format!(\"{:?}\", a), \"5\");\n    }\n\n    // Make sure deriving works with Arc<T>\n    #[derive(Eq, Ord, PartialEq, PartialOrd, Clone, Debug, Default)]\n    struct Foo {\n        inner: Arc<i32>,\n    }\n\n    #[test]\n    fn test_unsized() {\n        let x: Arc<[i32]> = Arc::new([1, 2, 3]);\n        assert_eq!(format!(\"{:?}\", x), \"[1, 2, 3]\");\n        let y = Arc::downgrade(&x.clone());\n        drop(x);\n        assert!(y.upgrade().is_none());\n    }\n\n    #[test]\n    fn test_from_owned() {\n        let foo = 123;\n        let foo_arc = Arc::from(foo);\n        assert!(123 == *foo_arc);\n    }\n\n    #[test]\n    fn test_new_weak() {\n        let foo: Weak<usize> = Weak::new();\n        assert!(foo.upgrade().is_none());\n    }\n\n    #[test]\n    fn test_ptr_eq() {\n        let five = Arc::new(5);\n        let same_five = five.clone();\n        let other_five = Arc::new(5);\n\n        assert!(Arc::ptr_eq(&five, &same_five));\n        assert!(!Arc::ptr_eq(&five, &other_five));\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn test_weak_count_locked() {\n        let mut a = Arc::new(atomic::AtomicBool::new(false));\n        let a2 = a.clone();\n        let t = thread::spawn(move || {\n            for _i in 0..1000000 {\n                Arc::get_mut(&mut a);\n            }\n            a.store(true, SeqCst);\n        });\n\n        while !a2.load(SeqCst) {\n            let n = Arc::weak_count(&a2);\n            assert!(n < 2, \"bad weak count: {}\", n);\n        }\n        t.join().unwrap();\n    }\n\n    #[test]\n    fn test_from_str() {\n        let r: Arc<str> = Arc::from(\"foo\");\n\n        assert_eq!(&r[..], \"foo\");\n    }\n\n    #[test]\n    fn test_copy_from_slice() {\n        let s: &[u32] = &[1, 2, 3];\n        let r: Arc<[u32]> = Arc::from(s);\n\n        assert_eq!(&r[..], [1, 2, 3]);\n    }\n\n    #[test]\n    fn test_clone_from_slice() {\n        #[derive(Clone, Debug, Eq, PartialEq)]\n        struct X(u32);\n\n        let s: &[X] = &[X(1), X(2), X(3)];\n        let r: Arc<[X]> = Arc::from(s);\n\n        assert_eq!(&r[..], s);\n    }\n\n    #[test]\n    #[should_panic]\n    fn test_clone_from_slice_panic() {\n        use std::string::{String, ToString};\n\n        struct Fail(u32, String);\n\n        impl Clone for Fail {\n            fn clone(&self) -> Fail {\n                if self.0 == 2 {\n                    panic!();\n                }\n                Fail(self.0, self.1.clone())\n            }\n        }\n\n        let s: &[Fail] = &[\n            Fail(0, \"foo\".to_string()),\n            Fail(1, \"bar\".to_string()),\n            Fail(2, \"baz\".to_string()),\n        ];\n\n        // Should panic, but not cause memory corruption\n        let _r: Arc<[Fail]> = Arc::from(s);\n    }\n\n    #[test]\n    fn test_from_box() {\n        let b: Box<u32> = box 123;\n        let r: Arc<u32> = Arc::from(b);\n\n        assert_eq!(*r, 123);\n    }\n\n    #[test]\n    fn test_from_box_str() {\n        use std::string::String;\n\n        let s = String::from(\"foo\").into_boxed_str();\n        let r: Arc<str> = Arc::from(s);\n\n        assert_eq!(&r[..], \"foo\");\n    }\n\n    #[test]\n    fn test_from_box_slice() {\n        let s = vec![1, 2, 3].into_boxed_slice();\n        let r: Arc<[u32]> = Arc::from(s);\n\n        assert_eq!(&r[..], [1, 2, 3]);\n    }\n\n    #[test]\n    fn test_from_box_trait() {\n        use std::fmt::Display;\n        use std::string::ToString;\n\n        let b: Box<dyn Display> = box 123;\n        let r: Arc<dyn Display> = Arc::from(b);\n\n        assert_eq!(r.to_string(), \"123\");\n    }\n\n    #[test]\n    fn test_from_box_trait_zero_sized() {\n        use std::fmt::Debug;\n\n        let b: Box<dyn Debug> = box ();\n        let r: Arc<dyn Debug> = Arc::from(b);\n\n        assert_eq!(format!(\"{:?}\", r), \"()\");\n    }\n\n    #[test]\n    fn test_from_vec() {\n        let v = vec![1, 2, 3];\n        let r: Arc<[u32]> = Arc::from(v);\n\n        assert_eq!(&r[..], [1, 2, 3]);\n    }\n\n    #[test]\n    fn test_downcast() {\n        use std::any::Any;\n\n        let r1: Arc<dyn Any + Send + Sync> = Arc::new(i32::max_value());\n        let r2: Arc<dyn Any + Send + Sync> = Arc::new(\"abc\");\n\n        assert!(r1.clone().downcast::<u32>().is_err());\n\n        let r1i32 = r1.downcast::<i32>();\n        assert!(r1i32.is_ok());\n        assert_eq!(r1i32.unwrap(), Arc::new(i32::max_value()));\n\n        assert!(r2.clone().downcast::<i32>().is_err());\n\n        let r2str = r2.downcast::<&'static str>();\n        assert!(r2str.is_ok());\n        assert_eq!(r2str.unwrap(), Arc::new(\"abc\"));\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized> borrow::Borrow<T> for Arc<T> {\n    fn borrow(&self) -> &T {\n        &**self\n    }\n}\n\n#[stable(since = \"1.5.0\", feature = \"smart_ptr_as_ref\")]\nimpl<T: ?Sized> AsRef<T> for Arc<T> {\n    fn as_ref(&self) -> &T {\n        &**self\n    }\n}\n\n#[unstable(feature = \"pin\", issue = \"49150\")]\nimpl<T: ?Sized> Unpin for Arc<T> { }\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse core::cmp::Ordering;\nuse core::fmt::Debug;\nuse core::hash::{Hash, Hasher};\nuse core::iter::{FromIterator, Peekable, FusedIterator};\nuse core::marker::PhantomData;\nuse core::ops::Bound::{Excluded, Included, Unbounded};\nuse core::ops::Index;\nuse core::ops::RangeBounds;\nuse core::{fmt, intrinsics, mem, ptr};\n\nuse borrow::Borrow;\n\nuse super::node::{self, Handle, NodeRef, marker};\nuse super::search;\n\nuse super::node::InsertResult::*;\nuse super::node::ForceResult::*;\nuse super::search::SearchResult::*;\nuse self::UnderflowResult::*;\nuse self::Entry::*;\n\n/// A map based on a B-Tree.\n///\n/// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing\n/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal\n/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of\n/// comparisons necessary to find an element (log<sub>2</sub>n). However, in practice the way this\n/// is done is *very* inefficient for modern computer architectures. In particular, every element\n/// is stored in its own individually heap-allocated node. This means that every single insertion\n/// triggers a heap-allocation, and every single comparison should be a cache-miss. Since these\n/// are both notably expensive things to do in practice, we are forced to at very least reconsider\n/// the BST strategy.\n///\n/// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing\n/// this, we reduce the number of allocations by a factor of B, and improve cache efficiency in\n/// searches. However, this does mean that searches will have to do *more* comparisons on average.\n/// The precise number of comparisons depends on the node search strategy used. For optimal cache\n/// efficiency, one could search the nodes linearly. For optimal comparisons, one could search\n/// the node using binary search. As a compromise, one could also perform a linear search\n/// that initially only checks every i<sup>th</sup> element for some choice of i.\n///\n/// Currently, our implementation simply performs naive linear search. This provides excellent\n/// performance on *small* nodes of elements which are cheap to compare. However in the future we\n/// would like to further explore choosing the optimal search strategy based on the choice of B,\n/// and possibly other factors. Using linear search, searching for a random element is expected\n/// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,\n/// however, performance is excellent.\n///\n/// It is a logic error for a key to be modified in such a way that the key's ordering relative to\n/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is\n/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.\n///\n/// [`Ord`]: ../../std/cmp/trait.Ord.html\n/// [`Cell`]: ../../std/cell/struct.Cell.html\n/// [`RefCell`]: ../../std/cell/struct.RefCell.html\n///\n/// # Examples\n///\n/// ```\n/// use std::collections::BTreeMap;\n///\n/// // type inference lets us omit an explicit type signature (which\n/// // would be `BTreeMap<&str, &str>` in this example).\n/// let mut movie_reviews = BTreeMap::new();\n///\n/// // review some movies.\n/// movie_reviews.insert(\"Office Space\",       \"Deals with real issues in the workplace.\");\n/// movie_reviews.insert(\"Pulp Fiction\",       \"Masterpiece.\");\n/// movie_reviews.insert(\"The Godfather\",      \"Very enjoyable.\");\n/// movie_reviews.insert(\"The Blues Brothers\", \"Eye lyked it a lot.\");\n///\n/// // check for a specific one.\n/// if !movie_reviews.contains_key(\"Les Mis\u00e9rables\") {\n///     println!(\"We've got {} reviews, but Les Mis\u00e9rables ain't one.\",\n///              movie_reviews.len());\n/// }\n///\n/// // oops, this review has a lot of spelling mistakes, let's delete it.\n/// movie_reviews.remove(\"The Blues Brothers\");\n///\n/// // look up the values associated with some keys.\n/// let to_find = [\"Up!\", \"Office Space\"];\n/// for book in &to_find {\n///     match movie_reviews.get(book) {\n///        Some(review) => println!(\"{}: {}\", book, review),\n///        None => println!(\"{} is unreviewed.\", book)\n///     }\n/// }\n///\n/// // iterate over everything.\n/// for (movie, review) in &movie_reviews {\n///     println!(\"{}: \\\"{}\\\"\", movie, review);\n/// }\n/// ```\n///\n/// `BTreeMap` also implements an [`Entry API`](#method.entry), which allows\n/// for more complex methods of getting, setting, updating and removing keys and\n/// their values:\n///\n/// ```\n/// use std::collections::BTreeMap;\n///\n/// // type inference lets us omit an explicit type signature (which\n/// // would be `BTreeMap<&str, u8>` in this example).\n/// let mut player_stats = BTreeMap::new();\n///\n/// fn random_stat_buff() -> u8 {\n///     // could actually return some random value here - let's just return\n///     // some fixed value for now\n///     42\n/// }\n///\n/// // insert a key only if it doesn't already exist\n/// player_stats.entry(\"health\").or_insert(100);\n///\n/// // insert a key using a function that provides a new value only if it\n/// // doesn't already exist\n/// player_stats.entry(\"defence\").or_insert_with(random_stat_buff);\n///\n/// // update a key, guarding against the key possibly not being set\n/// let stat = player_stats.entry(\"attack\").or_insert(100);\n/// *stat += random_stat_buff();\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct BTreeMap<K, V> {\n    root: node::Root<K, V>,\n    length: usize,\n}\n\n#[stable(feature = \"btree_drop\", since = \"1.7.0\")]\nunsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {\n    fn drop(&mut self) {\n        unsafe {\n            drop(ptr::read(self).into_iter());\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Clone, V: Clone> Clone for BTreeMap<K, V> {\n    fn clone(&self) -> BTreeMap<K, V> {\n        fn clone_subtree<'a, K: Clone, V: Clone>(\n            node: node::NodeRef<marker::Immut<'a>, K, V, marker::LeafOrInternal>\n        ) -> BTreeMap<K, V>\n        where K: 'a, V: 'a,\n        {\n            match node.force() {\n                Leaf(leaf) => {\n                    let mut out_tree = BTreeMap {\n                        root: node::Root::new_leaf(),\n                        length: 0,\n                    };\n\n                    {\n                        let mut out_node = match out_tree.root.as_mut().force() {\n                            Leaf(leaf) => leaf,\n                            Internal(_) => unreachable!(),\n                        };\n\n                        let mut in_edge = leaf.first_edge();\n                        while let Ok(kv) = in_edge.right_kv() {\n                            let (k, v) = kv.into_kv();\n                            in_edge = kv.right_edge();\n\n                            out_node.push(k.clone(), v.clone());\n                            out_tree.length += 1;\n                        }\n                    }\n\n                    out_tree\n                }\n                Internal(internal) => {\n                    let mut out_tree = clone_subtree(internal.first_edge().descend());\n\n                    {\n                        let mut out_node = out_tree.root.push_level();\n                        let mut in_edge = internal.first_edge();\n                        while let Ok(kv) = in_edge.right_kv() {\n                            let (k, v) = kv.into_kv();\n                            in_edge = kv.right_edge();\n\n                            let k = (*k).clone();\n                            let v = (*v).clone();\n                            let subtree = clone_subtree(in_edge.descend());\n\n                            // We can't destructure subtree directly\n                            // because BTreeMap implements Drop\n                            let (subroot, sublength) = unsafe {\n                                let root = ptr::read(&subtree.root);\n                                let length = subtree.length;\n                                mem::forget(subtree);\n                                (root, length)\n                            };\n\n                            out_node.push(k, v, subroot);\n                            out_tree.length += 1 + sublength;\n                        }\n                    }\n\n                    out_tree\n                }\n            }\n        }\n\n        if self.len() == 0 {\n            // Ideally we'd call `BTreeMap::new` here, but that has the `K:\n            // Ord` constraint, which this method lacks.\n            BTreeMap {\n                root: node::Root::shared_empty_root(),\n                length: 0,\n            }\n        } else {\n            clone_subtree(self.root.as_ref())\n        }\n    }\n}\n\nimpl<K, Q: ?Sized> super::Recover<Q> for BTreeMap<K, ()>\n    where K: Borrow<Q> + Ord,\n          Q: Ord\n{\n    type Key = K;\n\n    fn get(&self, key: &Q) -> Option<&K> {\n        match search::search_tree(self.root.as_ref(), key) {\n            Found(handle) => Some(handle.into_kv().0),\n            GoDown(_) => None,\n        }\n    }\n\n    fn take(&mut self, key: &Q) -> Option<K> {\n        match search::search_tree(self.root.as_mut(), key) {\n            Found(handle) => {\n                Some(OccupiedEntry {\n                         handle,\n                         length: &mut self.length,\n                         _marker: PhantomData,\n                     }\n                     .remove_kv()\n                     .0)\n            }\n            GoDown(_) => None,\n        }\n    }\n\n    fn replace(&mut self, key: K) -> Option<K> {\n        self.ensure_root_is_owned();\n        match search::search_tree::<marker::Mut, K, (), K>(self.root.as_mut(), &key) {\n            Found(handle) => Some(mem::replace(handle.into_kv_mut().0, key)),\n            GoDown(handle) => {\n                VacantEntry {\n                    key,\n                    handle,\n                    length: &mut self.length,\n                    _marker: PhantomData,\n                }\n                .insert(());\n                None\n            }\n        }\n    }\n}\n\n/// An iterator over the entries of a `BTreeMap`.\n///\n/// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`iter`]: struct.BTreeMap.html#method.iter\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Iter<'a, K: 'a, V: 'a> {\n    range: Range<'a, K, V>,\n    length: usize,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Iter<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list().entries(self.clone()).finish()\n    }\n}\n\n/// A mutable iterator over the entries of a `BTreeMap`.\n///\n/// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`iter_mut`]: struct.BTreeMap.html#method.iter_mut\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct IterMut<'a, K: 'a, V: 'a> {\n    range: RangeMut<'a, K, V>,\n    length: usize,\n}\n\n/// An owning iterator over the entries of a `BTreeMap`.\n///\n/// This `struct` is created by the [`into_iter`] method on [`BTreeMap`][`BTreeMap`]\n/// (provided by the `IntoIterator` trait). See its documentation for more.\n///\n/// [`into_iter`]: struct.BTreeMap.html#method.into_iter\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoIter<K, V> {\n    front: Handle<NodeRef<marker::Owned, K, V, marker::Leaf>, marker::Edge>,\n    back: Handle<NodeRef<marker::Owned, K, V, marker::Leaf>, marker::Edge>,\n    length: usize,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let range = Range {\n            front: self.front.reborrow(),\n            back: self.back.reborrow(),\n        };\n        f.debug_list().entries(range).finish()\n    }\n}\n\n/// An iterator over the keys of a `BTreeMap`.\n///\n/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`keys`]: struct.BTreeMap.html#method.keys\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Keys<'a, K: 'a, V: 'a> {\n    inner: Iter<'a, K, V>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, K: 'a + fmt::Debug, V: 'a> fmt::Debug for Keys<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list().entries(self.clone()).finish()\n    }\n}\n\n/// An iterator over the values of a `BTreeMap`.\n///\n/// This `struct` is created by the [`values`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`values`]: struct.BTreeMap.html#method.values\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Values<'a, K: 'a, V: 'a> {\n    inner: Iter<'a, K, V>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, K: 'a, V: 'a + fmt::Debug> fmt::Debug for Values<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list().entries(self.clone()).finish()\n    }\n}\n\n/// A mutable iterator over the values of a `BTreeMap`.\n///\n/// This `struct` is created by the [`values_mut`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`values_mut`]: struct.BTreeMap.html#method.values_mut\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\n#[derive(Debug)]\npub struct ValuesMut<'a, K: 'a, V: 'a> {\n    inner: IterMut<'a, K, V>,\n}\n\n/// An iterator over a sub-range of entries in a `BTreeMap`.\n///\n/// This `struct` is created by the [`range`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`range`]: struct.BTreeMap.html#method.range\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\npub struct Range<'a, K: 'a, V: 'a> {\n    front: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,\n    back: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Range<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list().entries(self.clone()).finish()\n    }\n}\n\n/// A mutable iterator over a sub-range of entries in a `BTreeMap`.\n///\n/// This `struct` is created by the [`range_mut`] method on [`BTreeMap`]. See its\n/// documentation for more.\n///\n/// [`range_mut`]: struct.BTreeMap.html#method.range_mut\n/// [`BTreeMap`]: struct.BTreeMap.html\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\npub struct RangeMut<'a, K: 'a, V: 'a> {\n    front: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,\n    back: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,\n\n    // Be invariant in `K` and `V`\n    _marker: PhantomData<&'a mut (K, V)>,\n}\n\n#[stable(feature = \"collection_debug\", since = \"1.17.0\")]\nimpl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for RangeMut<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        let range = Range {\n            front: self.front.reborrow(),\n            back: self.back.reborrow(),\n        };\n        f.debug_list().entries(range).finish()\n    }\n}\n\n/// A view into a single entry in a map, which may either be vacant or occupied.\n///\n/// This `enum` is constructed from the [`entry`] method on [`BTreeMap`].\n///\n/// [`BTreeMap`]: struct.BTreeMap.html\n/// [`entry`]: struct.BTreeMap.html#method.entry\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Entry<'a, K: 'a, V: 'a> {\n    /// A vacant entry.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Vacant(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n           VacantEntry<'a, K, V>),\n\n    /// An occupied entry.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Occupied(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n             OccupiedEntry<'a, K, V>),\n}\n\n#[stable(feature= \"debug_btree_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for Entry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            Vacant(ref v) => f.debug_tuple(\"Entry\")\n                              .field(v)\n                              .finish(),\n            Occupied(ref o) => f.debug_tuple(\"Entry\")\n                                .field(o)\n                                .finish(),\n        }\n    }\n}\n\n/// A view into a vacant entry in a `BTreeMap`.\n/// It is part of the [`Entry`] enum.\n///\n/// [`Entry`]: enum.Entry.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct VacantEntry<'a, K: 'a, V: 'a> {\n    key: K,\n    handle: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,\n    length: &'a mut usize,\n\n    // Be invariant in `K` and `V`\n    _marker: PhantomData<&'a mut (K, V)>,\n}\n\n#[stable(feature= \"debug_btree_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug + Ord, V: 'a> Debug for VacantEntry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"VacantEntry\")\n         .field(self.key())\n         .finish()\n    }\n}\n\n/// A view into an occupied entry in a `BTreeMap`.\n/// It is part of the [`Entry`] enum.\n///\n/// [`Entry`]: enum.Entry.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct OccupiedEntry<'a, K: 'a, V: 'a> {\n    handle: Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::KV>,\n\n    length: &'a mut usize,\n\n    // Be invariant in `K` and `V`\n    _marker: PhantomData<&'a mut (K, V)>,\n}\n\n#[stable(feature= \"debug_btree_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"OccupiedEntry\")\n         .field(\"key\", self.key())\n         .field(\"value\", self.get())\n         .finish()\n    }\n}\n\n// An iterator for merging two sorted sequences into one\nstruct MergeIter<K, V, I: Iterator<Item = (K, V)>> {\n    left: Peekable<I>,\n    right: Peekable<I>,\n}\n\nimpl<K: Ord, V> BTreeMap<K, V> {\n    /// Makes a new empty BTreeMap with a reasonable choice for B.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    ///\n    /// // entries can now be inserted into the empty map\n    /// map.insert(1, \"a\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> BTreeMap<K, V> {\n        BTreeMap {\n            root: node::Root::shared_empty_root(),\n            length: 0,\n        }\n    }\n\n    /// Clears the map, removing all values.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(1, \"a\");\n    /// a.clear();\n    /// assert!(a.is_empty());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn clear(&mut self) {\n        *self = BTreeMap::new();\n    }\n\n    /// Returns a reference to the value corresponding to the key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but the ordering\n    /// on the borrowed form *must* match the ordering on the key type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.get(&1), Some(&\"a\"));\n    /// assert_eq!(map.get(&2), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>\n        where K: Borrow<Q>,\n              Q: Ord\n    {\n        match search::search_tree(self.root.as_ref(), key) {\n            Found(handle) => Some(handle.into_kv().1),\n            GoDown(_) => None,\n        }\n    }\n\n    /// Returns the key-value pair corresponding to the supplied key.\n    ///\n    /// The supplied key may be any borrowed form of the map's key type, but the ordering\n    /// on the borrowed form *must* match the ordering on the key type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(map_get_key_value)]\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.get_key_value(&1), Some((&1, &\"a\")));\n    /// assert_eq!(map.get_key_value(&2), None);\n    /// ```\n    #[unstable(feature = \"map_get_key_value\", issue = \"49347\")]\n    pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)>\n        where K: Borrow<Q>,\n              Q: Ord\n    {\n        match search::search_tree(self.root.as_ref(), k) {\n            Found(handle) => Some(handle.into_kv()),\n            GoDown(_) => None,\n        }\n    }\n\n    /// Returns `true` if the map contains a value for the specified key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but the ordering\n    /// on the borrowed form *must* match the ordering on the key type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.contains_key(&1), true);\n    /// assert_eq!(map.contains_key(&2), false);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool\n        where K: Borrow<Q>,\n              Q: Ord\n    {\n        self.get(key).is_some()\n    }\n\n    /// Returns a mutable reference to the value corresponding to the key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but the ordering\n    /// on the borrowed form *must* match the ordering on the key type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(1, \"a\");\n    /// if let Some(x) = map.get_mut(&1) {\n    ///     *x = \"b\";\n    /// }\n    /// assert_eq!(map[&1], \"b\");\n    /// ```\n    // See `get` for implementation notes, this is basically a copy-paste with mut's added\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V>\n        where K: Borrow<Q>,\n              Q: Ord\n    {\n        match search::search_tree(self.root.as_mut(), key) {\n            Found(handle) => Some(handle.into_kv_mut().1),\n            GoDown(_) => None,\n        }\n    }\n\n    /// Inserts a key-value pair into the map.\n    ///\n    /// If the map did not have this key present, `None` is returned.\n    ///\n    /// If the map did have this key present, the value is updated, and the old\n    /// value is returned. The key is not updated, though; this matters for\n    /// types that can be `==` without being identical. See the [module-level\n    /// documentation] for more.\n    ///\n    /// [module-level documentation]: index.html#insert-and-complex-keys\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// assert_eq!(map.insert(37, \"a\"), None);\n    /// assert_eq!(map.is_empty(), false);\n    ///\n    /// map.insert(37, \"b\");\n    /// assert_eq!(map.insert(37, \"c\"), Some(\"b\"));\n    /// assert_eq!(map[&37], \"c\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, key: K, value: V) -> Option<V> {\n        match self.entry(key) {\n            Occupied(mut entry) => Some(entry.insert(value)),\n            Vacant(entry) => {\n                entry.insert(value);\n                None\n            }\n        }\n    }\n\n    /// Removes a key from the map, returning the value at the key if the key\n    /// was previously in the map.\n    ///\n    /// The key may be any borrowed form of the map's key type, but the ordering\n    /// on the borrowed form *must* match the ordering on the key type.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.remove(&1), Some(\"a\"));\n    /// assert_eq!(map.remove(&1), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>\n        where K: Borrow<Q>,\n              Q: Ord\n    {\n        match search::search_tree(self.root.as_mut(), key) {\n            Found(handle) => {\n                Some(OccupiedEntry {\n                         handle,\n                         length: &mut self.length,\n                         _marker: PhantomData,\n                     }\n                     .remove())\n            }\n            GoDown(_) => None,\n        }\n    }\n\n    /// Moves all elements from `other` into `Self`, leaving `other` empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(1, \"a\");\n    /// a.insert(2, \"b\");\n    /// a.insert(3, \"c\");\n    ///\n    /// let mut b = BTreeMap::new();\n    /// b.insert(3, \"d\");\n    /// b.insert(4, \"e\");\n    /// b.insert(5, \"f\");\n    ///\n    /// a.append(&mut b);\n    ///\n    /// assert_eq!(a.len(), 5);\n    /// assert_eq!(b.len(), 0);\n    ///\n    /// assert_eq!(a[&1], \"a\");\n    /// assert_eq!(a[&2], \"b\");\n    /// assert_eq!(a[&3], \"d\");\n    /// assert_eq!(a[&4], \"e\");\n    /// assert_eq!(a[&5], \"f\");\n    /// ```\n    #[stable(feature = \"btree_append\", since = \"1.11.0\")]\n    pub fn append(&mut self, other: &mut Self) {\n        // Do we have to append anything at all?\n        if other.len() == 0 {\n            return;\n        }\n\n        // We can just swap `self` and `other` if `self` is empty.\n        if self.len() == 0 {\n            mem::swap(self, other);\n            return;\n        }\n\n        // First, we merge `self` and `other` into a sorted sequence in linear time.\n        let self_iter = mem::replace(self, BTreeMap::new()).into_iter();\n        let other_iter = mem::replace(other, BTreeMap::new()).into_iter();\n        let iter = MergeIter {\n            left: self_iter.peekable(),\n            right: other_iter.peekable(),\n        };\n\n        // Second, we build a tree from the sorted sequence in linear time.\n        self.from_sorted_iter(iter);\n        self.fix_right_edge();\n    }\n\n    /// Constructs a double-ended iterator over a sub-range of elements in the map.\n    /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will\n    /// yield elements from min (inclusive) to max (exclusive).\n    /// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example\n    /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive\n    /// range from 4 to 10.\n    ///\n    /// # Panics\n    ///\n    /// Panics if range `start > end`.\n    /// Panics if range `start == end` and both bounds are `Excluded`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::ops::Bound::Included;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(3, \"a\");\n    /// map.insert(5, \"b\");\n    /// map.insert(8, \"c\");\n    /// for (&key, &value) in map.range((Included(&4), Included(&8))) {\n    ///     println!(\"{}: {}\", key, value);\n    /// }\n    /// assert_eq!(Some((&5, &\"b\")), map.range(4..).next());\n    /// ```\n    #[stable(feature = \"btree_range\", since = \"1.17.0\")]\n    pub fn range<T: ?Sized, R>(&self, range: R) -> Range<K, V>\n        where T: Ord, K: Borrow<T>, R: RangeBounds<T>\n    {\n        let root1 = self.root.as_ref();\n        let root2 = self.root.as_ref();\n        let (f, b) = range_search(root1, root2, range);\n\n        Range { front: f, back: b}\n    }\n\n    /// Constructs a mutable double-ended iterator over a sub-range of elements in the map.\n    /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will\n    /// yield elements from min (inclusive) to max (exclusive).\n    /// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example\n    /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive\n    /// range from 4 to 10.\n    ///\n    /// # Panics\n    ///\n    /// Panics if range `start > end`.\n    /// Panics if range `start == end` and both bounds are `Excluded`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, i32> = [\"Alice\", \"Bob\", \"Carol\", \"Cheryl\"].iter()\n    ///                                                                       .map(|&s| (s, 0))\n    ///                                                                       .collect();\n    /// for (_, balance) in map.range_mut(\"B\"..\"Cheryl\") {\n    ///     *balance += 100;\n    /// }\n    /// for (name, balance) in &map {\n    ///     println!(\"{} => {}\", name, balance);\n    /// }\n    /// ```\n    #[stable(feature = \"btree_range\", since = \"1.17.0\")]\n    pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<K, V>\n        where T: Ord, K: Borrow<T>, R: RangeBounds<T>\n    {\n        let root1 = self.root.as_mut();\n        let root2 = unsafe { ptr::read(&root1) };\n        let (f, b) = range_search(root1, root2, range);\n\n        RangeMut {\n            front: f,\n            back: b,\n            _marker: PhantomData,\n        }\n    }\n\n    /// Gets the given key's corresponding entry in the map for in-place manipulation.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();\n    ///\n    /// // count the number of occurrences of letters in the vec\n    /// for x in vec![\"a\",\"b\",\"a\",\"c\",\"a\",\"b\"] {\n    ///     *count.entry(x).or_insert(0) += 1;\n    /// }\n    ///\n    /// assert_eq!(count[\"a\"], 3);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn entry(&mut self, key: K) -> Entry<K, V> {\n        // FIXME(@porglezomp) Avoid allocating if we don't insert\n        self.ensure_root_is_owned();\n        match search::search_tree(self.root.as_mut(), &key) {\n            Found(handle) => {\n                Occupied(OccupiedEntry {\n                    handle,\n                    length: &mut self.length,\n                    _marker: PhantomData,\n                })\n            }\n            GoDown(handle) => {\n                Vacant(VacantEntry {\n                    key,\n                    handle,\n                    length: &mut self.length,\n                    _marker: PhantomData,\n                })\n            }\n        }\n    }\n\n    fn from_sorted_iter<I: Iterator<Item = (K, V)>>(&mut self, iter: I) {\n        self.ensure_root_is_owned();\n        let mut cur_node = last_leaf_edge(self.root.as_mut()).into_node();\n        // Iterate through all key-value pairs, pushing them into nodes at the right level.\n        for (key, value) in iter {\n            // Try to push key-value pair into the current leaf node.\n            if cur_node.len() < node::CAPACITY {\n                cur_node.push(key, value);\n            } else {\n                // No space left, go up and push there.\n                let mut open_node;\n                let mut test_node = cur_node.forget_type();\n                loop {\n                    match test_node.ascend() {\n                        Ok(parent) => {\n                            let parent = parent.into_node();\n                            if parent.len() < node::CAPACITY {\n                                // Found a node with space left, push here.\n                                open_node = parent;\n                                break;\n                            } else {\n                                // Go up again.\n                                test_node = parent.forget_type();\n                            }\n                        }\n                        Err(node) => {\n                            // We are at the top, create a new root node and push there.\n                            open_node = node.into_root_mut().push_level();\n                            break;\n                        }\n                    }\n                }\n\n                // Push key-value pair and new right subtree.\n                let tree_height = open_node.height() - 1;\n                let mut right_tree = node::Root::new_leaf();\n                for _ in 0..tree_height {\n                    right_tree.push_level();\n                }\n                open_node.push(key, value, right_tree);\n\n                // Go down to the right-most leaf again.\n                cur_node = last_leaf_edge(open_node.forget_type()).into_node();\n            }\n\n            self.length += 1;\n        }\n    }\n\n    fn fix_right_edge(&mut self) {\n        // Handle underfull nodes, start from the top.\n        let mut cur_node = self.root.as_mut();\n        while let Internal(internal) = cur_node.force() {\n            // Check if right-most child is underfull.\n            let mut last_edge = internal.last_edge();\n            let right_child_len = last_edge.reborrow().descend().len();\n            if right_child_len < node::MIN_LEN {\n                // We need to steal.\n                let mut last_kv = match last_edge.left_kv() {\n                    Ok(left) => left,\n                    Err(_) => unreachable!(),\n                };\n                last_kv.bulk_steal_left(node::MIN_LEN - right_child_len);\n                last_edge = last_kv.right_edge();\n            }\n\n            // Go further down.\n            cur_node = last_edge.descend();\n        }\n    }\n\n    /// Splits the collection into two at the given key. Returns everything after the given key,\n    /// including the key.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(1, \"a\");\n    /// a.insert(2, \"b\");\n    /// a.insert(3, \"c\");\n    /// a.insert(17, \"d\");\n    /// a.insert(41, \"e\");\n    ///\n    /// let b = a.split_off(&3);\n    ///\n    /// assert_eq!(a.len(), 2);\n    /// assert_eq!(b.len(), 3);\n    ///\n    /// assert_eq!(a[&1], \"a\");\n    /// assert_eq!(a[&2], \"b\");\n    ///\n    /// assert_eq!(b[&3], \"c\");\n    /// assert_eq!(b[&17], \"d\");\n    /// assert_eq!(b[&41], \"e\");\n    /// ```\n    #[stable(feature = \"btree_split_off\", since = \"1.11.0\")]\n    pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self\n        where K: Borrow<Q>\n    {\n        if self.is_empty() {\n            return Self::new();\n        }\n\n        let total_num = self.len();\n\n        let mut right = Self::new();\n        right.root = node::Root::new_leaf();\n        for _ in 0..(self.root.as_ref().height()) {\n            right.root.push_level();\n        }\n\n        {\n            let mut left_node = self.root.as_mut();\n            let mut right_node = right.root.as_mut();\n\n            loop {\n                let mut split_edge = match search::search_node(left_node, key) {\n                    // key is going to the right tree\n                    Found(handle) => handle.left_edge(),\n                    GoDown(handle) => handle,\n                };\n\n                split_edge.move_suffix(&mut right_node);\n\n                match (split_edge.force(), right_node.force()) {\n                    (Internal(edge), Internal(node)) => {\n                        left_node = edge.descend();\n                        right_node = node.first_edge().descend();\n                    }\n                    (Leaf(_), Leaf(_)) => {\n                        break;\n                    }\n                    _ => {\n                        unreachable!();\n                    }\n                }\n            }\n        }\n\n        self.fix_right_border();\n        right.fix_left_border();\n\n        if self.root.as_ref().height() < right.root.as_ref().height() {\n            self.recalc_length();\n            right.length = total_num - self.len();\n        } else {\n            right.recalc_length();\n            self.length = total_num - right.len();\n        }\n\n        right\n    }\n\n    /// Calculates the number of elements if it is incorrect.\n    fn recalc_length(&mut self) {\n        fn dfs<'a, K, V>(\n            node: NodeRef<marker::Immut<'a>, K, V, marker::LeafOrInternal>\n        ) -> usize\n        where K: 'a, V: 'a\n        {\n            let mut res = node.len();\n\n            if let Internal(node) = node.force() {\n                let mut edge = node.first_edge();\n                loop {\n                    res += dfs(edge.reborrow().descend());\n                    match edge.right_kv() {\n                        Ok(right_kv) => {\n                            edge = right_kv.right_edge();\n                        }\n                        Err(_) => {\n                            break;\n                        }\n                    }\n                }\n            }\n\n            res\n        }\n\n        self.length = dfs(self.root.as_ref());\n    }\n\n    /// Removes empty levels on the top.\n    fn fix_top(&mut self) {\n        loop {\n            {\n                let node = self.root.as_ref();\n                if node.height() == 0 || node.len() > 0 {\n                    break;\n                }\n            }\n            self.root.pop_level();\n        }\n    }\n\n    fn fix_right_border(&mut self) {\n        self.fix_top();\n\n        {\n            let mut cur_node = self.root.as_mut();\n\n            while let Internal(node) = cur_node.force() {\n                let mut last_kv = node.last_kv();\n\n                if last_kv.can_merge() {\n                    cur_node = last_kv.merge().descend();\n                } else {\n                    let right_len = last_kv.reborrow().right_edge().descend().len();\n                    // `MINLEN + 1` to avoid readjust if merge happens on the next level.\n                    if right_len < node::MIN_LEN + 1 {\n                        last_kv.bulk_steal_left(node::MIN_LEN + 1 - right_len);\n                    }\n                    cur_node = last_kv.right_edge().descend();\n                }\n            }\n        }\n\n        self.fix_top();\n    }\n\n    /// The symmetric clone of `fix_right_border`.\n    fn fix_left_border(&mut self) {\n        self.fix_top();\n\n        {\n            let mut cur_node = self.root.as_mut();\n\n            while let Internal(node) = cur_node.force() {\n                let mut first_kv = node.first_kv();\n\n                if first_kv.can_merge() {\n                    cur_node = first_kv.merge().descend();\n                } else {\n                    let left_len = first_kv.reborrow().left_edge().descend().len();\n                    if left_len < node::MIN_LEN + 1 {\n                        first_kv.bulk_steal_right(node::MIN_LEN + 1 - left_len);\n                    }\n                    cur_node = first_kv.left_edge().descend();\n                }\n            }\n        }\n\n        self.fix_top();\n    }\n\n    /// If the root node is the shared root node, allocate our own node.\n    fn ensure_root_is_owned(&mut self) {\n        if self.root.is_shared_root() {\n            self.root = node::Root::new_leaf();\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> IntoIterator for &'a BTreeMap<K, V> {\n    type Item = (&'a K, &'a V);\n    type IntoIter = Iter<'a, K, V>;\n\n    fn into_iter(self) -> Iter<'a, K, V> {\n        self.iter()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {\n    type Item = (&'a K, &'a V);\n\n    fn next(&mut self) -> Option<(&'a K, &'a V)> {\n        if self.length == 0 {\n            None\n        } else {\n            self.length -= 1;\n            unsafe { Some(self.range.next_unchecked()) }\n        }\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (self.length, Some(self.length))\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Iter<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> {\n    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {\n        if self.length == 0 {\n            None\n        } else {\n            self.length -= 1;\n            unsafe { Some(self.range.next_back_unchecked()) }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> ExactSizeIterator for Iter<'a, K, V> {\n    fn len(&self) -> usize {\n        self.length\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Iter<'a, K, V> {\n    fn clone(&self) -> Iter<'a, K, V> {\n        Iter {\n            range: self.range.clone(),\n            length: self.length,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> IntoIterator for &'a mut BTreeMap<K, V> {\n    type Item = (&'a K, &'a mut V);\n    type IntoIter = IterMut<'a, K, V>;\n\n    fn into_iter(self) -> IterMut<'a, K, V> {\n        self.iter_mut()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> {\n    type Item = (&'a K, &'a mut V);\n\n    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {\n        if self.length == 0 {\n            None\n        } else {\n            self.length -= 1;\n            unsafe { Some(self.range.next_unchecked()) }\n        }\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (self.length, Some(self.length))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> {\n    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {\n        if self.length == 0 {\n            None\n        } else {\n            self.length -= 1;\n            unsafe { Some(self.range.next_back_unchecked()) }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: 'a, V: 'a> ExactSizeIterator for IterMut<'a, K, V> {\n    fn len(&self) -> usize {\n        self.length\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for IterMut<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> IntoIterator for BTreeMap<K, V> {\n    type Item = (K, V);\n    type IntoIter = IntoIter<K, V>;\n\n    fn into_iter(self) -> IntoIter<K, V> {\n        let root1 = unsafe { ptr::read(&self.root).into_ref() };\n        let root2 = unsafe { ptr::read(&self.root).into_ref() };\n        let len = self.length;\n        mem::forget(self);\n\n        IntoIter {\n            front: first_leaf_edge(root1),\n            back: last_leaf_edge(root2),\n            length: len,\n        }\n    }\n}\n\n#[stable(feature = \"btree_drop\", since = \"1.7.0\")]\nimpl<K, V> Drop for IntoIter<K, V> {\n    fn drop(&mut self) {\n        self.for_each(drop);\n        unsafe {\n            let leaf_node = ptr::read(&self.front).into_node();\n            if leaf_node.is_shared_root() {\n                return;\n            }\n\n            if let Some(first_parent) = leaf_node.deallocate_and_ascend() {\n                let mut cur_node = first_parent.into_node();\n                while let Some(parent) = cur_node.deallocate_and_ascend() {\n                    cur_node = parent.into_node()\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> Iterator for IntoIter<K, V> {\n    type Item = (K, V);\n\n    fn next(&mut self) -> Option<(K, V)> {\n        if self.length == 0 {\n            return None;\n        } else {\n            self.length -= 1;\n        }\n\n        let handle = unsafe { ptr::read(&self.front) };\n\n        let mut cur_handle = match handle.right_kv() {\n            Ok(kv) => {\n                let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };\n                let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };\n                self.front = kv.right_edge();\n                return Some((k, v));\n            }\n            Err(last_edge) => unsafe {\n                unwrap_unchecked(last_edge.into_node().deallocate_and_ascend())\n            },\n        };\n\n        loop {\n            match cur_handle.right_kv() {\n                Ok(kv) => {\n                    let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };\n                    let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };\n                    self.front = first_leaf_edge(kv.right_edge().descend());\n                    return Some((k, v));\n                }\n                Err(last_edge) => unsafe {\n                    cur_handle = unwrap_unchecked(last_edge.into_node().deallocate_and_ascend());\n                },\n            }\n        }\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        (self.length, Some(self.length))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> DoubleEndedIterator for IntoIter<K, V> {\n    fn next_back(&mut self) -> Option<(K, V)> {\n        if self.length == 0 {\n            return None;\n        } else {\n            self.length -= 1;\n        }\n\n        let handle = unsafe { ptr::read(&self.back) };\n\n        let mut cur_handle = match handle.left_kv() {\n            Ok(kv) => {\n                let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };\n                let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };\n                self.back = kv.left_edge();\n                return Some((k, v));\n            }\n            Err(last_edge) => unsafe {\n                unwrap_unchecked(last_edge.into_node().deallocate_and_ascend())\n            },\n        };\n\n        loop {\n            match cur_handle.left_kv() {\n                Ok(kv) => {\n                    let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };\n                    let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };\n                    self.back = last_leaf_edge(kv.left_edge().descend());\n                    return Some((k, v));\n                }\n                Err(last_edge) => unsafe {\n                    cur_handle = unwrap_unchecked(last_edge.into_node().deallocate_and_ascend());\n                },\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> ExactSizeIterator for IntoIter<K, V> {\n    fn len(&self) -> usize {\n        self.length\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<K, V> FusedIterator for IntoIter<K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for Keys<'a, K, V> {\n    type Item = &'a K;\n\n    fn next(&mut self) -> Option<&'a K> {\n        self.inner.next().map(|(k, _)| k)\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {\n    fn next_back(&mut self) -> Option<&'a K> {\n        self.inner.next_back().map(|(k, _)| k)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Keys<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Keys<'a, K, V> {\n    fn clone(&self) -> Keys<'a, K, V> {\n        Keys { inner: self.inner.clone() }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for Values<'a, K, V> {\n    type Item = &'a V;\n\n    fn next(&mut self) -> Option<&'a V> {\n        self.inner.next().map(|(_, v)| v)\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {\n    fn next_back(&mut self) -> Option<&'a V> {\n        self.inner.next_back().map(|(_, v)| v)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Values<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Values<'a, K, V> {\n    fn clone(&self) -> Values<'a, K, V> {\n        Values { inner: self.inner.clone() }\n    }\n}\n\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\nimpl<'a, K, V> Iterator for Range<'a, K, V> {\n    type Item = (&'a K, &'a V);\n\n    fn next(&mut self) -> Option<(&'a K, &'a V)> {\n        if self.front == self.back {\n            None\n        } else {\n            unsafe { Some(self.next_unchecked()) }\n        }\n    }\n}\n\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\nimpl<'a, K, V> Iterator for ValuesMut<'a, K, V> {\n    type Item = &'a mut V;\n\n    fn next(&mut self) -> Option<&'a mut V> {\n        self.inner.next().map(|(_, v)| v)\n    }\n\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\nimpl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> {\n    fn next_back(&mut self) -> Option<&'a mut V> {\n        self.inner.next_back().map(|(_, v)| v)\n    }\n}\n\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\nimpl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for ValuesMut<'a, K, V> {}\n\n\nimpl<'a, K, V> Range<'a, K, V> {\n    unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) {\n        let handle = self.front;\n\n        let mut cur_handle = match handle.right_kv() {\n            Ok(kv) => {\n                let ret = kv.into_kv();\n                self.front = kv.right_edge();\n                return ret;\n            }\n            Err(last_edge) => {\n                let next_level = last_edge.into_node().ascend().ok();\n                unwrap_unchecked(next_level)\n            }\n        };\n\n        loop {\n            match cur_handle.right_kv() {\n                Ok(kv) => {\n                    let ret = kv.into_kv();\n                    self.front = first_leaf_edge(kv.right_edge().descend());\n                    return ret;\n                }\n                Err(last_edge) => {\n                    let next_level = last_edge.into_node().ascend().ok();\n                    cur_handle = unwrap_unchecked(next_level);\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\nimpl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> {\n    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {\n        if self.front == self.back {\n            None\n        } else {\n            unsafe { Some(self.next_back_unchecked()) }\n        }\n    }\n}\n\nimpl<'a, K, V> Range<'a, K, V> {\n    unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) {\n        let handle = self.back;\n\n        let mut cur_handle = match handle.left_kv() {\n            Ok(kv) => {\n                let ret = kv.into_kv();\n                self.back = kv.left_edge();\n                return ret;\n            }\n            Err(last_edge) => {\n                let next_level = last_edge.into_node().ascend().ok();\n                unwrap_unchecked(next_level)\n            }\n        };\n\n        loop {\n            match cur_handle.left_kv() {\n                Ok(kv) => {\n                    let ret = kv.into_kv();\n                    self.back = last_leaf_edge(kv.left_edge().descend());\n                    return ret;\n                }\n                Err(last_edge) => {\n                    let next_level = last_edge.into_node().ascend().ok();\n                    cur_handle = unwrap_unchecked(next_level);\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Range<'a, K, V> {}\n\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\nimpl<'a, K, V> Clone for Range<'a, K, V> {\n    fn clone(&self) -> Range<'a, K, V> {\n        Range {\n            front: self.front,\n            back: self.back,\n        }\n    }\n}\n\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\nimpl<'a, K, V> Iterator for RangeMut<'a, K, V> {\n    type Item = (&'a K, &'a mut V);\n\n    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {\n        if self.front == self.back {\n            None\n        } else {\n            unsafe { Some(self.next_unchecked()) }\n        }\n    }\n}\n\nimpl<'a, K, V> RangeMut<'a, K, V> {\n    unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) {\n        let handle = ptr::read(&self.front);\n\n        let mut cur_handle = match handle.right_kv() {\n            Ok(kv) => {\n                let (k, v) = ptr::read(&kv).into_kv_mut();\n                self.front = kv.right_edge();\n                return (k, v);\n            }\n            Err(last_edge) => {\n                let next_level = last_edge.into_node().ascend().ok();\n                unwrap_unchecked(next_level)\n            }\n        };\n\n        loop {\n            match cur_handle.right_kv() {\n                Ok(kv) => {\n                    let (k, v) = ptr::read(&kv).into_kv_mut();\n                    self.front = first_leaf_edge(kv.right_edge().descend());\n                    return (k, v);\n                }\n                Err(last_edge) => {\n                    let next_level = last_edge.into_node().ascend().ok();\n                    cur_handle = unwrap_unchecked(next_level);\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"btree_range\", since = \"1.17.0\")]\nimpl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {\n    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {\n        if self.front == self.back {\n            None\n        } else {\n            unsafe { Some(self.next_back_unchecked()) }\n        }\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for RangeMut<'a, K, V> {}\n\nimpl<'a, K, V> RangeMut<'a, K, V> {\n    unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) {\n        let handle = ptr::read(&self.back);\n\n        let mut cur_handle = match handle.left_kv() {\n            Ok(kv) => {\n                let (k, v) = ptr::read(&kv).into_kv_mut();\n                self.back = kv.left_edge();\n                return (k, v);\n            }\n            Err(last_edge) => {\n                let next_level = last_edge.into_node().ascend().ok();\n                unwrap_unchecked(next_level)\n            }\n        };\n\n        loop {\n            match cur_handle.left_kv() {\n                Ok(kv) => {\n                    let (k, v) = ptr::read(&kv).into_kv_mut();\n                    self.back = last_leaf_edge(kv.left_edge().descend());\n                    return (k, v);\n                }\n                Err(last_edge) => {\n                    let next_level = last_edge.into_node().ascend().ok();\n                    cur_handle = unwrap_unchecked(next_level);\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {\n    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V> {\n        let mut map = BTreeMap::new();\n        map.extend(iter);\n        map\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {\n    #[inline]\n    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {\n        for (k, v) in iter {\n            self.insert(k, v);\n        }\n    }\n}\n\n#[stable(feature = \"extend_ref\", since = \"1.2.0\")]\nimpl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap<K, V> {\n    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {\n        self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Hash, V: Hash> Hash for BTreeMap<K, V> {\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        for elt in self {\n            elt.hash(state);\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Ord, V> Default for BTreeMap<K, V> {\n    /// Creates an empty `BTreeMap<K, V>`.\n    fn default() -> BTreeMap<K, V> {\n        BTreeMap::new()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {\n    fn eq(&self, other: &BTreeMap<K, V>) -> bool {\n        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Eq, V: Eq> Eq for BTreeMap<K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: PartialOrd, V: PartialOrd> PartialOrd for BTreeMap<K, V> {\n    #[inline]\n    fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering> {\n        self.iter().partial_cmp(other.iter())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {\n    #[inline]\n    fn cmp(&self, other: &BTreeMap<K, V>) -> Ordering {\n        self.iter().cmp(other.iter())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_map().entries(self.iter()).finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>\n    where K: Borrow<Q>,\n          Q: Ord\n{\n    type Output = V;\n\n    /// Returns a reference to the value corresponding to the supplied key.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the key is not present in the `BTreeMap`.\n    #[inline]\n    fn index(&self, key: &Q) -> &V {\n        self.get(key).expect(\"no entry found for key\")\n    }\n}\n\nfn first_leaf_edge<BorrowType, K, V>\n    (mut node: NodeRef<BorrowType, K, V, marker::LeafOrInternal>)\n     -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge> {\n    loop {\n        match node.force() {\n            Leaf(leaf) => return leaf.first_edge(),\n            Internal(internal) => {\n                node = internal.first_edge().descend();\n            }\n        }\n    }\n}\n\nfn last_leaf_edge<BorrowType, K, V>\n    (mut node: NodeRef<BorrowType, K, V, marker::LeafOrInternal>)\n     -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge> {\n    loop {\n        match node.force() {\n            Leaf(leaf) => return leaf.last_edge(),\n            Internal(internal) => {\n                node = internal.last_edge().descend();\n            }\n        }\n    }\n}\n\nfn range_search<BorrowType, K, V, Q: ?Sized, R: RangeBounds<Q>>(\n    root1: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,\n    root2: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,\n    range: R\n)-> (Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>,\n     Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>)\n        where Q: Ord, K: Borrow<Q>\n{\n    match (range.start_bound(), range.end_bound()) {\n        (Excluded(s), Excluded(e)) if s==e =>\n            panic!(\"range start and end are equal and excluded in BTreeMap\"),\n        (Included(s), Included(e)) |\n        (Included(s), Excluded(e)) |\n        (Excluded(s), Included(e)) |\n        (Excluded(s), Excluded(e)) if s>e =>\n            panic!(\"range start is greater than range end in BTreeMap\"),\n        _ => {},\n    };\n\n    let mut min_node = root1;\n    let mut max_node = root2;\n    let mut min_found = false;\n    let mut max_found = false;\n    let mut diverged = false;\n\n    loop {\n        let min_edge = match (min_found, range.start_bound()) {\n            (false, Included(key)) => match search::search_linear(&min_node, key) {\n                (i, true) => { min_found = true; i },\n                (i, false) => i,\n            },\n            (false, Excluded(key)) => match search::search_linear(&min_node, key) {\n                (i, true) => { min_found = true; i+1 },\n                (i, false) => i,\n            },\n            (_, Unbounded) => 0,\n            (true, Included(_)) => min_node.keys().len(),\n            (true, Excluded(_)) => 0,\n        };\n\n        let max_edge = match (max_found, range.end_bound()) {\n            (false, Included(key)) => match search::search_linear(&max_node, key) {\n                (i, true) => { max_found = true; i+1 },\n                (i, false) => i,\n            },\n            (false, Excluded(key)) => match search::search_linear(&max_node, key) {\n                (i, true) => { max_found = true; i },\n                (i, false) => i,\n            },\n            (_, Unbounded) => max_node.keys().len(),\n            (true, Included(_)) => 0,\n            (true, Excluded(_)) => max_node.keys().len(),\n        };\n\n        if !diverged {\n            if max_edge < min_edge { panic!(\"Ord is ill-defined in BTreeMap range\") }\n            if min_edge != max_edge { diverged = true; }\n        }\n\n        let front = Handle::new_edge(min_node, min_edge);\n        let back = Handle::new_edge(max_node, max_edge);\n        match (front.force(), back.force()) {\n            (Leaf(f), Leaf(b)) => {\n                return (f, b);\n            },\n            (Internal(min_int), Internal(max_int)) => {\n                min_node = min_int.descend();\n                max_node = max_int.descend();\n            },\n            _ => unreachable!(\"BTreeMap has different depths\"),\n        };\n    }\n}\n\n#[inline(always)]\nunsafe fn unwrap_unchecked<T>(val: Option<T>) -> T {\n    val.unwrap_or_else(|| {\n        if cfg!(debug_assertions) {\n            panic!(\"'unchecked' unwrap on None in BTreeMap\");\n        } else {\n            intrinsics::unreachable();\n        }\n    })\n}\n\nimpl<K, V> BTreeMap<K, V> {\n    /// Gets an iterator over the entries of the map, sorted by key.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(3, \"c\");\n    /// map.insert(2, \"b\");\n    /// map.insert(1, \"a\");\n    ///\n    /// for (key, value) in map.iter() {\n    ///     println!(\"{}: {}\", key, value);\n    /// }\n    ///\n    /// let (first_key, first_value) = map.iter().next().unwrap();\n    /// assert_eq!((*first_key, *first_value), (1, \"a\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter(&self) -> Iter<K, V> {\n        Iter {\n            range: Range {\n                front: first_leaf_edge(self.root.as_ref()),\n                back: last_leaf_edge(self.root.as_ref()),\n            },\n            length: self.length,\n        }\n    }\n\n    /// Gets a mutable iterator over the entries of the map, sorted by key.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map = BTreeMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// // add 10 to the value if the key isn't \"a\"\n    /// for (key, value) in map.iter_mut() {\n    ///     if key != &\"a\" {\n    ///         *value += 10;\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter_mut(&mut self) -> IterMut<K, V> {\n        let root1 = self.root.as_mut();\n        let root2 = unsafe { ptr::read(&root1) };\n        IterMut {\n            range: RangeMut {\n                front: first_leaf_edge(root1),\n                back: last_leaf_edge(root2),\n                _marker: PhantomData,\n            },\n            length: self.length,\n        }\n    }\n\n    /// Gets an iterator over the keys of the map, in sorted order.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(2, \"b\");\n    /// a.insert(1, \"a\");\n    ///\n    /// let keys: Vec<_> = a.keys().cloned().collect();\n    /// assert_eq!(keys, [1, 2]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {\n        Keys { inner: self.iter() }\n    }\n\n    /// Gets an iterator over the values of the map, in order by key.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(1, \"hello\");\n    /// a.insert(2, \"goodbye\");\n    ///\n    /// let values: Vec<&str> = a.values().cloned().collect();\n    /// assert_eq!(values, [\"hello\", \"goodbye\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn values<'a>(&'a self) -> Values<'a, K, V> {\n        Values { inner: self.iter() }\n    }\n\n    /// Gets a mutable iterator over the values of the map, in order by key.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// a.insert(1, String::from(\"hello\"));\n    /// a.insert(2, String::from(\"goodbye\"));\n    ///\n    /// for value in a.values_mut() {\n    ///     value.push_str(\"!\");\n    /// }\n    ///\n    /// let values: Vec<String> = a.values().cloned().collect();\n    /// assert_eq!(values, [String::from(\"hello!\"),\n    ///                     String::from(\"goodbye!\")]);\n    /// ```\n    #[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\n    pub fn values_mut(&mut self) -> ValuesMut<K, V> {\n        ValuesMut { inner: self.iter_mut() }\n    }\n\n    /// Returns the number of elements in the map.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// assert_eq!(a.len(), 0);\n    /// a.insert(1, \"a\");\n    /// assert_eq!(a.len(), 1);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn len(&self) -> usize {\n        self.length\n    }\n\n    /// Returns `true` if the map contains no elements.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut a = BTreeMap::new();\n    /// assert!(a.is_empty());\n    /// a.insert(1, \"a\");\n    /// assert!(!a.is_empty());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n}\n\nimpl<'a, K: Ord, V> Entry<'a, K, V> {\n    /// Ensures a value is in the entry by inserting the default if empty, and returns\n    /// a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or_insert(self, default: V) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(default),\n        }\n    }\n\n    /// Ensures a value is in the entry by inserting the result of the default function if empty,\n    /// and returns a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, String> = BTreeMap::new();\n    /// let s = \"hoho\".to_string();\n    ///\n    /// map.entry(\"poneyland\").or_insert_with(|| s);\n    ///\n    /// assert_eq!(map[\"poneyland\"], \"hoho\".to_string());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(default()),\n        }\n    }\n\n    /// Returns a reference to this entry's key.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        match *self {\n            Occupied(ref entry) => entry.key(),\n            Vacant(ref entry) => entry.key(),\n        }\n    }\n\n    /// Provides in-place mutable access to an occupied entry before any\n    /// potential inserts into the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    ///\n    /// map.entry(\"poneyland\")\n    ///    .and_modify(|e| { *e += 1 })\n    ///    .or_insert(42);\n    /// assert_eq!(map[\"poneyland\"], 42);\n    ///\n    /// map.entry(\"poneyland\")\n    ///    .and_modify(|e| { *e += 1 })\n    ///    .or_insert(42);\n    /// assert_eq!(map[\"poneyland\"], 43);\n    /// ```\n    #[stable(feature = \"entry_and_modify\", since = \"1.26.0\")]\n    pub fn and_modify<F>(self, f: F) -> Self\n        where F: FnOnce(&mut V)\n    {\n        match self {\n            Occupied(mut entry) => {\n                f(entry.get_mut());\n                Occupied(entry)\n            },\n            Vacant(entry) => Vacant(entry),\n        }\n    }\n}\n\nimpl<'a, K: Ord, V: Default> Entry<'a, K, V> {\n    #[stable(feature = \"entry_or_default\", since = \"1.28.0\")]\n    /// Ensures a value is in the entry by inserting the default value if empty,\n    /// and returns a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # fn main() {\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, Option<usize>> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_default();\n    ///\n    /// assert_eq!(map[\"poneyland\"], None);\n    /// # }\n    /// ```\n    pub fn or_default(self) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(Default::default()),\n        }\n    }\n\n}\n\nimpl<'a, K: Ord, V> VacantEntry<'a, K, V> {\n    /// Gets a reference to the key that would be used when inserting a value\n    /// through the VacantEntry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        &self.key\n    }\n\n    /// Take ownership of the key.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    ///\n    /// if let Entry::Vacant(v) = map.entry(\"poneyland\") {\n    ///     v.into_key();\n    /// }\n    /// ```\n    #[stable(feature = \"map_entry_recover_keys2\", since = \"1.12.0\")]\n    pub fn into_key(self) -> K {\n        self.key\n    }\n\n    /// Sets the value of the entry with the `VacantEntry`'s key,\n    /// and returns a mutable reference to it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();\n    ///\n    /// // count the number of occurrences of letters in the vec\n    /// for x in vec![\"a\",\"b\",\"a\",\"c\",\"a\",\"b\"] {\n    ///     *count.entry(x).or_insert(0) += 1;\n    /// }\n    ///\n    /// assert_eq!(count[\"a\"], 3);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(self, value: V) -> &'a mut V {\n        *self.length += 1;\n\n        let out_ptr;\n\n        let mut ins_k;\n        let mut ins_v;\n        let mut ins_edge;\n\n        let mut cur_parent = match self.handle.insert(self.key, value) {\n            (Fit(handle), _) => return handle.into_kv_mut().1,\n            (Split(left, k, v, right), ptr) => {\n                ins_k = k;\n                ins_v = v;\n                ins_edge = right;\n                out_ptr = ptr;\n                left.ascend().map_err(|n| n.into_root_mut())\n            }\n        };\n\n        loop {\n            match cur_parent {\n                Ok(parent) => {\n                    match parent.insert(ins_k, ins_v, ins_edge) {\n                        Fit(_) => return unsafe { &mut *out_ptr },\n                        Split(left, k, v, right) => {\n                            ins_k = k;\n                            ins_v = v;\n                            ins_edge = right;\n                            cur_parent = left.ascend().map_err(|n| n.into_root_mut());\n                        }\n                    }\n                }\n                Err(root) => {\n                    root.push_level().push(ins_k, ins_v, ins_edge);\n                    return unsafe { &mut *out_ptr };\n                }\n            }\n        }\n    }\n}\n\nimpl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {\n    /// Gets a reference to the key in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        self.handle.reborrow().into_kv().0\n    }\n\n    /// Take ownership of the key and value from the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     // We delete the entry from the map.\n    ///     o.remove_entry();\n    /// }\n    ///\n    /// // If now try to get the value, it will panic:\n    /// // println!(\"{}\", map[\"poneyland\"]);\n    /// ```\n    #[stable(feature = \"map_entry_recover_keys2\", since = \"1.12.0\")]\n    pub fn remove_entry(self) -> (K, V) {\n        self.remove_kv()\n    }\n\n    /// Gets a reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.get(), &12);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get(&self) -> &V {\n        self.handle.reborrow().into_kv().1\n    }\n\n    /// Gets a mutable reference to the value in the entry.\n    ///\n    /// If you need a reference to the `OccupiedEntry` which may outlive the\n    /// destruction of the `Entry` value, see [`into_mut`].\n    ///\n    /// [`into_mut`]: #method.into_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    /// if let Entry::Occupied(mut o) = map.entry(\"poneyland\") {\n    ///     *o.get_mut() += 10;\n    ///     assert_eq!(*o.get(), 22);\n    ///\n    ///     // We can use the same Entry multiple times.\n    ///     *o.get_mut() += 2;\n    /// }\n    /// assert_eq!(map[\"poneyland\"], 24);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut V {\n        self.handle.kv_mut().1\n    }\n\n    /// Converts the entry into a mutable reference to its value.\n    ///\n    /// If you need multiple references to the `OccupiedEntry`, see [`get_mut`].\n    ///\n    /// [`get_mut`]: #method.get_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     *o.into_mut() += 10;\n    /// }\n    /// assert_eq!(map[\"poneyland\"], 22);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_mut(self) -> &'a mut V {\n        self.handle.into_kv_mut().1\n    }\n\n    /// Sets the value of the entry with the `OccupiedEntry`'s key,\n    /// and returns the entry's old value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(mut o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.insert(15), 12);\n    /// }\n    /// assert_eq!(map[\"poneyland\"], 15);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, value: V) -> V {\n        mem::replace(self.get_mut(), value)\n    }\n\n    /// Takes the value of the entry out of the map, and returns it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::BTreeMap;\n    /// use std::collections::btree_map::Entry;\n    ///\n    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.remove(), 12);\n    /// }\n    /// // If we try to get \"poneyland\"'s value, it'll panic:\n    /// // println!(\"{}\", map[\"poneyland\"]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove(self) -> V {\n        self.remove_kv().1\n    }\n\n    fn remove_kv(self) -> (K, V) {\n        *self.length -= 1;\n\n        let (small_leaf, old_key, old_val) = match self.handle.force() {\n            Leaf(leaf) => {\n                let (hole, old_key, old_val) = leaf.remove();\n                (hole.into_node(), old_key, old_val)\n            }\n            Internal(mut internal) => {\n                let key_loc = internal.kv_mut().0 as *mut K;\n                let val_loc = internal.kv_mut().1 as *mut V;\n\n                let to_remove = first_leaf_edge(internal.right_edge().descend()).right_kv().ok();\n                let to_remove = unsafe { unwrap_unchecked(to_remove) };\n\n                let (hole, key, val) = to_remove.remove();\n\n                let old_key = unsafe { mem::replace(&mut *key_loc, key) };\n                let old_val = unsafe { mem::replace(&mut *val_loc, val) };\n\n                (hole.into_node(), old_key, old_val)\n            }\n        };\n\n        // Handle underflow\n        let mut cur_node = small_leaf.forget_type();\n        while cur_node.len() < node::CAPACITY / 2 {\n            match handle_underfull_node(cur_node) {\n                AtRoot => break,\n                EmptyParent(_) => unreachable!(),\n                Merged(parent) => {\n                    if parent.len() == 0 {\n                        // We must be at the root\n                        parent.into_root_mut().pop_level();\n                        break;\n                    } else {\n                        cur_node = parent.forget_type();\n                    }\n                }\n                Stole(_) => break,\n            }\n        }\n\n        (old_key, old_val)\n    }\n}\n\nenum UnderflowResult<'a, K, V> {\n    AtRoot,\n    EmptyParent(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),\n    Merged(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),\n    Stole(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),\n}\n\nfn handle_underfull_node<'a, K, V>(node: NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>)\n                                   -> UnderflowResult<'a, K, V> {\n    let parent = if let Ok(parent) = node.ascend() {\n        parent\n    } else {\n        return AtRoot;\n    };\n\n    let (is_left, mut handle) = match parent.left_kv() {\n        Ok(left) => (true, left),\n        Err(parent) => {\n            match parent.right_kv() {\n                Ok(right) => (false, right),\n                Err(parent) => {\n                    return EmptyParent(parent.into_node());\n                }\n            }\n        }\n    };\n\n    if handle.can_merge() {\n        Merged(handle.merge().into_node())\n    } else {\n        if is_left {\n            handle.steal_left();\n        } else {\n            handle.steal_right();\n        }\n        Stole(handle.into_node())\n    }\n}\n\nimpl<K: Ord, V, I: Iterator<Item = (K, V)>> Iterator for MergeIter<K, V, I> {\n    type Item = (K, V);\n\n    fn next(&mut self) -> Option<(K, V)> {\n        let res = match (self.left.peek(), self.right.peek()) {\n            (Some(&(ref left_key, _)), Some(&(ref right_key, _))) => left_key.cmp(right_key),\n            (Some(_), None) => Ordering::Less,\n            (None, Some(_)) => Ordering::Greater,\n            (None, None) => return None,\n        };\n\n        // Check which elements comes first and only advance the corresponding iterator.\n        // If two keys are equal, take the value from `right`.\n        match res {\n            Ordering::Less => self.left.next(),\n            Ordering::Greater => self.right.next(),\n            Ordering::Equal => {\n                self.left.next();\n                self.right.next()\n            }\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n// This is an attempt at an implementation following the ideal\n//\n// ```\n// struct BTreeMap<K, V> {\n//     height: usize,\n//     root: Option<Box<Node<K, V, height>>>\n// }\n//\n// struct Node<K, V, height: usize> {\n//     keys: [K; 2 * B - 1],\n//     vals: [V; 2 * B - 1],\n//     edges: if height > 0 {\n//         [Box<Node<K, V, height - 1>>; 2 * B]\n//     } else { () },\n//     parent: *const Node<K, V, height + 1>,\n//     parent_idx: u16,\n//     len: u16,\n// }\n// ```\n//\n// Since Rust doesn't actually have dependent types and polymorphic recursion,\n// we make do with lots of unsafety.\n\n// A major goal of this module is to avoid complexity by treating the tree as a generic (if\n// weirdly shaped) container and avoiding dealing with most of the B-Tree invariants. As such,\n// this module doesn't care whether the entries are sorted, which nodes can be underfull, or\n// even what underfull means. However, we do rely on a few invariants:\n//\n// - Trees must have uniform depth/height. This means that every path down to a leaf from a\n//   given node has exactly the same length.\n// - A node of length `n` has `n` keys, `n` values, and (in an internal node) `n + 1` edges.\n//   This implies that even an empty internal node has at least one edge.\n\nuse core::marker::PhantomData;\nuse core::mem::{self, MaybeUninit};\nuse core::ptr::{self, Unique, NonNull};\nuse core::slice;\n\nuse alloc::{Global, Alloc, Layout};\nuse boxed::Box;\n\nconst B: usize = 6;\npub const MIN_LEN: usize = B - 1;\npub const CAPACITY: usize = 2 * B - 1;\n\n/// The underlying representation of leaf nodes. Note that it is often unsafe to actually store\n/// these, since only the first `len` keys and values are assumed to be initialized. As such,\n/// these should always be put behind pointers, and specifically behind `BoxedNode` in the owned\n/// case.\n///\n/// We put the metadata first so that its position is the same for every `K` and `V`, in order\n/// to statically allocate a single dummy node to avoid allocations. This struct is `repr(C)` to\n/// prevent them from being reordered.\n#[repr(C)]\nstruct LeafNode<K, V> {\n    /// We use `*const` as opposed to `*mut` so as to be covariant in `K` and `V`.\n    /// This either points to an actual node or is null.\n    parent: *const InternalNode<K, V>,\n\n    /// This node's index into the parent node's `edges` array.\n    /// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.\n    /// This is only guaranteed to be initialized when `parent` is nonnull.\n    parent_idx: MaybeUninit<u16>,\n\n    /// The number of keys and values this node stores.\n    ///\n    /// This next to `parent_idx` to encourage the compiler to join `len` and\n    /// `parent_idx` into the same 32-bit word, reducing space overhead.\n    len: u16,\n\n    /// The arrays storing the actual data of the node. Only the first `len` elements of each\n    /// array are initialized and valid.\n    keys: MaybeUninit<[K; CAPACITY]>,\n    vals: MaybeUninit<[V; CAPACITY]>,\n}\n\nimpl<K, V> LeafNode<K, V> {\n    /// Creates a new `LeafNode`. Unsafe because all nodes should really be hidden behind\n    /// `BoxedNode`, preventing accidental dropping of uninitialized keys and values.\n    unsafe fn new() -> Self {\n        LeafNode {\n            // As a general policy, we leave fields uninitialized if they can be, as this should\n            // be both slightly faster and easier to track in Valgrind.\n            keys: MaybeUninit::uninitialized(),\n            vals: MaybeUninit::uninitialized(),\n            parent: ptr::null(),\n            parent_idx: MaybeUninit::uninitialized(),\n            len: 0\n        }\n    }\n\n    fn is_shared_root(&self) -> bool {\n        ptr::eq(self, &EMPTY_ROOT_NODE as *const _ as *const _)\n    }\n}\n\n// We need to implement Sync here in order to make a static instance.\nunsafe impl Sync for LeafNode<(), ()> {}\n\n// An empty node used as a placeholder for the root node, to avoid allocations.\n// We use () in order to save space, since no operation on an empty tree will\n// ever take a pointer past the first key.\nstatic EMPTY_ROOT_NODE: LeafNode<(), ()> = LeafNode {\n    parent: ptr::null(),\n    parent_idx: MaybeUninit::uninitialized(),\n    len: 0,\n    keys: MaybeUninit::uninitialized(),\n    vals: MaybeUninit::uninitialized(),\n};\n\n/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden\n/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an\n/// `InternalNode` can be directly casted to a pointer to the underlying `LeafNode` portion of the\n/// node, allowing code to act on leaf and internal nodes generically without having to even check\n/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`.\n#[repr(C)]\nstruct InternalNode<K, V> {\n    data: LeafNode<K, V>,\n\n    /// The pointers to the children of this node. `len + 1` of these are considered\n    /// initialized and valid.\n    edges: [BoxedNode<K, V>; 2 * B],\n}\n\nimpl<K, V> InternalNode<K, V> {\n    /// Creates a new `InternalNode`.\n    ///\n    /// This is unsafe for two reasons. First, it returns an `InternalNode` by value, risking\n    /// dropping of uninitialized fields. Second, an invariant of internal nodes is that `len + 1`\n    /// edges are initialized and valid, meaning that even when the node is empty (having a\n    /// `len` of 0), there must be one initialized and valid edge. This function does not set up\n    /// such an edge.\n    unsafe fn new() -> Self {\n        InternalNode {\n            data: LeafNode::new(),\n            edges: mem::uninitialized()\n        }\n    }\n}\n\n/// An owned pointer to a node. This basically is either `Box<LeafNode<K, V>>` or\n/// `Box<InternalNode<K, V>>`. However, it contains no information as to which of the two types\n/// of nodes is actually behind the box, and, partially due to this lack of information, has no\n/// destructor.\nstruct BoxedNode<K, V> {\n    ptr: Unique<LeafNode<K, V>>\n}\n\nimpl<K, V> BoxedNode<K, V> {\n    fn from_leaf(node: Box<LeafNode<K, V>>) -> Self {\n        BoxedNode { ptr: Box::into_unique(node) }\n    }\n\n    fn from_internal(node: Box<InternalNode<K, V>>) -> Self {\n        unsafe {\n            BoxedNode { ptr: Unique::new_unchecked(Box::into_raw(node) as *mut LeafNode<K, V>) }\n        }\n    }\n\n    unsafe fn from_ptr(ptr: NonNull<LeafNode<K, V>>) -> Self {\n        BoxedNode { ptr: Unique::from(ptr) }\n    }\n\n    fn as_ptr(&self) -> NonNull<LeafNode<K, V>> {\n        NonNull::from(self.ptr)\n    }\n}\n\n/// An owned tree. Note that despite being owned, this does not have a destructor,\n/// and must be cleaned up manually.\npub struct Root<K, V> {\n    node: BoxedNode<K, V>,\n    height: usize\n}\n\nunsafe impl<K: Sync, V: Sync> Sync for Root<K, V> { }\nunsafe impl<K: Send, V: Send> Send for Root<K, V> { }\n\nimpl<K, V> Root<K, V> {\n    pub fn is_shared_root(&self) -> bool {\n        self.as_ref().is_shared_root()\n    }\n\n    pub fn shared_empty_root() -> Self {\n        Root {\n            node: unsafe {\n                BoxedNode::from_ptr(NonNull::new_unchecked(\n                    &EMPTY_ROOT_NODE as *const _ as *const LeafNode<K, V> as *mut _\n                ))\n            },\n            height: 0,\n        }\n    }\n\n    pub fn new_leaf() -> Self {\n        Root {\n            node: BoxedNode::from_leaf(Box::new(unsafe { LeafNode::new() })),\n            height: 0\n        }\n    }\n\n    pub fn as_ref(&self)\n            -> NodeRef<marker::Immut, K, V, marker::LeafOrInternal> {\n        NodeRef {\n            height: self.height,\n            node: self.node.as_ptr(),\n            root: self as *const _ as *mut _,\n            _marker: PhantomData,\n        }\n    }\n\n    pub fn as_mut(&mut self)\n            -> NodeRef<marker::Mut, K, V, marker::LeafOrInternal> {\n        NodeRef {\n            height: self.height,\n            node: self.node.as_ptr(),\n            root: self as *mut _,\n            _marker: PhantomData,\n        }\n    }\n\n    pub fn into_ref(self)\n            -> NodeRef<marker::Owned, K, V, marker::LeafOrInternal> {\n        NodeRef {\n            height: self.height,\n            node: self.node.as_ptr(),\n            root: ptr::null_mut(), // FIXME: Is there anything better to do here?\n            _marker: PhantomData,\n        }\n    }\n\n    /// Adds a new internal node with a single edge, pointing to the previous root, and make that\n    /// new node the root. This increases the height by 1 and is the opposite of `pop_level`.\n    pub fn push_level(&mut self)\n            -> NodeRef<marker::Mut, K, V, marker::Internal> {\n        debug_assert!(!self.is_shared_root());\n        let mut new_node = Box::new(unsafe { InternalNode::new() });\n        new_node.edges[0] = unsafe { BoxedNode::from_ptr(self.node.as_ptr()) };\n\n        self.node = BoxedNode::from_internal(new_node);\n        self.height += 1;\n\n        let mut ret = NodeRef {\n            height: self.height,\n            node: self.node.as_ptr(),\n            root: self as *mut _,\n            _marker: PhantomData\n        };\n\n        unsafe {\n            ret.reborrow_mut().first_edge().correct_parent_link();\n        }\n\n        ret\n    }\n\n    /// Removes the root node, using its first child as the new root. This cannot be called when\n    /// the tree consists only of a leaf node. As it is intended only to be called when the root\n    /// has only one edge, no cleanup is done on any of the other children are elements of the root.\n    /// This decreases the height by 1 and is the opposite of `push_level`.\n    pub fn pop_level(&mut self) {\n        debug_assert!(self.height > 0);\n\n        let top = self.node.ptr;\n\n        self.node = unsafe {\n            BoxedNode::from_ptr(self.as_mut()\n                                    .cast_unchecked::<marker::Internal>()\n                                    .first_edge()\n                                    .descend()\n                                    .node)\n        };\n        self.height -= 1;\n        self.as_mut().as_leaf_mut().parent = ptr::null();\n\n        unsafe {\n            Global.dealloc(NonNull::from(top).cast(), Layout::new::<InternalNode<K, V>>());\n        }\n    }\n}\n\n// N.B. `NodeRef` is always covariant in `K` and `V`, even when the `BorrowType`\n// is `Mut`. This is technically wrong, but cannot result in any unsafety due to\n// internal use of `NodeRef` because we stay completely generic over `K` and `V`.\n// However, whenever a public type wraps `NodeRef`, make sure that it has the\n// correct variance.\n/// A reference to a node.\n///\n/// This type has a number of parameters that controls how it acts:\n/// - `BorrowType`: This can be `Immut<'a>` or `Mut<'a>` for some `'a` or `Owned`.\n///    When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`,\n///    when this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,\n///    and when this is `Owned`, the `NodeRef` acts roughly like `Box<Node>`.\n/// - `K` and `V`: These control what types of things are stored in the nodes.\n/// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is\n///   `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the\n///   `NodeRef` points to an internal node, and when this is `LeafOrInternal` the\n///   `NodeRef` could be pointing to either type of node.\npub struct NodeRef<BorrowType, K, V, Type> {\n    height: usize,\n    node: NonNull<LeafNode<K, V>>,\n    // This is null unless the borrow type is `Mut`\n    root: *const Root<K, V>,\n    _marker: PhantomData<(BorrowType, Type)>\n}\n\nimpl<'a, K: 'a, V: 'a, Type> Copy for NodeRef<marker::Immut<'a>, K, V, Type> { }\nimpl<'a, K: 'a, V: 'a, Type> Clone for NodeRef<marker::Immut<'a>, K, V, Type> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\nunsafe impl<BorrowType, K: Sync, V: Sync, Type> Sync\n    for NodeRef<BorrowType, K, V, Type> { }\n\nunsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send\n   for NodeRef<marker::Immut<'a>, K, V, Type> { }\nunsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send\n   for NodeRef<marker::Mut<'a>, K, V, Type> { }\nunsafe impl<K: Send, V: Send, Type> Send\n   for NodeRef<marker::Owned, K, V, Type> { }\n\nimpl<BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Internal> {\n    fn as_internal(&self) -> &InternalNode<K, V> {\n        unsafe {\n            &*(self.node.as_ptr() as *mut InternalNode<K, V>)\n        }\n    }\n}\n\nimpl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Internal> {\n    fn as_internal_mut(&mut self) -> &mut InternalNode<K, V> {\n        unsafe {\n            &mut *(self.node.as_ptr() as *mut InternalNode<K, V>)\n        }\n    }\n}\n\n\nimpl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {\n    /// Finds the length of the node. This is the number of keys or values. In an\n    /// internal node, the number of edges is `len() + 1`.\n    pub fn len(&self) -> usize {\n        self.as_leaf().len as usize\n    }\n\n    /// Returns the height of this node in the whole tree. Zero height denotes the\n    /// leaf level.\n    pub fn height(&self) -> usize {\n        self.height\n    }\n\n    /// Removes any static information about whether this node is a `Leaf` or an\n    /// `Internal` node.\n    pub fn forget_type(self) -> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {\n        NodeRef {\n            height: self.height,\n            node: self.node,\n            root: self.root,\n            _marker: PhantomData\n        }\n    }\n\n    /// Temporarily takes out another, immutable reference to the same node.\n    fn reborrow<'a>(&'a self) -> NodeRef<marker::Immut<'a>, K, V, Type> {\n        NodeRef {\n            height: self.height,\n            node: self.node,\n            root: self.root,\n            _marker: PhantomData\n        }\n    }\n\n    fn as_leaf(&self) -> &LeafNode<K, V> {\n        unsafe {\n            self.node.as_ref()\n        }\n    }\n\n    pub fn is_shared_root(&self) -> bool {\n        self.as_leaf().is_shared_root()\n    }\n\n    pub fn keys(&self) -> &[K] {\n        self.reborrow().into_key_slice()\n    }\n\n    fn vals(&self) -> &[V] {\n        self.reborrow().into_val_slice()\n    }\n\n    /// Finds the parent of the current node. Returns `Ok(handle)` if the current\n    /// node actually has a parent, where `handle` points to the edge of the parent\n    /// that points to the current node. Returns `Err(self)` if the current node has\n    /// no parent, giving back the original `NodeRef`.\n    ///\n    /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should\n    /// both, upon success, do nothing.\n    pub fn ascend(self) -> Result<\n        Handle<\n            NodeRef<\n                BorrowType,\n                K, V,\n                marker::Internal\n            >,\n            marker::Edge\n        >,\n        Self\n    > {\n        let parent_as_leaf = self.as_leaf().parent as *const LeafNode<K, V>;\n        if let Some(non_zero) = NonNull::new(parent_as_leaf as *mut _) {\n            Ok(Handle {\n                node: NodeRef {\n                    height: self.height + 1,\n                    node: non_zero,\n                    root: self.root,\n                    _marker: PhantomData\n                },\n                idx: unsafe { usize::from(*self.as_leaf().parent_idx.get_ref()) },\n                _marker: PhantomData\n            })\n        } else {\n            Err(self)\n        }\n    }\n\n    pub fn first_edge(self) -> Handle<Self, marker::Edge> {\n        Handle::new_edge(self, 0)\n    }\n\n    pub fn last_edge(self) -> Handle<Self, marker::Edge> {\n        let len = self.len();\n        Handle::new_edge(self, len)\n    }\n\n    /// Note that `self` must be nonempty.\n    pub fn first_kv(self) -> Handle<Self, marker::KV> {\n        debug_assert!(self.len() > 0);\n        Handle::new_kv(self, 0)\n    }\n\n    /// Note that `self` must be nonempty.\n    pub fn last_kv(self) -> Handle<Self, marker::KV> {\n        let len = self.len();\n        debug_assert!(len > 0);\n        Handle::new_kv(self, len - 1)\n    }\n}\n\nimpl<K, V> NodeRef<marker::Owned, K, V, marker::Leaf> {\n    /// Similar to `ascend`, gets a reference to a node's parent node, but also\n    /// deallocate the current node in the process. This is unsafe because the\n    /// current node will still be accessible despite being deallocated.\n    pub unsafe fn deallocate_and_ascend(self) -> Option<\n        Handle<\n            NodeRef<\n                marker::Owned,\n                K, V,\n                marker::Internal\n            >,\n            marker::Edge\n        >\n    > {\n        debug_assert!(!self.is_shared_root());\n        let node = self.node;\n        let ret = self.ascend().ok();\n        Global.dealloc(node.cast(), Layout::new::<LeafNode<K, V>>());\n        ret\n    }\n}\n\nimpl<K, V> NodeRef<marker::Owned, K, V, marker::Internal> {\n    /// Similar to `ascend`, gets a reference to a node's parent node, but also\n    /// deallocate the current node in the process. This is unsafe because the\n    /// current node will still be accessible despite being deallocated.\n    pub unsafe fn deallocate_and_ascend(self) -> Option<\n        Handle<\n            NodeRef<\n                marker::Owned,\n                K, V,\n                marker::Internal\n            >,\n            marker::Edge\n        >\n    > {\n        let node = self.node;\n        let ret = self.ascend().ok();\n        Global.dealloc(node.cast(), Layout::new::<InternalNode<K, V>>());\n        ret\n    }\n}\n\nimpl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {\n    /// Unsafely asserts to the compiler some static information about whether this\n    /// node is a `Leaf`.\n    unsafe fn cast_unchecked<NewType>(&mut self)\n            -> NodeRef<marker::Mut, K, V, NewType> {\n\n        NodeRef {\n            height: self.height,\n            node: self.node,\n            root: self.root,\n            _marker: PhantomData\n        }\n    }\n\n    /// Temporarily takes out another, mutable reference to the same node. Beware, as\n    /// this method is very dangerous, doubly so since it may not immediately appear\n    /// dangerous.\n    ///\n    /// Because mutable pointers can roam anywhere around the tree and can even (through\n    /// `into_root_mut`) mess with the root of the tree, the result of `reborrow_mut`\n    /// can easily be used to make the original mutable pointer dangling, or, in the case\n    /// of a reborrowed handle, out of bounds.\n    // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts\n    // the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.\n    unsafe fn reborrow_mut(&mut self) -> NodeRef<marker::Mut, K, V, Type> {\n        NodeRef {\n            height: self.height,\n            node: self.node,\n            root: self.root,\n            _marker: PhantomData\n        }\n    }\n\n    fn as_leaf_mut(&mut self) -> &mut LeafNode<K, V> {\n        unsafe {\n            self.node.as_mut()\n        }\n    }\n\n    fn keys_mut(&mut self) -> &mut [K] {\n        unsafe { self.reborrow_mut().into_key_slice_mut() }\n    }\n\n    fn vals_mut(&mut self) -> &mut [V] {\n        unsafe { self.reborrow_mut().into_val_slice_mut() }\n    }\n}\n\nimpl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Immut<'a>, K, V, Type> {\n    fn into_key_slice(self) -> &'a [K] {\n        // When taking a pointer to the keys, if our key has a stricter\n        // alignment requirement than the shared root does, then the pointer\n        // would be out of bounds, which LLVM assumes will not happen. If the\n        // alignment is more strict, we need to make an empty slice that doesn't\n        // use an out of bounds pointer.\n        if mem::align_of::<K>() > mem::align_of::<LeafNode<(), ()>>() && self.is_shared_root() {\n            &[]\n        } else {\n            // Here either it's not the root, or the alignment is less strict,\n            // in which case the keys pointer will point \"one-past-the-end\" of\n            // the node, which is allowed by LLVM.\n            unsafe {\n                slice::from_raw_parts(\n                    self.as_leaf().keys.as_ptr() as *const K,\n                    self.len()\n                )\n            }\n        }\n    }\n\n    fn into_val_slice(self) -> &'a [V] {\n        debug_assert!(!self.is_shared_root());\n        unsafe {\n            slice::from_raw_parts(\n                self.as_leaf().vals.as_ptr() as *const V,\n                self.len()\n            )\n        }\n    }\n\n    fn into_slices(self) -> (&'a [K], &'a [V]) {\n        let k = unsafe { ptr::read(&self) };\n        (k.into_key_slice(), self.into_val_slice())\n    }\n}\n\nimpl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Mut<'a>, K, V, Type> {\n    /// Gets a mutable reference to the root itself. This is useful primarily when the\n    /// height of the tree needs to be adjusted. Never call this on a reborrowed pointer.\n    pub fn into_root_mut(self) -> &'a mut Root<K, V> {\n        unsafe {\n            &mut *(self.root as *mut Root<K, V>)\n        }\n    }\n\n    fn into_key_slice_mut(mut self) -> &'a mut [K] {\n        if mem::align_of::<K>() > mem::align_of::<LeafNode<(), ()>>() && self.is_shared_root() {\n            &mut []\n        } else {\n            unsafe {\n                slice::from_raw_parts_mut(\n                    self.as_leaf_mut().keys.get_mut() as *mut [K] as *mut K,\n                    self.len()\n                )\n            }\n        }\n    }\n\n    fn into_val_slice_mut(mut self) -> &'a mut [V] {\n        debug_assert!(!self.is_shared_root());\n        unsafe {\n            slice::from_raw_parts_mut(\n                self.as_leaf_mut().vals.get_mut() as *mut [V] as *mut V,\n                self.len()\n            )\n        }\n    }\n\n    fn into_slices_mut(self) -> (&'a mut [K], &'a mut [V]) {\n        let k = unsafe { ptr::read(&self) };\n        (k.into_key_slice_mut(), self.into_val_slice_mut())\n    }\n}\n\nimpl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Leaf> {\n    /// Adds a key/value pair the end of the node.\n    pub fn push(&mut self, key: K, val: V) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(self.len() < CAPACITY);\n        debug_assert!(!self.is_shared_root());\n\n        let idx = self.len();\n\n        unsafe {\n            ptr::write(self.keys_mut().get_unchecked_mut(idx), key);\n            ptr::write(self.vals_mut().get_unchecked_mut(idx), val);\n        }\n\n        self.as_leaf_mut().len += 1;\n    }\n\n    /// Adds a key/value pair to the beginning of the node.\n    pub fn push_front(&mut self, key: K, val: V) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(self.len() < CAPACITY);\n        debug_assert!(!self.is_shared_root());\n\n        unsafe {\n            slice_insert(self.keys_mut(), 0, key);\n            slice_insert(self.vals_mut(), 0, val);\n        }\n\n        self.as_leaf_mut().len += 1;\n    }\n}\n\nimpl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Internal> {\n    /// Adds a key/value pair and an edge to go to the right of that pair to\n    /// the end of the node.\n    pub fn push(&mut self, key: K, val: V, edge: Root<K, V>) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(edge.height == self.height - 1);\n        debug_assert!(self.len() < CAPACITY);\n\n        let idx = self.len();\n\n        unsafe {\n            ptr::write(self.keys_mut().get_unchecked_mut(idx), key);\n            ptr::write(self.vals_mut().get_unchecked_mut(idx), val);\n            ptr::write(self.as_internal_mut().edges.get_unchecked_mut(idx + 1), edge.node);\n\n            self.as_leaf_mut().len += 1;\n\n            Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link();\n        }\n    }\n\n    fn correct_childrens_parent_links(&mut self, first: usize, after_last: usize) {\n        for i in first..after_last {\n            Handle::new_edge(unsafe { self.reborrow_mut() }, i).correct_parent_link();\n        }\n    }\n\n    fn correct_all_childrens_parent_links(&mut self) {\n        let len = self.len();\n        self.correct_childrens_parent_links(0, len + 1);\n    }\n\n    /// Adds a key/value pair and an edge to go to the left of that pair to\n    /// the beginning of the node.\n    pub fn push_front(&mut self, key: K, val: V, edge: Root<K, V>) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(edge.height == self.height - 1);\n        debug_assert!(self.len() < CAPACITY);\n\n        unsafe {\n            slice_insert(self.keys_mut(), 0, key);\n            slice_insert(self.vals_mut(), 0, val);\n            slice_insert(\n                slice::from_raw_parts_mut(\n                    self.as_internal_mut().edges.as_mut_ptr(),\n                    self.len()+1\n                ),\n                0,\n                edge.node\n            );\n\n            self.as_leaf_mut().len += 1;\n\n            self.correct_all_childrens_parent_links();\n        }\n    }\n}\n\nimpl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {\n    /// Removes a key/value pair from the end of this node. If this is an internal node,\n    /// also removes the edge that was to the right of that pair.\n    pub fn pop(&mut self) -> (K, V, Option<Root<K, V>>) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(self.len() > 0);\n\n        let idx = self.len() - 1;\n\n        unsafe {\n            let key = ptr::read(self.keys().get_unchecked(idx));\n            let val = ptr::read(self.vals().get_unchecked(idx));\n            let edge = match self.reborrow_mut().force() {\n                ForceResult::Leaf(_) => None,\n                ForceResult::Internal(internal) => {\n                    let edge = ptr::read(internal.as_internal().edges.get_unchecked(idx + 1));\n                    let mut new_root = Root { node: edge, height: internal.height - 1 };\n                    new_root.as_mut().as_leaf_mut().parent = ptr::null();\n                    Some(new_root)\n                }\n            };\n\n            self.as_leaf_mut().len -= 1;\n            (key, val, edge)\n        }\n    }\n\n    /// Removes a key/value pair from the beginning of this node. If this is an internal node,\n    /// also removes the edge that was to the left of that pair.\n    pub fn pop_front(&mut self) -> (K, V, Option<Root<K, V>>) {\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(self.len() > 0);\n\n        let old_len = self.len();\n\n        unsafe {\n            let key = slice_remove(self.keys_mut(), 0);\n            let val = slice_remove(self.vals_mut(), 0);\n            let edge = match self.reborrow_mut().force() {\n                ForceResult::Leaf(_) => None,\n                ForceResult::Internal(mut internal) => {\n                    let edge = slice_remove(\n                        slice::from_raw_parts_mut(\n                            internal.as_internal_mut().edges.as_mut_ptr(),\n                            old_len+1\n                        ),\n                        0\n                    );\n\n                    let mut new_root = Root { node: edge, height: internal.height - 1 };\n                    new_root.as_mut().as_leaf_mut().parent = ptr::null();\n\n                    for i in 0..old_len {\n                        Handle::new_edge(internal.reborrow_mut(), i).correct_parent_link();\n                    }\n\n                    Some(new_root)\n                }\n            };\n\n            self.as_leaf_mut().len -= 1;\n\n            (key, val, edge)\n        }\n    }\n\n    fn into_kv_pointers_mut(mut self) -> (*mut K, *mut V) {\n        (\n            self.keys_mut().as_mut_ptr(),\n            self.vals_mut().as_mut_ptr()\n        )\n    }\n}\n\nimpl<BorrowType, K, V> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {\n    /// Checks whether a node is an `Internal` node or a `Leaf` node.\n    pub fn force(self) -> ForceResult<\n        NodeRef<BorrowType, K, V, marker::Leaf>,\n        NodeRef<BorrowType, K, V, marker::Internal>\n    > {\n        if self.height == 0 {\n            ForceResult::Leaf(NodeRef {\n                height: self.height,\n                node: self.node,\n                root: self.root,\n                _marker: PhantomData\n            })\n        } else {\n            ForceResult::Internal(NodeRef {\n                height: self.height,\n                node: self.node,\n                root: self.root,\n                _marker: PhantomData\n            })\n        }\n    }\n}\n\n/// A reference to a specific key/value pair or edge within a node. The `Node` parameter\n/// must be a `NodeRef`, while the `Type` can either be `KV` (signifying a handle on a key/value\n/// pair) or `Edge` (signifying a handle on an edge).\n///\n/// Note that even `Leaf` nodes can have `Edge` handles. Instead of representing a pointer to\n/// a child node, these represent the spaces where child pointers would go between the key/value\n/// pairs. For example, in a node with length 2, there would be 3 possible edge locations - one\n/// to the left of the node, one between the two pairs, and one at the right of the node.\npub struct Handle<Node, Type> {\n    node: Node,\n    idx: usize,\n    _marker: PhantomData<Type>\n}\n\nimpl<Node: Copy, Type> Copy for Handle<Node, Type> { }\n// We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be\n// `Clone`able is when it is an immutable reference and therefore `Copy`.\nimpl<Node: Copy, Type> Clone for Handle<Node, Type> {\n    fn clone(&self) -> Self {\n        *self\n    }\n}\n\nimpl<Node, Type> Handle<Node, Type> {\n    /// Retrieves the node that contains the edge of key/value pair this handle points to.\n    pub fn into_node(self) -> Node {\n        self.node\n    }\n}\n\nimpl<BorrowType, K, V, NodeType> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV> {\n    /// Creates a new handle to a key/value pair in `node`. `idx` must be less than `node.len()`.\n    pub fn new_kv(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {\n        // Necessary for correctness, but in a private module\n        debug_assert!(idx < node.len());\n\n        Handle {\n            node,\n            idx,\n            _marker: PhantomData\n        }\n    }\n\n    pub fn left_edge(self) -> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {\n        Handle::new_edge(self.node, self.idx)\n    }\n\n    pub fn right_edge(self) -> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {\n        Handle::new_edge(self.node, self.idx + 1)\n    }\n}\n\nimpl<BorrowType, K, V, NodeType, HandleType> PartialEq\n        for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {\n\n    fn eq(&self, other: &Self) -> bool {\n        self.node.node == other.node.node && self.idx == other.idx\n    }\n}\n\nimpl<BorrowType, K, V, NodeType, HandleType>\n        Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {\n\n    /// Temporarily takes out another, immutable handle on the same location.\n    pub fn reborrow(&self)\n            -> Handle<NodeRef<marker::Immut, K, V, NodeType>, HandleType> {\n\n        // We can't use Handle::new_kv or Handle::new_edge because we don't know our type\n        Handle {\n            node: self.node.reborrow(),\n            idx: self.idx,\n            _marker: PhantomData\n        }\n    }\n}\n\nimpl<'a, K, V, NodeType, HandleType>\n        Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, HandleType> {\n\n    /// Temporarily takes out another, mutable handle on the same location. Beware, as\n    /// this method is very dangerous, doubly so since it may not immediately appear\n    /// dangerous.\n    ///\n    /// Because mutable pointers can roam anywhere around the tree and can even (through\n    /// `into_root_mut`) mess with the root of the tree, the result of `reborrow_mut`\n    /// can easily be used to make the original mutable pointer dangling, or, in the case\n    /// of a reborrowed handle, out of bounds.\n    // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts\n    // the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.\n    pub unsafe fn reborrow_mut(&mut self)\n            -> Handle<NodeRef<marker::Mut, K, V, NodeType>, HandleType> {\n\n        // We can't use Handle::new_kv or Handle::new_edge because we don't know our type\n        Handle {\n            node: self.node.reborrow_mut(),\n            idx: self.idx,\n            _marker: PhantomData\n        }\n    }\n}\n\nimpl<BorrowType, K, V, NodeType>\n        Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {\n\n    /// Creates a new handle to an edge in `node`. `idx` must be less than or equal to\n    /// `node.len()`.\n    pub fn new_edge(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {\n        // Necessary for correctness, but in a private module\n        debug_assert!(idx <= node.len());\n\n        Handle {\n            node,\n            idx,\n            _marker: PhantomData\n        }\n    }\n\n    pub fn left_kv(self)\n            -> Result<Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV>, Self> {\n\n        if self.idx > 0 {\n            Ok(Handle::new_kv(self.node, self.idx - 1))\n        } else {\n            Err(self)\n        }\n    }\n\n    pub fn right_kv(self)\n            -> Result<Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV>, Self> {\n\n        if self.idx < self.node.len() {\n            Ok(Handle::new_kv(self.node, self.idx))\n        } else {\n            Err(self)\n        }\n    }\n}\n\nimpl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge> {\n    /// Inserts a new key/value pair between the key/value pairs to the right and left of\n    /// this edge. This method assumes that there is enough space in the node for the new\n    /// pair to fit.\n    ///\n    /// The returned pointer points to the inserted value.\n    fn insert_fit(&mut self, key: K, val: V) -> *mut V {\n        // Necessary for correctness, but in a private module\n        debug_assert!(self.node.len() < CAPACITY);\n        debug_assert!(!self.node.is_shared_root());\n\n        unsafe {\n            slice_insert(self.node.keys_mut(), self.idx, key);\n            slice_insert(self.node.vals_mut(), self.idx, val);\n\n            self.node.as_leaf_mut().len += 1;\n\n            self.node.vals_mut().get_unchecked_mut(self.idx)\n        }\n    }\n\n    /// Inserts a new key/value pair between the key/value pairs to the right and left of\n    /// this edge. This method splits the node if there isn't enough room.\n    ///\n    /// The returned pointer points to the inserted value.\n    pub fn insert(mut self, key: K, val: V)\n            -> (InsertResult<'a, K, V, marker::Leaf>, *mut V) {\n\n        if self.node.len() < CAPACITY {\n            let ptr = self.insert_fit(key, val);\n            (InsertResult::Fit(Handle::new_kv(self.node, self.idx)), ptr)\n        } else {\n            let middle = Handle::new_kv(self.node, B);\n            let (mut left, k, v, mut right) = middle.split();\n            let ptr = if self.idx <= B {\n                unsafe {\n                    Handle::new_edge(left.reborrow_mut(), self.idx).insert_fit(key, val)\n                }\n            } else {\n                unsafe {\n                    Handle::new_edge(\n                        right.as_mut().cast_unchecked::<marker::Leaf>(),\n                        self.idx - (B + 1)\n                    ).insert_fit(key, val)\n                }\n            };\n            (InsertResult::Split(left, k, v, right), ptr)\n        }\n    }\n}\n\nimpl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> {\n    /// Fixes the parent pointer and index in the child node below this edge. This is useful\n    /// when the ordering of edges has been changed, such as in the various `insert` methods.\n    fn correct_parent_link(mut self) {\n        let idx = self.idx as u16;\n        let ptr = self.node.as_internal_mut() as *mut _;\n        let mut child = self.descend();\n        child.as_leaf_mut().parent = ptr;\n        child.as_leaf_mut().parent_idx.set(idx);\n    }\n\n    /// Unsafely asserts to the compiler some static information about whether the underlying\n    /// node of this handle is a `Leaf`.\n    unsafe fn cast_unchecked<NewType>(&mut self)\n            -> Handle<NodeRef<marker::Mut, K, V, NewType>, marker::Edge> {\n\n        Handle::new_edge(self.node.cast_unchecked(), self.idx)\n    }\n\n    /// Inserts a new key/value pair and an edge that will go to the right of that new pair\n    /// between this edge and the key/value pair to the right of this edge. This method assumes\n    /// that there is enough space in the node for the new pair to fit.\n    fn insert_fit(&mut self, key: K, val: V, edge: Root<K, V>) {\n        // Necessary for correctness, but in an internal module\n        debug_assert!(self.node.len() < CAPACITY);\n        debug_assert!(edge.height == self.node.height - 1);\n\n        unsafe {\n            // This cast is a lie, but it allows us to reuse the key/value insertion logic.\n            self.cast_unchecked::<marker::Leaf>().insert_fit(key, val);\n\n            slice_insert(\n                slice::from_raw_parts_mut(\n                    self.node.as_internal_mut().edges.as_mut_ptr(),\n                    self.node.len()\n                ),\n                self.idx + 1,\n                edge.node\n            );\n\n            for i in (self.idx+1)..(self.node.len()+1) {\n                Handle::new_edge(self.node.reborrow_mut(), i).correct_parent_link();\n            }\n        }\n    }\n\n    /// Inserts a new key/value pair and an edge that will go to the right of that new pair\n    /// between this edge and the key/value pair to the right of this edge. This method splits\n    /// the node if there isn't enough room.\n    pub fn insert(mut self, key: K, val: V, edge: Root<K, V>)\n            -> InsertResult<'a, K, V, marker::Internal> {\n\n        // Necessary for correctness, but this is an internal module\n        debug_assert!(edge.height == self.node.height - 1);\n\n        if self.node.len() < CAPACITY {\n            self.insert_fit(key, val, edge);\n            InsertResult::Fit(Handle::new_kv(self.node, self.idx))\n        } else {\n            let middle = Handle::new_kv(self.node, B);\n            let (mut left, k, v, mut right) = middle.split();\n            if self.idx <= B {\n                unsafe {\n                    Handle::new_edge(left.reborrow_mut(), self.idx).insert_fit(key, val, edge);\n                }\n            } else {\n                unsafe {\n                    Handle::new_edge(\n                        right.as_mut().cast_unchecked::<marker::Internal>(),\n                        self.idx - (B + 1)\n                    ).insert_fit(key, val, edge);\n                }\n            }\n            InsertResult::Split(left, k, v, right)\n        }\n    }\n}\n\nimpl<BorrowType, K, V>\n        Handle<NodeRef<BorrowType, K, V, marker::Internal>, marker::Edge> {\n\n    /// Finds the node pointed to by this edge.\n    ///\n    /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should\n    /// both, upon success, do nothing.\n    pub fn descend(self) -> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {\n        NodeRef {\n            height: self.node.height - 1,\n            node: unsafe { self.node.as_internal().edges.get_unchecked(self.idx).as_ptr() },\n            root: self.node.root,\n            _marker: PhantomData\n        }\n    }\n}\n\nimpl<'a, K: 'a, V: 'a, NodeType>\n        Handle<NodeRef<marker::Immut<'a>, K, V, NodeType>, marker::KV> {\n\n    pub fn into_kv(self) -> (&'a K, &'a V) {\n        let (keys, vals) = self.node.into_slices();\n        unsafe {\n            (keys.get_unchecked(self.idx), vals.get_unchecked(self.idx))\n        }\n    }\n}\n\nimpl<'a, K: 'a, V: 'a, NodeType>\n        Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, marker::KV> {\n\n    pub fn into_kv_mut(self) -> (&'a mut K, &'a mut V) {\n        let (keys, vals) = self.node.into_slices_mut();\n        unsafe {\n            (keys.get_unchecked_mut(self.idx), vals.get_unchecked_mut(self.idx))\n        }\n    }\n}\n\nimpl<'a, K, V, NodeType> Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, marker::KV> {\n    pub fn kv_mut(&mut self) -> (&mut K, &mut V) {\n        unsafe {\n            let (keys, vals) = self.node.reborrow_mut().into_slices_mut();\n            (keys.get_unchecked_mut(self.idx), vals.get_unchecked_mut(self.idx))\n        }\n    }\n}\n\nimpl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::KV> {\n    /// Splits the underlying node into three parts:\n    ///\n    /// - The node is truncated to only contain the key/value pairs to the right of\n    ///   this handle.\n    /// - The key and value pointed to by this handle and extracted.\n    /// - All the key/value pairs to the right of this handle are put into a newly\n    ///   allocated node.\n    pub fn split(mut self)\n            -> (NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, K, V, Root<K, V>) {\n        debug_assert!(!self.node.is_shared_root());\n        unsafe {\n            let mut new_node = Box::new(LeafNode::new());\n\n            let k = ptr::read(self.node.keys().get_unchecked(self.idx));\n            let v = ptr::read(self.node.vals().get_unchecked(self.idx));\n\n            let new_len = self.node.len() - self.idx - 1;\n\n            ptr::copy_nonoverlapping(\n                self.node.keys().as_ptr().add(self.idx + 1),\n                new_node.keys.as_mut_ptr() as *mut K,\n                new_len\n            );\n            ptr::copy_nonoverlapping(\n                self.node.vals().as_ptr().add(self.idx + 1),\n                new_node.vals.as_mut_ptr() as *mut V,\n                new_len\n            );\n\n            self.node.as_leaf_mut().len = self.idx as u16;\n            new_node.len = new_len as u16;\n\n            (\n                self.node,\n                k, v,\n                Root {\n                    node: BoxedNode::from_leaf(new_node),\n                    height: 0\n                }\n            )\n        }\n    }\n\n    /// Removes the key/value pair pointed to by this handle, returning the edge between the\n    /// now adjacent key/value pairs to the left and right of this handle.\n    pub fn remove(mut self)\n            -> (Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>, K, V) {\n        debug_assert!(!self.node.is_shared_root());\n        unsafe {\n            let k = slice_remove(self.node.keys_mut(), self.idx);\n            let v = slice_remove(self.node.vals_mut(), self.idx);\n            self.node.as_leaf_mut().len -= 1;\n            (self.left_edge(), k, v)\n        }\n    }\n}\n\nimpl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::KV> {\n    /// Splits the underlying node into three parts:\n    ///\n    /// - The node is truncated to only contain the edges and key/value pairs to the\n    ///   right of this handle.\n    /// - The key and value pointed to by this handle and extracted.\n    /// - All the edges and key/value pairs to the right of this handle are put into\n    ///   a newly allocated node.\n    pub fn split(mut self)\n            -> (NodeRef<marker::Mut<'a>, K, V, marker::Internal>, K, V, Root<K, V>) {\n        unsafe {\n            let mut new_node = Box::new(InternalNode::new());\n\n            let k = ptr::read(self.node.keys().get_unchecked(self.idx));\n            let v = ptr::read(self.node.vals().get_unchecked(self.idx));\n\n            let height = self.node.height;\n            let new_len = self.node.len() - self.idx - 1;\n\n            ptr::copy_nonoverlapping(\n                self.node.keys().as_ptr().add(self.idx + 1),\n                new_node.data.keys.as_mut_ptr() as *mut K,\n                new_len\n            );\n            ptr::copy_nonoverlapping(\n                self.node.vals().as_ptr().add(self.idx + 1),\n                new_node.data.vals.as_mut_ptr() as *mut V,\n                new_len\n            );\n            ptr::copy_nonoverlapping(\n                self.node.as_internal().edges.as_ptr().add(self.idx + 1),\n                new_node.edges.as_mut_ptr(),\n                new_len + 1\n            );\n\n            self.node.as_leaf_mut().len = self.idx as u16;\n            new_node.data.len = new_len as u16;\n\n            let mut new_root = Root {\n                node: BoxedNode::from_internal(new_node),\n                height,\n            };\n\n            for i in 0..(new_len+1) {\n                Handle::new_edge(new_root.as_mut().cast_unchecked(), i).correct_parent_link();\n            }\n\n            (\n                self.node,\n                k, v,\n                new_root\n            )\n        }\n    }\n\n    /// Returns whether it is valid to call `.merge()`, i.e., whether there is enough room in\n    /// a node to hold the combination of the nodes to the left and right of this handle along\n    /// with the key/value pair at this handle.\n    pub fn can_merge(&self) -> bool {\n        (\n            self.reborrow()\n                .left_edge()\n                .descend()\n                .len()\n          + self.reborrow()\n                .right_edge()\n                .descend()\n                .len()\n          + 1\n        ) <= CAPACITY\n    }\n\n    /// Combines the node immediately to the left of this handle, the key/value pair pointed\n    /// to by this handle, and the node immediately to the right of this handle into one new\n    /// child of the underlying node, returning an edge referencing that new child.\n    ///\n    /// Assumes that this edge `.can_merge()`.\n    pub fn merge(mut self)\n            -> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> {\n        let self1 = unsafe { ptr::read(&self) };\n        let self2 = unsafe { ptr::read(&self) };\n        let mut left_node = self1.left_edge().descend();\n        let left_len = left_node.len();\n        let mut right_node = self2.right_edge().descend();\n        let right_len = right_node.len();\n\n        // necessary for correctness, but in a private module\n        debug_assert!(left_len + right_len + 1 <= CAPACITY);\n\n        unsafe {\n            ptr::write(left_node.keys_mut().get_unchecked_mut(left_len),\n                       slice_remove(self.node.keys_mut(), self.idx));\n            ptr::copy_nonoverlapping(\n                right_node.keys().as_ptr(),\n                left_node.keys_mut().as_mut_ptr().add(left_len + 1),\n                right_len\n            );\n            ptr::write(left_node.vals_mut().get_unchecked_mut(left_len),\n                       slice_remove(self.node.vals_mut(), self.idx));\n            ptr::copy_nonoverlapping(\n                right_node.vals().as_ptr(),\n                left_node.vals_mut().as_mut_ptr().add(left_len + 1),\n                right_len\n            );\n\n            slice_remove(&mut self.node.as_internal_mut().edges, self.idx + 1);\n            for i in self.idx+1..self.node.len() {\n                Handle::new_edge(self.node.reborrow_mut(), i).correct_parent_link();\n            }\n            self.node.as_leaf_mut().len -= 1;\n\n            left_node.as_leaf_mut().len += right_len as u16 + 1;\n\n            if self.node.height > 1 {\n                ptr::copy_nonoverlapping(\n                    right_node.cast_unchecked().as_internal().edges.as_ptr(),\n                    left_node.cast_unchecked()\n                             .as_internal_mut()\n                             .edges\n                             .as_mut_ptr()\n                             .add(left_len + 1),\n                    right_len + 1\n                );\n\n                for i in left_len+1..left_len+right_len+2 {\n                    Handle::new_edge(\n                        left_node.cast_unchecked().reborrow_mut(),\n                        i\n                    ).correct_parent_link();\n                }\n\n                Global.dealloc(\n                    right_node.node.cast(),\n                    Layout::new::<InternalNode<K, V>>(),\n                );\n            } else {\n                Global.dealloc(\n                    right_node.node.cast(),\n                    Layout::new::<LeafNode<K, V>>(),\n                );\n            }\n\n            Handle::new_edge(self.node, self.idx)\n        }\n    }\n\n    /// This removes a key/value pair from the left child and replaces it with the key/value pair\n    /// pointed to by this handle while pushing the old key/value pair of this handle into the right\n    /// child.\n    pub fn steal_left(&mut self) {\n        unsafe {\n            let (k, v, edge) = self.reborrow_mut().left_edge().descend().pop();\n\n            let k = mem::replace(self.reborrow_mut().into_kv_mut().0, k);\n            let v = mem::replace(self.reborrow_mut().into_kv_mut().1, v);\n\n            match self.reborrow_mut().right_edge().descend().force() {\n                ForceResult::Leaf(mut leaf) => leaf.push_front(k, v),\n                ForceResult::Internal(mut internal) => internal.push_front(k, v, edge.unwrap())\n            }\n        }\n    }\n\n    /// This removes a key/value pair from the right child and replaces it with the key/value pair\n    /// pointed to by this handle while pushing the old key/value pair of this handle into the left\n    /// child.\n    pub fn steal_right(&mut self) {\n        unsafe {\n            let (k, v, edge) = self.reborrow_mut().right_edge().descend().pop_front();\n\n            let k = mem::replace(self.reborrow_mut().into_kv_mut().0, k);\n            let v = mem::replace(self.reborrow_mut().into_kv_mut().1, v);\n\n            match self.reborrow_mut().left_edge().descend().force() {\n                ForceResult::Leaf(mut leaf) => leaf.push(k, v),\n                ForceResult::Internal(mut internal) => internal.push(k, v, edge.unwrap())\n            }\n        }\n    }\n\n    /// This does stealing similar to `steal_left` but steals multiple elements at once.\n    pub fn bulk_steal_left(&mut self, count: usize) {\n        unsafe {\n            let mut left_node = ptr::read(self).left_edge().descend();\n            let left_len = left_node.len();\n            let mut right_node = ptr::read(self).right_edge().descend();\n            let right_len = right_node.len();\n\n            // Make sure that we may steal safely.\n            debug_assert!(right_len + count <= CAPACITY);\n            debug_assert!(left_len >= count);\n\n            let new_left_len = left_len - count;\n\n            // Move data.\n            {\n                let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();\n                let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();\n                let parent_kv = {\n                    let kv = self.reborrow_mut().into_kv_mut();\n                    (kv.0 as *mut K, kv.1 as *mut V)\n                };\n\n                // Make room for stolen elements in the right child.\n                ptr::copy(right_kv.0,\n                          right_kv.0.add(count),\n                          right_len);\n                ptr::copy(right_kv.1,\n                          right_kv.1.add(count),\n                          right_len);\n\n                // Move elements from the left child to the right one.\n                move_kv(left_kv, new_left_len + 1, right_kv, 0, count - 1);\n\n                // Move parent's key/value pair to the right child.\n                move_kv(parent_kv, 0, right_kv, count - 1, 1);\n\n                // Move the left-most stolen pair to the parent.\n                move_kv(left_kv, new_left_len, parent_kv, 0, 1);\n            }\n\n            left_node.reborrow_mut().as_leaf_mut().len -= count as u16;\n            right_node.reborrow_mut().as_leaf_mut().len += count as u16;\n\n            match (left_node.force(), right_node.force()) {\n                (ForceResult::Internal(left), ForceResult::Internal(mut right)) => {\n                    // Make room for stolen edges.\n                    let right_edges = right.reborrow_mut().as_internal_mut().edges.as_mut_ptr();\n                    ptr::copy(right_edges,\n                              right_edges.add(count),\n                              right_len + 1);\n                    right.correct_childrens_parent_links(count, count + right_len + 1);\n\n                    move_edges(left, new_left_len + 1, right, 0, count);\n                },\n                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }\n                _ => { unreachable!(); }\n            }\n        }\n    }\n\n    /// The symmetric clone of `bulk_steal_left`.\n    pub fn bulk_steal_right(&mut self, count: usize) {\n        unsafe {\n            let mut left_node = ptr::read(self).left_edge().descend();\n            let left_len = left_node.len();\n            let mut right_node = ptr::read(self).right_edge().descend();\n            let right_len = right_node.len();\n\n            // Make sure that we may steal safely.\n            debug_assert!(left_len + count <= CAPACITY);\n            debug_assert!(right_len >= count);\n\n            let new_right_len = right_len - count;\n\n            // Move data.\n            {\n                let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();\n                let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();\n                let parent_kv = {\n                    let kv = self.reborrow_mut().into_kv_mut();\n                    (kv.0 as *mut K, kv.1 as *mut V)\n                };\n\n                // Move parent's key/value pair to the left child.\n                move_kv(parent_kv, 0, left_kv, left_len, 1);\n\n                // Move elements from the right child to the left one.\n                move_kv(right_kv, 0, left_kv, left_len + 1, count - 1);\n\n                // Move the right-most stolen pair to the parent.\n                move_kv(right_kv, count - 1, parent_kv, 0, 1);\n\n                // Fix right indexing\n                ptr::copy(right_kv.0.add(count),\n                          right_kv.0,\n                          new_right_len);\n                ptr::copy(right_kv.1.add(count),\n                          right_kv.1,\n                          new_right_len);\n            }\n\n            left_node.reborrow_mut().as_leaf_mut().len += count as u16;\n            right_node.reborrow_mut().as_leaf_mut().len -= count as u16;\n\n            match (left_node.force(), right_node.force()) {\n                (ForceResult::Internal(left), ForceResult::Internal(mut right)) => {\n                    move_edges(right.reborrow_mut(), 0, left, left_len + 1, count);\n\n                    // Fix right indexing.\n                    let right_edges = right.reborrow_mut().as_internal_mut().edges.as_mut_ptr();\n                    ptr::copy(right_edges.add(count),\n                              right_edges,\n                              new_right_len + 1);\n                    right.correct_childrens_parent_links(0, new_right_len + 1);\n                },\n                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }\n                _ => { unreachable!(); }\n            }\n        }\n    }\n}\n\nunsafe fn move_kv<K, V>(\n    source: (*mut K, *mut V), source_offset: usize,\n    dest: (*mut K, *mut V), dest_offset: usize,\n    count: usize)\n{\n    ptr::copy_nonoverlapping(source.0.add(source_offset),\n                             dest.0.add(dest_offset),\n                             count);\n    ptr::copy_nonoverlapping(source.1.add(source_offset),\n                             dest.1.add(dest_offset),\n                             count);\n}\n\n// Source and destination must have the same height.\nunsafe fn move_edges<K, V>(\n    mut source: NodeRef<marker::Mut, K, V, marker::Internal>, source_offset: usize,\n    mut dest: NodeRef<marker::Mut, K, V, marker::Internal>, dest_offset: usize,\n    count: usize)\n{\n    let source_ptr = source.as_internal_mut().edges.as_mut_ptr();\n    let dest_ptr = dest.as_internal_mut().edges.as_mut_ptr();\n    ptr::copy_nonoverlapping(source_ptr.add(source_offset),\n                             dest_ptr.add(dest_offset),\n                             count);\n    dest.correct_childrens_parent_links(dest_offset, dest_offset + count);\n}\n\nimpl<BorrowType, K, V, HandleType>\n        Handle<NodeRef<BorrowType, K, V, marker::LeafOrInternal>, HandleType> {\n\n    /// Check whether the underlying node is an `Internal` node or a `Leaf` node.\n    pub fn force(self) -> ForceResult<\n        Handle<NodeRef<BorrowType, K, V, marker::Leaf>, HandleType>,\n        Handle<NodeRef<BorrowType, K, V, marker::Internal>, HandleType>\n    > {\n        match self.node.force() {\n            ForceResult::Leaf(node) => ForceResult::Leaf(Handle {\n                node,\n                idx: self.idx,\n                _marker: PhantomData\n            }),\n            ForceResult::Internal(node) => ForceResult::Internal(Handle {\n                node,\n                idx: self.idx,\n                _marker: PhantomData\n            })\n        }\n    }\n}\n\nimpl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::Edge> {\n    /// Move the suffix after `self` from one node to another one. `right` must be empty.\n    /// The first edge of `right` remains unchanged.\n    pub fn move_suffix(&mut self,\n            right: &mut NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>) {\n        unsafe {\n            let left_new_len = self.idx;\n            let mut left_node = self.reborrow_mut().into_node();\n\n            let right_new_len = left_node.len() - left_new_len;\n            let mut right_node = right.reborrow_mut();\n\n            debug_assert!(right_node.len() == 0);\n            debug_assert!(left_node.height == right_node.height);\n\n            let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();\n            let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();\n\n\n            move_kv(left_kv, left_new_len, right_kv, 0, right_new_len);\n\n            left_node.reborrow_mut().as_leaf_mut().len = left_new_len as u16;\n            right_node.reborrow_mut().as_leaf_mut().len = right_new_len as u16;\n\n            match (left_node.force(), right_node.force()) {\n                (ForceResult::Internal(left), ForceResult::Internal(right)) => {\n                    move_edges(left, left_new_len + 1, right, 1, right_new_len);\n                },\n                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }\n                _ => { unreachable!(); }\n            }\n        }\n    }\n}\n\npub enum ForceResult<Leaf, Internal> {\n    Leaf(Leaf),\n    Internal(Internal)\n}\n\npub enum InsertResult<'a, K, V, Type> {\n    Fit(Handle<NodeRef<marker::Mut<'a>, K, V, Type>, marker::KV>),\n    Split(NodeRef<marker::Mut<'a>, K, V, Type>, K, V, Root<K, V>)\n}\n\npub mod marker {\n    use core::marker::PhantomData;\n\n    pub enum Leaf { }\n    pub enum Internal { }\n    pub enum LeafOrInternal { }\n\n    pub enum Owned { }\n    pub struct Immut<'a>(PhantomData<&'a ()>);\n    pub struct Mut<'a>(PhantomData<&'a mut ()>);\n\n    pub enum KV { }\n    pub enum Edge { }\n}\n\nunsafe fn slice_insert<T>(slice: &mut [T], idx: usize, val: T) {\n    ptr::copy(\n        slice.as_ptr().add(idx),\n        slice.as_mut_ptr().add(idx + 1),\n        slice.len() - idx\n    );\n    ptr::write(slice.get_unchecked_mut(idx), val);\n}\n\nunsafe fn slice_remove<T>(slice: &mut [T], idx: usize) -> T {\n    let ret = ptr::read(slice.get_unchecked(idx));\n    ptr::copy(\n        slice.as_ptr().add(idx + 1),\n        slice.as_mut_ptr().add(idx),\n        slice.len() - idx - 1\n    );\n    ret\n}\n","// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A dynamically-sized view into a contiguous sequence, `[T]`.\n//!\n//! *[See also the slice primitive type](../../std/primitive.slice.html).*\n//!\n//! Slices are a view into a block of memory represented as a pointer and a\n//! length.\n//!\n//! ```\n//! // slicing a Vec\n//! let vec = vec![1, 2, 3];\n//! let int_slice = &vec[..];\n//! // coercing an array to a slice\n//! let str_slice: &[&str] = &[\"one\", \"two\", \"three\"];\n//! ```\n//!\n//! Slices are either mutable or shared. The shared slice type is `&[T]`,\n//! while the mutable slice type is `&mut [T]`, where `T` represents the element\n//! type. For example, you can mutate the block of memory that a mutable slice\n//! points to:\n//!\n//! ```\n//! let x = &mut [1, 2, 3];\n//! x[1] = 7;\n//! assert_eq!(x, &[1, 7, 3]);\n//! ```\n//!\n//! Here are some of the things this module contains:\n//!\n//! ## Structs\n//!\n//! There are several structs that are useful for slices, such as [`Iter`], which\n//! represents iteration over a slice.\n//!\n//! ## Trait Implementations\n//!\n//! There are several implementations of common traits for slices. Some examples\n//! include:\n//!\n//! * [`Clone`]\n//! * [`Eq`], [`Ord`] - for slices whose element type are [`Eq`] or [`Ord`].\n//! * [`Hash`] - for slices whose element type is [`Hash`].\n//!\n//! ## Iteration\n//!\n//! The slices implement `IntoIterator`. The iterator yields references to the\n//! slice elements.\n//!\n//! ```\n//! let numbers = &[0, 1, 2];\n//! for n in numbers {\n//!     println!(\"{} is a number!\", n);\n//! }\n//! ```\n//!\n//! The mutable slice yields mutable references to the elements:\n//!\n//! ```\n//! let mut scores = [7, 8, 9];\n//! for score in &mut scores[..] {\n//!     *score += 1;\n//! }\n//! ```\n//!\n//! This iterator yields mutable references to the slice's elements, so while\n//! the element type of the slice is `i32`, the element type of the iterator is\n//! `&mut i32`.\n//!\n//! * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default\n//!   iterators.\n//! * Further methods that return iterators are [`.split`], [`.splitn`],\n//!   [`.chunks`], [`.windows`] and more.\n//!\n//! [`Clone`]: ../../std/clone/trait.Clone.html\n//! [`Eq`]: ../../std/cmp/trait.Eq.html\n//! [`Ord`]: ../../std/cmp/trait.Ord.html\n//! [`Iter`]: struct.Iter.html\n//! [`Hash`]: ../../std/hash/trait.Hash.html\n//! [`.iter`]: ../../std/primitive.slice.html#method.iter\n//! [`.iter_mut`]: ../../std/primitive.slice.html#method.iter_mut\n//! [`.split`]: ../../std/primitive.slice.html#method.split\n//! [`.splitn`]: ../../std/primitive.slice.html#method.splitn\n//! [`.chunks`]: ../../std/primitive.slice.html#method.chunks\n//! [`.windows`]: ../../std/primitive.slice.html#method.windows\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n// Many of the usings in this module are only used in the test configuration.\n// It's cleaner to just turn off the unused_imports warning than to fix them.\n#![cfg_attr(test, allow(unused_imports, dead_code))]\n\nuse core::cmp::Ordering::{self, Less};\nuse core::mem::size_of;\nuse core::mem;\nuse core::ptr;\nuse core::{u8, u16, u32};\n\nuse borrow::{Borrow, BorrowMut, ToOwned};\nuse boxed::Box;\nuse vec::Vec;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::slice::{Chunks, Windows};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::slice::{Iter, IterMut};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::slice::{SplitMut, ChunksMut, Split};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut};\n#[stable(feature = \"slice_rsplit\", since = \"1.27.0\")]\npub use core::slice::{RSplit, RSplitMut};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::slice::{from_raw_parts, from_raw_parts_mut};\n#[stable(feature = \"from_ref\", since = \"1.28.0\")]\npub use core::slice::{from_ref, from_mut};\n#[stable(feature = \"slice_get_slice\", since = \"1.28.0\")]\npub use core::slice::SliceIndex;\n#[stable(feature = \"chunks_exact\", since = \"1.31.0\")]\npub use core::slice::{ChunksExact, ChunksExactMut};\n#[stable(feature = \"rchunks\", since = \"1.31.0\")]\npub use core::slice::{RChunks, RChunksMut, RChunksExact, RChunksExactMut};\n\n////////////////////////////////////////////////////////////////////////////////\n// Basic slice extension methods\n////////////////////////////////////////////////////////////////////////////////\n\n// HACK(japaric) needed for the implementation of `vec!` macro during testing\n// NB see the hack module in this file for more details\n#[cfg(test)]\npub use self::hack::into_vec;\n\n// HACK(japaric) needed for the implementation of `Vec::clone` during testing\n// NB see the hack module in this file for more details\n#[cfg(test)]\npub use self::hack::to_vec;\n\n// HACK(japaric): With cfg(test) `impl [T]` is not available, these three\n// functions are actually methods that are in `impl [T]` but not in\n// `core::slice::SliceExt` - we need to supply these functions for the\n// `test_permutations` test\nmod hack {\n    use boxed::Box;\n    use core::mem;\n\n    #[cfg(test)]\n    use string::ToString;\n    use vec::Vec;\n\n    pub fn into_vec<T>(mut b: Box<[T]>) -> Vec<T> {\n        unsafe {\n            let xs = Vec::from_raw_parts(b.as_mut_ptr(), b.len(), b.len());\n            mem::forget(b);\n            xs\n        }\n    }\n\n    #[inline]\n    pub fn to_vec<T>(s: &[T]) -> Vec<T>\n        where T: Clone\n    {\n        let mut vector = Vec::with_capacity(s.len());\n        vector.extend_from_slice(s);\n        vector\n    }\n}\n\n#[lang = \"slice_alloc\"]\n#[cfg(not(test))]\nimpl<T> [T] {\n    /// Sorts the slice.\n    ///\n    /// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.\n    ///\n    /// When applicable, unstable sorting is preferred because it is generally faster than stable\n    /// sorting and it doesn't allocate auxiliary memory.\n    /// See [`sort_unstable`](#method.sort_unstable).\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is an adaptive, iterative merge sort inspired by\n    /// [timsort](https://en.wikipedia.org/wiki/Timsort).\n    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of\n    /// two or more sorted sequences concatenated one after another.\n    ///\n    /// Also, it allocates temporary storage half the size of `self`, but for short slices a\n    /// non-allocating insertion sort is used instead.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [-5, 4, 1, -3, 2];\n    ///\n    /// v.sort();\n    /// assert!(v == [-5, -3, 1, 2, 4]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn sort(&mut self)\n        where T: Ord\n    {\n        merge_sort(self, |a, b| a.lt(b));\n    }\n\n    /// Sorts the slice with a comparator function.\n    ///\n    /// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.\n    ///\n    /// When applicable, unstable sorting is preferred because it is generally faster than stable\n    /// sorting and it doesn't allocate auxiliary memory.\n    /// See [`sort_unstable_by`](#method.sort_unstable_by).\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is an adaptive, iterative merge sort inspired by\n    /// [timsort](https://en.wikipedia.org/wiki/Timsort).\n    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of\n    /// two or more sorted sequences concatenated one after another.\n    ///\n    /// Also, it allocates temporary storage half the size of `self`, but for short slices a\n    /// non-allocating insertion sort is used instead.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [5, 4, 1, 3, 2];\n    /// v.sort_by(|a, b| a.cmp(b));\n    /// assert!(v == [1, 2, 3, 4, 5]);\n    ///\n    /// // reverse sorting\n    /// v.sort_by(|a, b| b.cmp(a));\n    /// assert!(v == [5, 4, 3, 2, 1]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn sort_by<F>(&mut self, mut compare: F)\n        where F: FnMut(&T, &T) -> Ordering\n    {\n        merge_sort(self, |a, b| compare(a, b) == Less);\n    }\n\n    /// Sorts the slice with a key extraction function.\n    ///\n    /// This sort is stable (i.e. does not reorder equal elements) and `O(m n log(m n))`\n    /// worst-case, where the key function is `O(m)`.\n    ///\n    /// When applicable, unstable sorting is preferred because it is generally faster than stable\n    /// sorting and it doesn't allocate auxiliary memory.\n    /// See [`sort_unstable_by_key`](#method.sort_unstable_by_key).\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is an adaptive, iterative merge sort inspired by\n    /// [timsort](https://en.wikipedia.org/wiki/Timsort).\n    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of\n    /// two or more sorted sequences concatenated one after another.\n    ///\n    /// Also, it allocates temporary storage half the size of `self`, but for short slices a\n    /// non-allocating insertion sort is used instead.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let mut v = [-5i32, 4, 1, -3, 2];\n    ///\n    /// v.sort_by_key(|k| k.abs());\n    /// assert!(v == [1, 2, -3, 4, -5]);\n    /// ```\n    #[stable(feature = \"slice_sort_by_key\", since = \"1.7.0\")]\n    #[inline]\n    pub fn sort_by_key<K, F>(&mut self, mut f: F)\n        where F: FnMut(&T) -> K, K: Ord\n    {\n        merge_sort(self, |a, b| f(a).lt(&f(b)));\n    }\n\n    /// Sorts the slice with a key extraction function.\n    ///\n    /// During sorting, the key function is called only once per element.\n    ///\n    /// This sort is stable (i.e. does not reorder equal elements) and `O(m n + n log n)`\n    /// worst-case, where the key function is `O(m)`.\n    ///\n    /// For simple key functions (e.g. functions that are property accesses or\n    /// basic operations), [`sort_by_key`](#method.sort_by_key) is likely to be\n    /// faster.\n    ///\n    /// # Current implementation\n    ///\n    /// The current algorithm is based on [pattern-defeating quicksort][pdqsort] by Orson Peters,\n    /// which combines the fast average case of randomized quicksort with the fast worst case of\n    /// heapsort, while achieving linear time on slices with certain patterns. It uses some\n    /// randomization to avoid degenerate cases, but with a fixed seed to always provide\n    /// deterministic behavior.\n    ///\n    /// In the worst case, the algorithm allocates temporary storage in a `Vec<(K, usize)>` the\n    /// length of the slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(slice_sort_by_cached_key)]\n    /// let mut v = [-5i32, 4, 32, -3, 2];\n    ///\n    /// v.sort_by_cached_key(|k| k.to_string());\n    /// assert!(v == [-3, -5, 2, 32, 4]);\n    /// ```\n    ///\n    /// [pdqsort]: https://github.com/orlp/pdqsort\n    #[unstable(feature = \"slice_sort_by_cached_key\", issue = \"34447\")]\n    #[inline]\n    pub fn sort_by_cached_key<K, F>(&mut self, f: F)\n        where F: FnMut(&T) -> K, K: Ord\n    {\n        // Helper macro for indexing our vector by the smallest possible type, to reduce allocation.\n        macro_rules! sort_by_key {\n            ($t:ty, $slice:ident, $f:ident) => ({\n                let mut indices: Vec<_> =\n                    $slice.iter().map($f).enumerate().map(|(i, k)| (k, i as $t)).collect();\n                // The elements of `indices` are unique, as they are indexed, so any sort will be\n                // stable with respect to the original slice. We use `sort_unstable` here because\n                // it requires less memory allocation.\n                indices.sort_unstable();\n                for i in 0..$slice.len() {\n                    let mut index = indices[i].1;\n                    while (index as usize) < i {\n                        index = indices[index as usize].1;\n                    }\n                    indices[i].1 = index;\n                    $slice.swap(i, index as usize);\n                }\n            })\n        }\n\n        let sz_u8    = mem::size_of::<(K, u8)>();\n        let sz_u16   = mem::size_of::<(K, u16)>();\n        let sz_u32   = mem::size_of::<(K, u32)>();\n        let sz_usize = mem::size_of::<(K, usize)>();\n\n        let len = self.len();\n        if len < 2 { return }\n        if sz_u8  < sz_u16   && len <= ( u8::MAX as usize) { return sort_by_key!( u8, self, f) }\n        if sz_u16 < sz_u32   && len <= (u16::MAX as usize) { return sort_by_key!(u16, self, f) }\n        if sz_u32 < sz_usize && len <= (u32::MAX as usize) { return sort_by_key!(u32, self, f) }\n        sort_by_key!(usize, self, f)\n    }\n\n    /// Copies `self` into a new `Vec`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s = [10, 40, 30];\n    /// let x = s.to_vec();\n    /// // Here, `s` and `x` can be modified independently.\n    /// ```\n    #[rustc_conversion_suggestion]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_vec(&self) -> Vec<T>\n        where T: Clone\n    {\n        // NB see hack module in this file\n        hack::to_vec(self)\n    }\n\n    /// Converts `self` into a vector without clones or allocation.\n    ///\n    /// The resulting vector can be converted back into a box via\n    /// `Vec<T>`'s `into_boxed_slice` method.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s: Box<[i32]> = Box::new([10, 40, 30]);\n    /// let x = s.into_vec();\n    /// // `s` cannot be used anymore because it has been converted into `x`.\n    ///\n    /// assert_eq!(x, vec![10, 40, 30]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn into_vec(self: Box<Self>) -> Vec<T> {\n        // NB see hack module in this file\n        hack::into_vec(self)\n    }\n\n    /// Creates a vector by repeating a slice `n` times.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if the capacity would overflow.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// #![feature(repeat_generic_slice)]\n    ///\n    /// fn main() {\n    ///     assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);\n    /// }\n    /// ```\n    ///\n    /// A panic upon overflow:\n    ///\n    /// ```should_panic\n    /// #![feature(repeat_generic_slice)]\n    /// fn main() {\n    ///     // this will panic at runtime\n    ///     b\"0123456789abcdef\".repeat(usize::max_value());\n    /// }\n    /// ```\n    #[unstable(feature = \"repeat_generic_slice\",\n               reason = \"it's on str, why not on slice?\",\n               issue = \"48784\")]\n    pub fn repeat(&self, n: usize) -> Vec<T> where T: Copy {\n        if n == 0 {\n            return Vec::new();\n        }\n\n        // If `n` is larger than zero, it can be split as\n        // `n = 2^expn + rem (2^expn > rem, expn >= 0, rem >= 0)`.\n        // `2^expn` is the number represented by the leftmost '1' bit of `n`,\n        // and `rem` is the remaining part of `n`.\n\n        // Using `Vec` to access `set_len()`.\n        let mut buf = Vec::with_capacity(self.len().checked_mul(n).expect(\"capacity overflow\"));\n\n        // `2^expn` repetition is done by doubling `buf` `expn`-times.\n        buf.extend(self);\n        {\n            let mut m = n >> 1;\n            // If `m > 0`, there are remaining bits up to the leftmost '1'.\n            while m > 0 {\n                // `buf.extend(buf)`:\n                unsafe {\n                    ptr::copy_nonoverlapping(\n                        buf.as_ptr(),\n                        (buf.as_mut_ptr() as *mut T).add(buf.len()),\n                        buf.len(),\n                    );\n                    // `buf` has capacity of `self.len() * n`.\n                    let buf_len = buf.len();\n                    buf.set_len(buf_len * 2);\n                }\n\n                m >>= 1;\n            }\n        }\n\n        // `rem` (`= n - 2^expn`) repetition is done by copying\n        // first `rem` repetitions from `buf` itself.\n        let rem_len = self.len() * n - buf.len(); // `self.len() * rem`\n        if rem_len > 0 {\n            // `buf.extend(buf[0 .. rem_len])`:\n            unsafe {\n                // This is non-overlapping since `2^expn > rem`.\n                ptr::copy_nonoverlapping(\n                    buf.as_ptr(),\n                    (buf.as_mut_ptr() as *mut T).add(buf.len()),\n                    rem_len,\n                );\n                // `buf.len() + rem_len` equals to `buf.capacity()` (`= self.len() * n`).\n                let buf_cap = buf.capacity();\n                buf.set_len(buf_cap);\n            }\n        }\n        buf\n    }\n}\n\n#[lang = \"slice_u8_alloc\"]\n#[cfg(not(test))]\nimpl [u8] {\n    /// Returns a vector containing a copy of this slice where each byte\n    /// is mapped to its ASCII upper case equivalent.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To uppercase the value in-place, use [`make_ascii_uppercase`].\n    ///\n    /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_uppercase(&self) -> Vec<u8> {\n        let mut me = self.to_vec();\n        me.make_ascii_uppercase();\n        me\n    }\n\n    /// Returns a vector containing a copy of this slice where each byte\n    /// is mapped to its ASCII lower case equivalent.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To lowercase the value in-place, use [`make_ascii_lowercase`].\n    ///\n    /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_lowercase(&self) -> Vec<u8> {\n        let mut me = self.to_vec();\n        me.make_ascii_lowercase();\n        me\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Extension traits for slices over specific kinds of data\n////////////////////////////////////////////////////////////////////////////////\n#[unstable(feature = \"slice_concat_ext\",\n           reason = \"trait should not have to exist\",\n           issue = \"27747\")]\n/// An extension trait for concatenating slices\n///\n/// While this trait is unstable, the methods are stable. `SliceConcatExt` is\n/// included in the [standard library prelude], so you can use [`join()`] and\n/// [`concat()`] as if they existed on `[T]` itself.\n///\n/// [standard library prelude]: ../../std/prelude/index.html\n/// [`join()`]: #tymethod.join\n/// [`concat()`]: #tymethod.concat\npub trait SliceConcatExt<T: ?Sized> {\n    #[unstable(feature = \"slice_concat_ext\",\n               reason = \"trait should not have to exist\",\n               issue = \"27747\")]\n    /// The resulting type after concatenation\n    type Output;\n\n    /// Flattens a slice of `T` into a single value `Self::Output`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!([\"hello\", \"world\"].concat(), \"helloworld\");\n    /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn concat(&self) -> Self::Output;\n\n    /// Flattens a slice of `T` into a single value `Self::Output`, placing a\n    /// given separator between each.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_eq!([\"hello\", \"world\"].join(\" \"), \"hello world\");\n    /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);\n    /// ```\n    #[stable(feature = \"rename_connect_to_join\", since = \"1.3.0\")]\n    fn join(&self, sep: &T) -> Self::Output;\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.3.0\", reason = \"renamed to join\")]\n    fn connect(&self, sep: &T) -> Self::Output;\n}\n\n#[unstable(feature = \"slice_concat_ext\",\n           reason = \"trait should not have to exist\",\n           issue = \"27747\")]\nimpl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {\n    type Output = Vec<T>;\n\n    fn concat(&self) -> Vec<T> {\n        let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());\n        let mut result = Vec::with_capacity(size);\n        for v in self {\n            result.extend_from_slice(v.borrow())\n        }\n        result\n    }\n\n    fn join(&self, sep: &T) -> Vec<T> {\n        let mut iter = self.iter();\n        let first = match iter.next() {\n            Some(first) => first,\n            None => return vec![],\n        };\n        let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());\n        let mut result = Vec::with_capacity(size + self.len());\n        result.extend_from_slice(first.borrow());\n\n        for v in iter {\n            result.push(sep.clone());\n            result.extend_from_slice(v.borrow())\n        }\n        result\n    }\n\n    fn connect(&self, sep: &T) -> Vec<T> {\n        self.join(sep)\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Standard trait implementations for slices\n////////////////////////////////////////////////////////////////////////////////\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Borrow<[T]> for Vec<T> {\n    fn borrow(&self) -> &[T] {\n        &self[..]\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> BorrowMut<[T]> for Vec<T> {\n    fn borrow_mut(&mut self) -> &mut [T] {\n        &mut self[..]\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Clone> ToOwned for [T] {\n    type Owned = Vec<T>;\n    #[cfg(not(test))]\n    fn to_owned(&self) -> Vec<T> {\n        self.to_vec()\n    }\n\n    #[cfg(test)]\n    fn to_owned(&self) -> Vec<T> {\n        hack::to_vec(self)\n    }\n\n    fn clone_into(&self, target: &mut Vec<T>) {\n        // drop anything in target that will not be overwritten\n        target.truncate(self.len());\n        let len = target.len();\n\n        // reuse the contained values' allocations/resources.\n        target.clone_from_slice(&self[..len]);\n\n        // target.len <= self.len due to the truncate above, so the\n        // slice here is always in-bounds.\n        target.extend_from_slice(&self[len..]);\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Sorting\n////////////////////////////////////////////////////////////////////////////////\n\n/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.\n///\n/// This is the integral subroutine of insertion sort.\nfn insert_head<T, F>(v: &mut [T], is_less: &mut F)\n    where F: FnMut(&T, &T) -> bool\n{\n    if v.len() >= 2 && is_less(&v[1], &v[0]) {\n        unsafe {\n            // There are three ways to implement insertion here:\n            //\n            // 1. Swap adjacent elements until the first one gets to its final destination.\n            //    However, this way we copy data around more than is necessary. If elements are big\n            //    structures (costly to copy), this method will be slow.\n            //\n            // 2. Iterate until the right place for the first element is found. Then shift the\n            //    elements succeeding it to make room for it and finally place it into the\n            //    remaining hole. This is a good method.\n            //\n            // 3. Copy the first element into a temporary variable. Iterate until the right place\n            //    for it is found. As we go along, copy every traversed element into the slot\n            //    preceding it. Finally, copy data from the temporary variable into the remaining\n            //    hole. This method is very good. Benchmarks demonstrated slightly better\n            //    performance than with the 2nd method.\n            //\n            // All methods were benchmarked, and the 3rd showed best results. So we chose that one.\n            let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));\n\n            // Intermediate state of the insertion process is always tracked by `hole`, which\n            // serves two purposes:\n            // 1. Protects integrity of `v` from panics in `is_less`.\n            // 2. Fills the remaining hole in `v` in the end.\n            //\n            // Panic safety:\n            //\n            // If `is_less` panics at any point during the process, `hole` will get dropped and\n            // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it\n            // initially held exactly once.\n            let mut hole = InsertionHole {\n                src: &mut *tmp,\n                dest: &mut v[1],\n            };\n            ptr::copy_nonoverlapping(&v[1], &mut v[0], 1);\n\n            for i in 2..v.len() {\n                if !is_less(&v[i], &*tmp) {\n                    break;\n                }\n                ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1);\n                hole.dest = &mut v[i];\n            }\n            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.\n        }\n    }\n\n    // When dropped, copies from `src` into `dest`.\n    struct InsertionHole<T> {\n        src: *mut T,\n        dest: *mut T,\n    }\n\n    impl<T> Drop for InsertionHole<T> {\n        fn drop(&mut self) {\n            unsafe { ptr::copy_nonoverlapping(self.src, self.dest, 1); }\n        }\n    }\n}\n\n/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and\n/// stores the result into `v[..]`.\n///\n/// # Safety\n///\n/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough\n/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.\nunsafe fn merge<T, F>(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F)\n    where F: FnMut(&T, &T) -> bool\n{\n    let len = v.len();\n    let v = v.as_mut_ptr();\n    let v_mid = v.add(mid);\n    let v_end = v.add(len);\n\n    // The merge process first copies the shorter run into `buf`. Then it traces the newly copied\n    // run and the longer run forwards (or backwards), comparing their next unconsumed elements and\n    // copying the lesser (or greater) one into `v`.\n    //\n    // As soon as the shorter run is fully consumed, the process is done. If the longer run gets\n    // consumed first, then we must copy whatever is left of the shorter run into the remaining\n    // hole in `v`.\n    //\n    // Intermediate state of the process is always tracked by `hole`, which serves two purposes:\n    // 1. Protects integrity of `v` from panics in `is_less`.\n    // 2. Fills the remaining hole in `v` if the longer run gets consumed first.\n    //\n    // Panic safety:\n    //\n    // If `is_less` panics at any point during the process, `hole` will get dropped and fill the\n    // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every\n    // object it initially held exactly once.\n    let mut hole;\n\n    if mid <= len - mid {\n        // The left run is shorter.\n        ptr::copy_nonoverlapping(v, buf, mid);\n        hole = MergeHole {\n            start: buf,\n            end: buf.add(mid),\n            dest: v,\n        };\n\n        // Initially, these pointers point to the beginnings of their arrays.\n        let left = &mut hole.start;\n        let mut right = v_mid;\n        let out = &mut hole.dest;\n\n        while *left < hole.end && right < v_end {\n            // Consume the lesser side.\n            // If equal, prefer the left run to maintain stability.\n            let to_copy = if is_less(&*right, &**left) {\n                get_and_increment(&mut right)\n            } else {\n                get_and_increment(left)\n            };\n            ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1);\n        }\n    } else {\n        // The right run is shorter.\n        ptr::copy_nonoverlapping(v_mid, buf, len - mid);\n        hole = MergeHole {\n            start: buf,\n            end: buf.add(len - mid),\n            dest: v_mid,\n        };\n\n        // Initially, these pointers point past the ends of their arrays.\n        let left = &mut hole.dest;\n        let right = &mut hole.end;\n        let mut out = v_end;\n\n        while v < *left && buf < *right {\n            // Consume the greater side.\n            // If equal, prefer the right run to maintain stability.\n            let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {\n                decrement_and_get(left)\n            } else {\n                decrement_and_get(right)\n            };\n            ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1);\n        }\n    }\n    // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of\n    // it will now be copied into the hole in `v`.\n\n    unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {\n        let old = *ptr;\n        *ptr = ptr.offset(1);\n        old\n    }\n\n    unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {\n        *ptr = ptr.offset(-1);\n        *ptr\n    }\n\n    // When dropped, copies the range `start..end` into `dest..`.\n    struct MergeHole<T> {\n        start: *mut T,\n        end: *mut T,\n        dest: *mut T,\n    }\n\n    impl<T> Drop for MergeHole<T> {\n        fn drop(&mut self) {\n            // `T` is not a zero-sized type, so it's okay to divide by its size.\n            let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();\n            unsafe { ptr::copy_nonoverlapping(self.start, self.dest, len); }\n        }\n    }\n}\n\n/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail\n/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt).\n///\n/// The algorithm identifies strictly descending and non-descending subsequences, which are called\n/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed\n/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are\n/// satisfied:\n///\n/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`\n/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`\n///\n/// The invariants ensure that the total running time is `O(n log n)` worst-case.\nfn merge_sort<T, F>(v: &mut [T], mut is_less: F)\n    where F: FnMut(&T, &T) -> bool\n{\n    // Slices of up to this length get sorted using insertion sort.\n    const MAX_INSERTION: usize = 20;\n    // Very short runs are extended using insertion sort to span at least this many elements.\n    const MIN_RUN: usize = 10;\n\n    // Sorting has no meaningful behavior on zero-sized types.\n    if size_of::<T>() == 0 {\n        return;\n    }\n\n    let len = v.len();\n\n    // Short arrays get sorted in-place via insertion sort to avoid allocations.\n    if len <= MAX_INSERTION {\n        if len >= 2 {\n            for i in (0..len-1).rev() {\n                insert_head(&mut v[i..], &mut is_less);\n            }\n        }\n        return;\n    }\n\n    // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it\n    // shallow copies of the contents of `v` without risking the dtors running on copies if\n    // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,\n    // which will always have length at most `len / 2`.\n    let mut buf = Vec::with_capacity(len / 2);\n\n    // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a\n    // strange decision, but consider the fact that merges more often go in the opposite direction\n    // (forwards). According to benchmarks, merging forwards is slightly faster than merging\n    // backwards. To conclude, identifying runs by traversing backwards improves performance.\n    let mut runs = vec![];\n    let mut end = len;\n    while end > 0 {\n        // Find the next natural run, and reverse it if it's strictly descending.\n        let mut start = end - 1;\n        if start > 0 {\n            start -= 1;\n            unsafe {\n                if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) {\n                    while start > 0 && is_less(v.get_unchecked(start),\n                                               v.get_unchecked(start - 1)) {\n                        start -= 1;\n                    }\n                    v[start..end].reverse();\n                } else {\n                    while start > 0 && !is_less(v.get_unchecked(start),\n                                                v.get_unchecked(start - 1)) {\n                        start -= 1;\n                    }\n                }\n            }\n        }\n\n        // Insert some more elements into the run if it's too short. Insertion sort is faster than\n        // merge sort on short sequences, so this significantly improves performance.\n        while start > 0 && end - start < MIN_RUN {\n            start -= 1;\n            insert_head(&mut v[start..end], &mut is_less);\n        }\n\n        // Push this run onto the stack.\n        runs.push(Run {\n            start,\n            len: end - start,\n        });\n        end = start;\n\n        // Merge some pairs of adjacent runs to satisfy the invariants.\n        while let Some(r) = collapse(&runs) {\n            let left = runs[r + 1];\n            let right = runs[r];\n            unsafe {\n                merge(&mut v[left.start .. right.start + right.len], left.len, buf.as_mut_ptr(),\n                      &mut is_less);\n            }\n            runs[r] = Run {\n                start: left.start,\n                len: left.len + right.len,\n            };\n            runs.remove(r + 1);\n        }\n    }\n\n    // Finally, exactly one run must remain in the stack.\n    debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);\n\n    // Examines the stack of runs and identifies the next pair of runs to merge. More specifically,\n    // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the\n    // algorithm should continue building a new run instead, `None` is returned.\n    //\n    // TimSort is infamous for its buggy implementations, as described here:\n    // http://envisage-project.eu/timsort-specification-and-verification/\n    //\n    // The gist of the story is: we must enforce the invariants on the top four runs on the stack.\n    // Enforcing them on just top three is not sufficient to ensure that the invariants will still\n    // hold for *all* runs in the stack.\n    //\n    // This function correctly checks invariants for the top four runs. Additionally, if the top\n    // run starts at index 0, it will always demand a merge operation until the stack is fully\n    // collapsed, in order to complete the sort.\n    #[inline]\n    fn collapse(runs: &[Run]) -> Option<usize> {\n        let n = runs.len();\n        if n >= 2 && (runs[n - 1].start == 0 ||\n                      runs[n - 2].len <= runs[n - 1].len ||\n                      (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len) ||\n                      (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len)) {\n            if n >= 3 && runs[n - 3].len < runs[n - 1].len {\n                Some(n - 3)\n            } else {\n                Some(n - 2)\n            }\n        } else {\n            None\n        }\n    }\n\n    #[derive(Clone, Copy)]\n    struct Run {\n        start: usize,\n        len: usize,\n    }\n}\n","// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Unicode string slices.\n//!\n//! *[See also the `str` primitive type](../../std/primitive.str.html).*\n//!\n//! The `&str` type is one of the two main string types, the other being `String`.\n//! Unlike its `String` counterpart, its contents are borrowed.\n//!\n//! # Basic Usage\n//!\n//! A basic string declaration of `&str` type:\n//!\n//! ```\n//! let hello_world = \"Hello, World!\";\n//! ```\n//!\n//! Here we have declared a string literal, also known as a string slice.\n//! String literals have a static lifetime, which means the string `hello_world`\n//! is guaranteed to be valid for the duration of the entire program.\n//! We can explicitly specify `hello_world`'s lifetime as well:\n//!\n//! ```\n//! let hello_world: &'static str = \"Hello, world!\";\n//! ```\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n// Many of the usings in this module are only used in the test configuration.\n// It's cleaner to just turn off the unused_imports warning than to fix them.\n#![allow(unused_imports)]\n\nuse core::fmt;\nuse core::str as core_str;\nuse core::str::pattern::Pattern;\nuse core::str::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};\nuse core::mem;\nuse core::ptr;\nuse core::iter::FusedIterator;\nuse core::unicode::conversions;\n\nuse borrow::{Borrow, ToOwned};\nuse boxed::Box;\nuse slice::{SliceConcatExt, SliceIndex};\nuse string::String;\nuse vec::Vec;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{FromStr, Utf8Error};\n#[allow(deprecated)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{Lines, LinesAny};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{Split, RSplit};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{SplitN, RSplitN};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{SplitTerminator, RSplitTerminator};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{Matches, RMatches};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{MatchIndices, RMatchIndices};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{from_utf8, from_utf8_mut, Chars, CharIndices, Bytes};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::SplitWhitespace;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::str::pattern;\n#[stable(feature = \"encode_utf16\", since = \"1.8.0\")]\npub use core::str::EncodeUtf16;\n#[unstable(feature = \"split_ascii_whitespace\", issue = \"48656\")]\npub use core::str::SplitAsciiWhitespace;\n\n#[unstable(feature = \"slice_concat_ext\",\n           reason = \"trait should not have to exist\",\n           issue = \"27747\")]\nimpl<S: Borrow<str>> SliceConcatExt<str> for [S] {\n    type Output = String;\n\n    fn concat(&self) -> String {\n        self.join(\"\")\n    }\n\n    fn join(&self, sep: &str) -> String {\n        unsafe {\n            String::from_utf8_unchecked( join_generic_copy(self, sep.as_bytes()) )\n        }\n    }\n\n    fn connect(&self, sep: &str) -> String {\n        self.join(sep)\n    }\n}\n\nmacro_rules! spezialize_for_lengths {\n    ($separator:expr, $target:expr, $iter:expr; $($num:expr),*) => {\n        let mut target = $target;\n        let iter = $iter;\n        let sep_bytes = $separator;\n        match $separator.len() {\n            $(\n                // loops with hardcoded sizes run much faster\n                // specialize the cases with small separator lengths\n                $num => {\n                    for s in iter {\n                        copy_slice_and_advance!(target, sep_bytes);\n                        copy_slice_and_advance!(target, s.borrow().as_ref());\n                    }\n                },\n            )*\n            _ => {\n                // arbitrary non-zero size fallback\n                for s in iter {\n                    copy_slice_and_advance!(target, sep_bytes);\n                    copy_slice_and_advance!(target, s.borrow().as_ref());\n                }\n            }\n        }\n    };\n}\n\nmacro_rules! copy_slice_and_advance {\n    ($target:expr, $bytes:expr) => {\n        let len = $bytes.len();\n        let (head, tail) = {$target}.split_at_mut(len);\n        head.copy_from_slice($bytes);\n        $target = tail;\n    }\n}\n\n// Optimized join implementation that works for both Vec<T> (T: Copy) and String's inner vec\n// Currently (2018-05-13) there is a bug with type inference and specialization (see issue #36262)\n// For this reason SliceConcatExt<T> is not specialized for T: Copy and SliceConcatExt<str> is the\n// only user of this function. It is left in place for the time when that is fixed.\n//\n// the bounds for String-join are S: Borrow<str> and for Vec-join Borrow<[T]>\n// [T] and str both impl AsRef<[T]> for some T\n// => s.borrow().as_ref() and we always have slices\nfn join_generic_copy<B, T, S>(slice: &[S], sep: &[T]) -> Vec<T>\nwhere\n    T: Copy,\n    B: AsRef<[T]> + ?Sized,\n    S: Borrow<B>,\n{\n    let sep_len = sep.len();\n    let mut iter = slice.iter();\n\n    // the first slice is the only one without a separator preceding it\n    let first = match iter.next() {\n        Some(first) => first,\n        None => return vec![],\n    };\n\n    // compute the exact total length of the joined Vec\n    // if the `len` calculation overflows, we'll panic\n    // we would have run out of memory anyway and the rest of the function requires\n    // the entire Vec pre-allocated for safety\n    let len =  sep_len.checked_mul(iter.len()).and_then(|n| {\n            slice.iter()\n                .map(|s| s.borrow().as_ref().len())\n                .try_fold(n, usize::checked_add)\n        }).expect(\"attempt to join into collection with len > usize::MAX\");\n\n    // crucial for safety\n    let mut result = Vec::with_capacity(len);\n    assert!(result.capacity() >= len);\n\n    result.extend_from_slice(first.borrow().as_ref());\n\n    unsafe {\n        {\n            let pos = result.len();\n            let target = result.get_unchecked_mut(pos..len);\n\n            // copy separator and slices over without bounds checks\n            // generate loops with hardcoded offsets for small separators\n            // massive improvements possible (~ x2)\n            spezialize_for_lengths!(sep, target, iter; 0, 1, 2, 3, 4);\n        }\n        result.set_len(len);\n    }\n    result\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Borrow<str> for String {\n    #[inline]\n    fn borrow(&self) -> &str {\n        &self[..]\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToOwned for str {\n    type Owned = String;\n    #[inline]\n    fn to_owned(&self) -> String {\n        unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) }\n    }\n\n    fn clone_into(&self, target: &mut String) {\n        let mut b = mem::replace(target, String::new()).into_bytes();\n        self.as_bytes().clone_into(&mut b);\n        *target = unsafe { String::from_utf8_unchecked(b) }\n    }\n}\n\n/// Methods for string slices.\n#[lang = \"str_alloc\"]\n#[cfg(not(test))]\nimpl str {\n    /// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"this is a string\";\n    /// let boxed_str = s.to_owned().into_boxed_str();\n    /// let boxed_bytes = boxed_str.into_boxed_bytes();\n    /// assert_eq!(*boxed_bytes, *s.as_bytes());\n    /// ```\n    #[stable(feature = \"str_box_extras\", since = \"1.20.0\")]\n    #[inline]\n    pub fn into_boxed_bytes(self: Box<str>) -> Box<[u8]> {\n        self.into()\n    }\n\n    /// Replaces all matches of a pattern with another string.\n    ///\n    /// `replace` creates a new [`String`], and copies the data from this string slice into it.\n    /// While doing so, it attempts to find matches of a pattern. If it finds any, it\n    /// replaces them with the replacement string slice.\n    ///\n    /// [`String`]: string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"this is old\";\n    ///\n    /// assert_eq!(\"this is new\", s.replace(\"old\", \"new\"));\n    /// ```\n    ///\n    /// When the pattern doesn't match:\n    ///\n    /// ```\n    /// let s = \"this is old\";\n    /// assert_eq!(s, s.replace(\"cookie monster\", \"little lamb\"));\n    /// ```\n    #[must_use = \"this returns the replaced string as a new allocation, \\\n                  without modifying the original\"]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {\n        let mut result = String::new();\n        let mut last_end = 0;\n        for (start, part) in self.match_indices(from) {\n            result.push_str(unsafe { self.get_unchecked(last_end..start) });\n            result.push_str(to);\n            last_end = start + part.len();\n        }\n        result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });\n        result\n    }\n\n    /// Replaces first N matches of a pattern with another string.\n    ///\n    /// `replacen` creates a new [`String`], and copies the data from this string slice into it.\n    /// While doing so, it attempts to find matches of a pattern. If it finds any, it\n    /// replaces them with the replacement string slice at most `count` times.\n    ///\n    /// [`String`]: string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"foo foo 123 foo\";\n    /// assert_eq!(\"new new 123 foo\", s.replacen(\"foo\", \"new\", 2));\n    /// assert_eq!(\"faa fao 123 foo\", s.replacen('o', \"a\", 3));\n    /// assert_eq!(\"foo foo new23 foo\", s.replacen(char::is_numeric, \"new\", 1));\n    /// ```\n    ///\n    /// When the pattern doesn't match:\n    ///\n    /// ```\n    /// let s = \"this is old\";\n    /// assert_eq!(s, s.replacen(\"cookie monster\", \"little lamb\", 10));\n    /// ```\n    #[must_use = \"this returns the replaced string as a new allocation, \\\n                  without modifying the original\"]\n    #[stable(feature = \"str_replacen\", since = \"1.16.0\")]\n    pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String {\n        // Hope to reduce the times of re-allocation\n        let mut result = String::with_capacity(32);\n        let mut last_end = 0;\n        for (start, part) in self.match_indices(pat).take(count) {\n            result.push_str(unsafe { self.get_unchecked(last_end..start) });\n            result.push_str(to);\n            last_end = start + part.len();\n        }\n        result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });\n        result\n    }\n\n    /// Returns the lowercase equivalent of this string slice, as a new [`String`].\n    ///\n    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property\n    /// `Lowercase`.\n    ///\n    /// Since some characters can expand into multiple characters when changing\n    /// the case, this function returns a [`String`] instead of modifying the\n    /// parameter in-place.\n    ///\n    /// [`String`]: string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"HELLO\";\n    ///\n    /// assert_eq!(\"hello\", s.to_lowercase());\n    /// ```\n    ///\n    /// A tricky example, with sigma:\n    ///\n    /// ```\n    /// let sigma = \"\u03a3\";\n    ///\n    /// assert_eq!(\"\u03c3\", sigma.to_lowercase());\n    ///\n    /// // but at the end of a word, it's \u03c2, not \u03c3:\n    /// let odysseus = \"\u1f48\u0394\u03a5\u03a3\u03a3\u0395\u038e\u03a3\";\n    ///\n    /// assert_eq!(\"\u1f40\u03b4\u03c5\u03c3\u03c3\u03b5\u03cd\u03c2\", odysseus.to_lowercase());\n    /// ```\n    ///\n    /// Languages without case are not changed:\n    ///\n    /// ```\n    /// let new_year = \"\u519c\u5386\u65b0\u5e74\";\n    ///\n    /// assert_eq!(new_year, new_year.to_lowercase());\n    /// ```\n    #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")]\n    pub fn to_lowercase(&self) -> String {\n        let mut s = String::with_capacity(self.len());\n        for (i, c) in self[..].char_indices() {\n            if c == '\u03a3' {\n                // \u03a3 maps to \u03c3, except at the end of a word where it maps to \u03c2.\n                // This is the only conditional (contextual) but language-independent mapping\n                // in `SpecialCasing.txt`,\n                // so hard-code it rather than have a generic \"condition\" mechanism.\n                // See https://github.com/rust-lang/rust/issues/26035\n                map_uppercase_sigma(self, i, &mut s)\n            } else {\n                match conversions::to_lower(c) {\n                    [a, '\\0', _] => s.push(a),\n                    [a, b, '\\0'] => {\n                        s.push(a);\n                        s.push(b);\n                    }\n                    [a, b, c] => {\n                        s.push(a);\n                        s.push(b);\n                        s.push(c);\n                    }\n                }\n            }\n        }\n        return s;\n\n        fn map_uppercase_sigma(from: &str, i: usize, to: &mut String) {\n            // See http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992\n            // for the definition of `Final_Sigma`.\n            debug_assert!('\u03a3'.len_utf8() == 2);\n            let is_word_final = case_ignoreable_then_cased(from[..i].chars().rev()) &&\n                                !case_ignoreable_then_cased(from[i + 2..].chars());\n            to.push_str(if is_word_final { \"\u03c2\" } else { \"\u03c3\" });\n        }\n\n        fn case_ignoreable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {\n            use core::unicode::derived_property::{Cased, Case_Ignorable};\n            match iter.skip_while(|&c| Case_Ignorable(c)).next() {\n                Some(c) => Cased(c),\n                None => false,\n            }\n        }\n    }\n\n    /// Returns the uppercase equivalent of this string slice, as a new [`String`].\n    ///\n    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property\n    /// `Uppercase`.\n    ///\n    /// Since some characters can expand into multiple characters when changing\n    /// the case, this function returns a [`String`] instead of modifying the\n    /// parameter in-place.\n    ///\n    /// [`String`]: string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s = \"hello\";\n    ///\n    /// assert_eq!(\"HELLO\", s.to_uppercase());\n    /// ```\n    ///\n    /// Scripts without case are not changed:\n    ///\n    /// ```\n    /// let new_year = \"\u519c\u5386\u65b0\u5e74\";\n    ///\n    /// assert_eq!(new_year, new_year.to_uppercase());\n    /// ```\n    #[stable(feature = \"unicode_case_mapping\", since = \"1.2.0\")]\n    pub fn to_uppercase(&self) -> String {\n        let mut s = String::with_capacity(self.len());\n        for c in self[..].chars() {\n            match conversions::to_upper(c) {\n                [a, '\\0', _] => s.push(a),\n                [a, b, '\\0'] => {\n                    s.push(a);\n                    s.push(b);\n                }\n                [a, b, c] => {\n                    s.push(a);\n                    s.push(b);\n                    s.push(c);\n                }\n            }\n        }\n        return s;\n    }\n\n    /// Escapes each char in `s` with [`char::escape_debug`].\n    ///\n    /// Note: only extended grapheme codepoints that begin the string will be\n    /// escaped.\n    ///\n    /// [`char::escape_debug`]: primitive.char.html#method.escape_debug\n    #[unstable(feature = \"str_escape\",\n               reason = \"return type may change to be an iterator\",\n               issue = \"27791\")]\n    pub fn escape_debug(&self) -> String {\n        let mut string = String::with_capacity(self.len());\n        let mut chars = self.chars();\n        if let Some(first) = chars.next() {\n            string.extend(first.escape_debug_ext(true))\n        }\n        string.extend(chars.flat_map(|c| c.escape_debug_ext(false)));\n        string\n    }\n\n    /// Escapes each char in `s` with [`char::escape_default`].\n    ///\n    /// [`char::escape_default`]: primitive.char.html#method.escape_default\n    #[unstable(feature = \"str_escape\",\n               reason = \"return type may change to be an iterator\",\n               issue = \"27791\")]\n    pub fn escape_default(&self) -> String {\n        self.chars().flat_map(|c| c.escape_default()).collect()\n    }\n\n    /// Escapes each char in `s` with [`char::escape_unicode`].\n    ///\n    /// [`char::escape_unicode`]: primitive.char.html#method.escape_unicode\n    #[unstable(feature = \"str_escape\",\n               reason = \"return type may change to be an iterator\",\n               issue = \"27791\")]\n    pub fn escape_unicode(&self) -> String {\n        self.chars().flat_map(|c| c.escape_unicode()).collect()\n    }\n\n    /// Converts a [`Box<str>`] into a [`String`] without copying or allocating.\n    ///\n    /// [`String`]: string/struct.String.html\n    /// [`Box<str>`]: boxed/struct.Box.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let string = String::from(\"birthday gift\");\n    /// let boxed_str = string.clone().into_boxed_str();\n    ///\n    /// assert_eq!(boxed_str.into_string(), string);\n    /// ```\n    #[stable(feature = \"box_str\", since = \"1.4.0\")]\n    #[inline]\n    pub fn into_string(self: Box<str>) -> String {\n        let slice = Box::<[u8]>::from(self);\n        unsafe { String::from_utf8_unchecked(slice.into_vec()) }\n    }\n\n    /// Creates a new [`String`] by repeating a string `n` times.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if the capacity would overflow.\n    ///\n    /// [`String`]: string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// assert_eq!(\"abc\".repeat(4), String::from(\"abcabcabcabc\"));\n    /// ```\n    ///\n    /// A panic upon overflow:\n    ///\n    /// ```should_panic\n    /// fn main() {\n    ///     // this will panic at runtime\n    ///     \"0123456789abcdef\".repeat(usize::max_value());\n    /// }\n    /// ```\n    #[stable(feature = \"repeat_str\", since = \"1.16.0\")]\n    pub fn repeat(&self, n: usize) -> String {\n        unsafe { String::from_utf8_unchecked(self.as_bytes().repeat(n)) }\n    }\n\n    /// Returns a copy of this string where each character is mapped to its\n    /// ASCII upper case equivalent.\n    ///\n    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To uppercase the value in-place, use [`make_ascii_uppercase`].\n    ///\n    /// To uppercase ASCII characters in addition to non-ASCII characters, use\n    /// [`to_uppercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s = \"Gr\u00fc\u00dfe, J\u00fcrgen \u2764\";\n    ///\n    /// assert_eq!(\"GR\u00fc\u00dfE, J\u00fcRGEN \u2764\", s.to_ascii_uppercase());\n    /// ```\n    ///\n    /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase\n    /// [`to_uppercase`]: #method.to_uppercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_uppercase(&self) -> String {\n        let mut bytes = self.as_bytes().to_vec();\n        bytes.make_ascii_uppercase();\n        // make_ascii_uppercase() preserves the UTF-8 invariant.\n        unsafe { String::from_utf8_unchecked(bytes) }\n    }\n\n    /// Returns a copy of this string where each character is mapped to its\n    /// ASCII lower case equivalent.\n    ///\n    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',\n    /// but non-ASCII letters are unchanged.\n    ///\n    /// To lowercase the value in-place, use [`make_ascii_lowercase`].\n    ///\n    /// To lowercase ASCII characters in addition to non-ASCII characters, use\n    /// [`to_lowercase`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// let s = \"Gr\u00fc\u00dfe, J\u00fcrgen \u2764\";\n    ///\n    /// assert_eq!(\"gr\u00fc\u00dfe, j\u00fcrgen \u2764\", s.to_ascii_lowercase());\n    /// ```\n    ///\n    /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase\n    /// [`to_lowercase`]: #method.to_lowercase\n    #[stable(feature = \"ascii_methods_on_intrinsics\", since = \"1.23.0\")]\n    #[inline]\n    pub fn to_ascii_lowercase(&self) -> String {\n        let mut bytes = self.as_bytes().to_vec();\n        bytes.make_ascii_lowercase();\n        // make_ascii_lowercase() preserves the UTF-8 invariant.\n        unsafe { String::from_utf8_unchecked(bytes) }\n    }\n}\n\n/// Converts a boxed slice of bytes to a boxed string slice without checking\n/// that the string contains valid UTF-8.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// let smile_utf8 = Box::new([226, 152, 186]);\n/// let smile = unsafe { std::str::from_boxed_utf8_unchecked(smile_utf8) };\n///\n/// assert_eq!(\"\u263a\", &*smile);\n/// ```\n#[stable(feature = \"str_box_extras\", since = \"1.20.0\")]\n#[inline]\npub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str> {\n    Box::from_raw(Box::into_raw(v) as *mut str)\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A module for working with borrowed data.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse core::cmp::Ordering;\nuse core::hash::{Hash, Hasher};\nuse core::ops::{Add, AddAssign, Deref};\n\nuse fmt;\nuse string::String;\n\nuse self::Cow::*;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use core::borrow::{Borrow, BorrowMut};\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>\n    where B: ToOwned,\n          <B as ToOwned>::Owned: 'a\n{\n    fn borrow(&self) -> &B {\n        &**self\n    }\n}\n\n/// A generalization of `Clone` to borrowed data.\n///\n/// Some types make it possible to go from borrowed to owned, usually by\n/// implementing the `Clone` trait. But `Clone` works only for going from `&T`\n/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data\n/// from any borrow of a given type.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait ToOwned {\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Owned: Borrow<Self>;\n\n    /// Creates owned data from borrowed data, usually by cloning.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// let s: &str = \"a\";\n    /// let ss: String = s.to_owned();\n    ///\n    /// let v: &[i32] = &[1, 2];\n    /// let vv: Vec<i32> = v.to_owned();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[must_use = \"cloning is often expensive and is not expected to have side effects\"]\n    fn to_owned(&self) -> Self::Owned;\n\n    /// Uses borrowed data to replace owned data, usually by cloning.\n    ///\n    /// This is borrow-generalized version of `Clone::clone_from`.\n    ///\n    /// # Examples\n    ///\n    /// Basic usage:\n    ///\n    /// ```\n    /// # #![feature(toowned_clone_into)]\n    /// let mut s: String = String::new();\n    /// \"hello\".clone_into(&mut s);\n    ///\n    /// let mut v: Vec<i32> = Vec::new();\n    /// [1, 2][..].clone_into(&mut v);\n    /// ```\n    #[unstable(feature = \"toowned_clone_into\",\n               reason = \"recently added\",\n               issue = \"41263\")]\n    fn clone_into(&self, target: &mut Self::Owned) {\n        *target = self.to_owned();\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> ToOwned for T\n    where T: Clone\n{\n    type Owned = T;\n    fn to_owned(&self) -> T {\n        self.clone()\n    }\n\n    fn clone_into(&self, target: &mut T) {\n        target.clone_from(self);\n    }\n}\n\n/// A clone-on-write smart pointer.\n///\n/// The type `Cow` is a smart pointer providing clone-on-write functionality: it\n/// can enclose and provide immutable access to borrowed data, and clone the\n/// data lazily when mutation or ownership is required. The type is designed to\n/// work with general borrowed data via the `Borrow` trait.\n///\n/// `Cow` implements `Deref`, which means that you can call\n/// non-mutating methods directly on the data it encloses. If mutation\n/// is desired, `to_mut` will obtain a mutable reference to an owned\n/// value, cloning if necessary.\n///\n/// # Examples\n///\n/// ```\n/// use std::borrow::Cow;\n///\n/// fn abs_all(input: &mut Cow<[i32]>) {\n///     for i in 0..input.len() {\n///         let v = input[i];\n///         if v < 0 {\n///             // Clones into a vector if not already owned.\n///             input.to_mut()[i] = -v;\n///         }\n///     }\n/// }\n///\n/// // No clone occurs because `input` doesn't need to be mutated.\n/// let slice = [0, 1, 2];\n/// let mut input = Cow::from(&slice[..]);\n/// abs_all(&mut input);\n///\n/// // Clone occurs because `input` needs to be mutated.\n/// let slice = [-1, 0, 1];\n/// let mut input = Cow::from(&slice[..]);\n/// abs_all(&mut input);\n///\n/// // No clone occurs because `input` is already owned.\n/// let mut input = Cow::from(vec![-1, 0, 1]);\n/// abs_all(&mut input);\n/// ```\n///\n/// Another example showing how to keep `Cow` in a struct:\n///\n/// ```\n/// use std::borrow::{Cow, ToOwned};\n///\n/// struct Items<'a, X: 'a> where [X]: ToOwned<Owned=Vec<X>> {\n///     values: Cow<'a, [X]>,\n/// }\n///\n/// impl<'a, X: Clone + 'a> Items<'a, X> where [X]: ToOwned<Owned=Vec<X>> {\n///     fn new(v: Cow<'a, [X]>) -> Self {\n///         Items { values: v }\n///     }\n/// }\n///\n/// // Creates a container from borrowed values of a slice\n/// let readonly = [1, 2];\n/// let borrowed = Items::new((&readonly[..]).into());\n/// match borrowed {\n///     Items { values: Cow::Borrowed(b) } => println!(\"borrowed {:?}\", b),\n///     _ => panic!(\"expect borrowed value\"),\n/// }\n///\n/// let mut clone_on_write = borrowed;\n/// // Mutates the data from slice into owned vec and pushes a new value on top\n/// clone_on_write.values.to_mut().push(3);\n/// println!(\"clone_on_write = {:?}\", clone_on_write.values);\n///\n/// // The data was mutated. Let check it out.\n/// match clone_on_write {\n///     Items { values: Cow::Owned(_) } => println!(\"clone_on_write contains owned data\"),\n///     _ => panic!(\"expect owned data\"),\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Cow<'a, B: ?Sized + 'a>\n    where B: ToOwned\n{\n    /// Borrowed data.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Borrowed(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n             &'a B),\n\n    /// Owned data.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Owned(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n          <B as ToOwned>::Owned),\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Clone for Cow<'a, B>\n    where B: ToOwned\n{\n    fn clone(&self) -> Cow<'a, B> {\n        match *self {\n            Borrowed(b) => Borrowed(b),\n            Owned(ref o) => {\n                let b: &B = o.borrow();\n                Owned(b.to_owned())\n            }\n        }\n    }\n\n    fn clone_from(&mut self, source: &Cow<'a, B>) {\n        if let Owned(ref mut dest) = *self {\n            if let Owned(ref o) = *source {\n                o.borrow().clone_into(dest);\n                return;\n            }\n        }\n\n        *self = source.clone();\n    }\n}\n\nimpl<'a, B: ?Sized> Cow<'a, B>\n    where B: ToOwned\n{\n    /// Acquires a mutable reference to the owned form of the data.\n    ///\n    /// Clones the data if it is not already owned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::borrow::Cow;\n    ///\n    /// let mut cow = Cow::Borrowed(\"foo\");\n    /// cow.to_mut().make_ascii_uppercase();\n    ///\n    /// assert_eq!(\n    ///   cow,\n    ///   Cow::Owned(String::from(\"FOO\")) as Cow<str>\n    /// );\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {\n        match *self {\n            Borrowed(borrowed) => {\n                *self = Owned(borrowed.to_owned());\n                match *self {\n                    Borrowed(..) => unreachable!(),\n                    Owned(ref mut owned) => owned,\n                }\n            }\n            Owned(ref mut owned) => owned,\n        }\n    }\n\n    /// Extracts the owned data.\n    ///\n    /// Clones the data if it is not already owned.\n    ///\n    /// # Examples\n    ///\n    /// Calling `into_owned` on a `Cow::Borrowed` clones the underlying data\n    /// and becomes a `Cow::Owned`:\n    ///\n    /// ```\n    /// use std::borrow::Cow;\n    ///\n    /// let s = \"Hello world!\";\n    /// let cow = Cow::Borrowed(s);\n    ///\n    /// assert_eq!(\n    ///   cow.into_owned(),\n    ///   String::from(s)\n    /// );\n    /// ```\n    ///\n    /// Calling `into_owned` on a `Cow::Owned` is a no-op:\n    ///\n    /// ```\n    /// use std::borrow::Cow;\n    ///\n    /// let s = \"Hello world!\";\n    /// let cow: Cow<str> = Cow::Owned(String::from(s));\n    ///\n    /// assert_eq!(\n    ///   cow.into_owned(),\n    ///   String::from(s)\n    /// );\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_owned(self) -> <B as ToOwned>::Owned {\n        match self {\n            Borrowed(borrowed) => borrowed.to_owned(),\n            Owned(owned) => owned,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Deref for Cow<'a, B>\n    where B: ToOwned\n{\n    type Target = B;\n\n    fn deref(&self) -> &B {\n        match *self {\n            Borrowed(borrowed) => borrowed,\n            Owned(ref owned) => owned.borrow(),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Eq for Cow<'a, B> where B: Eq + ToOwned {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Ord for Cow<'a, B>\n    where B: Ord + ToOwned\n{\n    #[inline]\n    fn cmp(&self, other: &Cow<'a, B>) -> Ordering {\n        Ord::cmp(&**self, &**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, C>> for Cow<'a, B>\n    where B: PartialEq<C> + ToOwned,\n          C: ToOwned\n{\n    #[inline]\n    fn eq(&self, other: &Cow<'b, C>) -> bool {\n        PartialEq::eq(&**self, &**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> PartialOrd for Cow<'a, B>\n    where B: PartialOrd + ToOwned\n{\n    #[inline]\n    fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering> {\n        PartialOrd::partial_cmp(&**self, &**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> fmt::Debug for Cow<'a, B>\n    where B: fmt::Debug + ToOwned,\n          <B as ToOwned>::Owned: fmt::Debug\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            Borrowed(ref b) => fmt::Debug::fmt(b, f),\n            Owned(ref o) => fmt::Debug::fmt(o, f),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> fmt::Display for Cow<'a, B>\n    where B: fmt::Display + ToOwned,\n          <B as ToOwned>::Owned: fmt::Display\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            Borrowed(ref b) => fmt::Display::fmt(b, f),\n            Owned(ref o) => fmt::Display::fmt(o, f),\n        }\n    }\n}\n\n#[stable(feature = \"default\", since = \"1.11.0\")]\nimpl<'a, B: ?Sized> Default for Cow<'a, B>\n    where B: ToOwned,\n          <B as ToOwned>::Owned: Default\n{\n    /// Creates an owned Cow<'a, B> with the default value for the contained owned value.\n    fn default() -> Cow<'a, B> {\n        Owned(<B as ToOwned>::Owned::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: ?Sized> Hash for Cow<'a, B>\n    where B: Hash + ToOwned\n{\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        Hash::hash(&**self, state)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow(deprecated)]\nimpl<'a, T: ?Sized + ToOwned> AsRef<T> for Cow<'a, T> {\n    fn as_ref(&self) -> &T {\n        self\n    }\n}\n\n#[stable(feature = \"cow_add\", since = \"1.14.0\")]\nimpl<'a> Add<&'a str> for Cow<'a, str> {\n    type Output = Cow<'a, str>;\n\n    #[inline]\n    fn add(mut self, rhs: &'a str) -> Self::Output {\n        self += rhs;\n        self\n    }\n}\n\n#[stable(feature = \"cow_add\", since = \"1.14.0\")]\nimpl<'a> Add<Cow<'a, str>> for Cow<'a, str> {\n    type Output = Cow<'a, str>;\n\n    #[inline]\n    fn add(mut self, rhs: Cow<'a, str>) -> Self::Output {\n        self += rhs;\n        self\n    }\n}\n\n#[stable(feature = \"cow_add\", since = \"1.14.0\")]\nimpl<'a> AddAssign<&'a str> for Cow<'a, str> {\n    fn add_assign(&mut self, rhs: &'a str) {\n        if self.is_empty() {\n            *self = Cow::Borrowed(rhs)\n        } else if rhs.is_empty() {\n            return;\n        } else {\n            if let Cow::Borrowed(lhs) = *self {\n                let mut s = String::with_capacity(lhs.len() + rhs.len());\n                s.push_str(lhs);\n                *self = Cow::Owned(s);\n            }\n            self.to_mut().push_str(rhs);\n        }\n    }\n}\n\n#[stable(feature = \"cow_add\", since = \"1.14.0\")]\nimpl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {\n    fn add_assign(&mut self, rhs: Cow<'a, str>) {\n        if self.is_empty() {\n            *self = rhs\n        } else if rhs.is_empty() {\n            return;\n        } else {\n            if let Cow::Borrowed(lhs) = *self {\n                let mut s = String::with_capacity(lhs.len() + rhs.len());\n                s.push_str(lhs);\n                *self = Cow::Owned(s);\n            }\n            self.to_mut().push_str(&rhs);\n        }\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Traits, helpers, and type definitions for core I/O functionality.\n//!\n//! The `std::io` module contains a number of common things you'll need\n//! when doing input and output. The most core part of this module is\n//! the [`Read`] and [`Write`] traits, which provide the\n//! most general interface for reading and writing input and output.\n//!\n//! # Read and Write\n//!\n//! Because they are traits, [`Read`] and [`Write`] are implemented by a number\n//! of other types, and you can implement them for your types too. As such,\n//! you'll see a few different types of I/O throughout the documentation in\n//! this module: [`File`]s, [`TcpStream`]s, and sometimes even [`Vec<T>`]s. For\n//! example, [`Read`] adds a [`read`][`Read::read`] method, which we can use on\n//! [`File`]s:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//! use std::fs::File;\n//!\n//! fn main() -> io::Result<()> {\n//!     let mut f = File::open(\"foo.txt\")?;\n//!     let mut buffer = [0; 10];\n//!\n//!     // read up to 10 bytes\n//!     f.read(&mut buffer)?;\n//!\n//!     println!(\"The bytes: {:?}\", buffer);\n//!     Ok(())\n//! }\n//! ```\n//!\n//! [`Read`] and [`Write`] are so important, implementors of the two traits have a\n//! nickname: readers and writers. So you'll sometimes see 'a reader' instead\n//! of 'a type that implements the [`Read`] trait'. Much easier!\n//!\n//! ## Seek and BufRead\n//!\n//! Beyond that, there are two important traits that are provided: [`Seek`]\n//! and [`BufRead`]. Both of these build on top of a reader to control\n//! how the reading happens. [`Seek`] lets you control where the next byte is\n//! coming from:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//! use std::io::SeekFrom;\n//! use std::fs::File;\n//!\n//! fn main() -> io::Result<()> {\n//!     let mut f = File::open(\"foo.txt\")?;\n//!     let mut buffer = [0; 10];\n//!\n//!     // skip to the last 10 bytes of the file\n//!     f.seek(SeekFrom::End(-10))?;\n//!\n//!     // read up to 10 bytes\n//!     f.read(&mut buffer)?;\n//!\n//!     println!(\"The bytes: {:?}\", buffer);\n//!     Ok(())\n//! }\n//! ```\n//!\n//! [`BufRead`] uses an internal buffer to provide a number of other ways to read, but\n//! to show it off, we'll need to talk about buffers in general. Keep reading!\n//!\n//! ## BufReader and BufWriter\n//!\n//! Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be\n//! making near-constant calls to the operating system. To help with this,\n//! `std::io` comes with two structs, [`BufReader`] and [`BufWriter`], which wrap\n//! readers and writers. The wrapper uses a buffer, reducing the number of\n//! calls and providing nicer methods for accessing exactly what you want.\n//!\n//! For example, [`BufReader`] works with the [`BufRead`] trait to add extra\n//! methods to any reader:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//! use std::io::BufReader;\n//! use std::fs::File;\n//!\n//! fn main() -> io::Result<()> {\n//!     let f = File::open(\"foo.txt\")?;\n//!     let mut reader = BufReader::new(f);\n//!     let mut buffer = String::new();\n//!\n//!     // read a line into buffer\n//!     reader.read_line(&mut buffer)?;\n//!\n//!     println!(\"{}\", buffer);\n//!     Ok(())\n//! }\n//! ```\n//!\n//! [`BufWriter`] doesn't add any new ways of writing; it just buffers every call\n//! to [`write`][`Write::write`]:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//! use std::io::BufWriter;\n//! use std::fs::File;\n//!\n//! fn main() -> io::Result<()> {\n//!     let f = File::create(\"foo.txt\")?;\n//!     {\n//!         let mut writer = BufWriter::new(f);\n//!\n//!         // write a byte to the buffer\n//!         writer.write(&[42])?;\n//!\n//!     } // the buffer is flushed once writer goes out of scope\n//!\n//!     Ok(())\n//! }\n//! ```\n//!\n//! ## Standard input and output\n//!\n//! A very common source of input is standard input:\n//!\n//! ```no_run\n//! use std::io;\n//!\n//! fn main() -> io::Result<()> {\n//!     let mut input = String::new();\n//!\n//!     io::stdin().read_line(&mut input)?;\n//!\n//!     println!(\"You typed: {}\", input.trim());\n//!     Ok(())\n//! }\n//! ```\n//!\n//! Note that you cannot use the [`?` operator] in functions that do not return\n//! a [`Result<T, E>`][`Result`]. Instead, you can call [`.unwrap()`]\n//! or `match` on the return value to catch any possible errors:\n//!\n//! ```no_run\n//! use std::io;\n//!\n//! let mut input = String::new();\n//!\n//! io::stdin().read_line(&mut input).unwrap();\n//! ```\n//!\n//! And a very common source of output is standard output:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//!\n//! fn main() -> io::Result<()> {\n//!     io::stdout().write(&[42])?;\n//!     Ok(())\n//! }\n//! ```\n//!\n//! Of course, using [`io::stdout`] directly is less common than something like\n//! [`println!`].\n//!\n//! ## Iterator types\n//!\n//! A large number of the structures provided by `std::io` are for various\n//! ways of iterating over I/O. For example, [`Lines`] is used to split over\n//! lines:\n//!\n//! ```no_run\n//! use std::io;\n//! use std::io::prelude::*;\n//! use std::io::BufReader;\n//! use std::fs::File;\n//!\n//! fn main() -> io::Result<()> {\n//!     let f = File::open(\"foo.txt\")?;\n//!     let reader = BufReader::new(f);\n//!\n//!     for line in reader.lines() {\n//!         println!(\"{}\", line?);\n//!     }\n//!     Ok(())\n//! }\n//! ```\n//!\n//! ## Functions\n//!\n//! There are a number of [functions][functions-list] that offer access to various\n//! features. For example, we can use three of these functions to copy everything\n//! from standard input to standard output:\n//!\n//! ```no_run\n//! use std::io;\n//!\n//! fn main() -> io::Result<()> {\n//!     io::copy(&mut io::stdin(), &mut io::stdout())?;\n//!     Ok(())\n//! }\n//! ```\n//!\n//! [functions-list]: #functions-1\n//!\n//! ## io::Result\n//!\n//! Last, but certainly not least, is [`io::Result`]. This type is used\n//! as the return type of many `std::io` functions that can cause an error, and\n//! can be returned from your own functions as well. Many of the examples in this\n//! module use the [`?` operator]:\n//!\n//! ```\n//! use std::io;\n//!\n//! fn read_input() -> io::Result<()> {\n//!     let mut input = String::new();\n//!\n//!     io::stdin().read_line(&mut input)?;\n//!\n//!     println!(\"You typed: {}\", input.trim());\n//!\n//!     Ok(())\n//! }\n//! ```\n//!\n//! The return type of `read_input()`, [`io::Result<()>`][`io::Result`], is a very\n//! common type for functions which don't have a 'real' return value, but do want to\n//! return errors if they happen. In this case, the only purpose of this function is\n//! to read the line and print it, so we use `()`.\n//!\n//! ## Platform-specific behavior\n//!\n//! Many I/O functions throughout the standard library are documented to indicate\n//! what various library or syscalls they are delegated to. This is done to help\n//! applications both understand what's happening under the hood as well as investigate\n//! any possibly unclear semantics. Note, however, that this is informative, not a binding\n//! contract. The implementation of many of these functions are subject to change over\n//! time and may call fewer or more syscalls/library functions.\n//!\n//! [`Read`]: trait.Read.html\n//! [`Write`]: trait.Write.html\n//! [`Seek`]: trait.Seek.html\n//! [`BufRead`]: trait.BufRead.html\n//! [`File`]: ../fs/struct.File.html\n//! [`TcpStream`]: ../net/struct.TcpStream.html\n//! [`Vec<T>`]: ../vec/struct.Vec.html\n//! [`BufReader`]: struct.BufReader.html\n//! [`BufWriter`]: struct.BufWriter.html\n//! [`Write::write`]: trait.Write.html#tymethod.write\n//! [`io::stdout`]: fn.stdout.html\n//! [`println!`]: ../macro.println.html\n//! [`Lines`]: struct.Lines.html\n//! [`io::Result`]: type.Result.html\n//! [`?` operator]: ../../book/first-edition/syntax-index.html\n//! [`Read::read`]: trait.Read.html#tymethod.read\n//! [`Result`]: ../result/enum.Result.html\n//! [`.unwrap()`]: ../result/enum.Result.html#method.unwrap\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse cmp;\nuse fmt;\nuse str;\nuse memchr;\nuse ptr;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::buffered::{BufReader, BufWriter, LineWriter};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::buffered::IntoInnerError;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::cursor::Cursor;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::error::{Result, Error, ErrorKind};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::util::{copy, sink, Sink, empty, Empty, repeat, Repeat};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::stdio::{stdin, stdout, stderr, Stdin, Stdout, Stderr};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::stdio::{StdoutLock, StderrLock, StdinLock};\n#[unstable(feature = \"print_internals\", issue = \"0\")]\npub use self::stdio::{_print, _eprint};\n#[unstable(feature = \"libstd_io_internals\", issue = \"42788\")]\n#[doc(no_inline, hidden)]\npub use self::stdio::{set_panic, set_print};\n\npub mod prelude;\nmod buffered;\nmod cursor;\nmod error;\nmod impls;\nmod lazy;\nmod util;\nmod stdio;\n\nconst DEFAULT_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;\n\nstruct Guard<'a> { buf: &'a mut Vec<u8>, len: usize }\n\nimpl<'a> Drop for Guard<'a> {\n    fn drop(&mut self) {\n        unsafe { self.buf.set_len(self.len); }\n    }\n}\n\n// A few methods below (read_to_string, read_line) will append data into a\n// `String` buffer, but we need to be pretty careful when doing this. The\n// implementation will just call `.as_mut_vec()` and then delegate to a\n// byte-oriented reading method, but we must ensure that when returning we never\n// leave `buf` in a state such that it contains invalid UTF-8 in its bounds.\n//\n// To this end, we use an RAII guard (to protect against panics) which updates\n// the length of the string when it is dropped. This guard initially truncates\n// the string to the prior length and only after we've validated that the\n// new contents are valid UTF-8 do we allow it to set a longer length.\n//\n// The unsafety in this function is twofold:\n//\n// 1. We're looking at the raw bytes of `buf`, so we take on the burden of UTF-8\n//    checks.\n// 2. We're passing a raw buffer to the function `f`, and it is expected that\n//    the function only *appends* bytes to the buffer. We'll get undefined\n//    behavior if existing bytes are overwritten to have non-UTF-8 data.\nfn append_to_string<F>(buf: &mut String, f: F) -> Result<usize>\n    where F: FnOnce(&mut Vec<u8>) -> Result<usize>\n{\n    unsafe {\n        let mut g = Guard { len: buf.len(), buf: buf.as_mut_vec() };\n        let ret = f(g.buf);\n        if str::from_utf8(&g.buf[g.len..]).is_err() {\n            ret.and_then(|_| {\n                Err(Error::new(ErrorKind::InvalidData,\n                               \"stream did not contain valid UTF-8\"))\n            })\n        } else {\n            g.len = g.buf.len();\n            ret\n        }\n    }\n}\n\n// This uses an adaptive system to extend the vector when it fills. We want to\n// avoid paying to allocate and zero a huge chunk of memory if the reader only\n// has 4 bytes while still making large reads if the reader does have a ton\n// of data to return. Simply tacking on an extra DEFAULT_BUF_SIZE space every\n// time is 4,500 times (!) slower than a default reservation size of 32 if the\n// reader has a very small amount of data to return.\n//\n// Because we're extending the buffer with uninitialized data for trusted\n// readers, we need to make sure to truncate that if any of this panics.\nfn read_to_end<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {\n    read_to_end_with_reservation(r, buf, 32)\n}\n\nfn read_to_end_with_reservation<R: Read + ?Sized>(r: &mut R,\n                                                  buf: &mut Vec<u8>,\n                                                  reservation_size: usize) -> Result<usize>\n{\n    let start_len = buf.len();\n    let mut g = Guard { len: buf.len(), buf: buf };\n    let ret;\n    loop {\n        if g.len == g.buf.len() {\n            unsafe {\n                g.buf.reserve(reservation_size);\n                let capacity = g.buf.capacity();\n                g.buf.set_len(capacity);\n                r.initializer().initialize(&mut g.buf[g.len..]);\n            }\n        }\n\n        match r.read(&mut g.buf[g.len..]) {\n            Ok(0) => {\n                ret = Ok(g.len - start_len);\n                break;\n            }\n            Ok(n) => g.len += n,\n            Err(ref e) if e.kind() == ErrorKind::Interrupted => {}\n            Err(e) => {\n                ret = Err(e);\n                break;\n            }\n        }\n    }\n\n    ret\n}\n\n/// The `Read` trait allows for reading bytes from a source.\n///\n/// Implementors of the `Read` trait are called 'readers'.\n///\n/// Readers are defined by one required method, [`read()`]. Each call to [`read()`]\n/// will attempt to pull bytes from this source into a provided buffer. A\n/// number of other methods are implemented in terms of [`read()`], giving\n/// implementors a number of ways to read bytes while only needing to implement\n/// a single method.\n///\n/// Readers are intended to be composable with one another. Many implementors\n/// throughout [`std::io`] take and provide types which implement the `Read`\n/// trait.\n///\n/// Please note that each call to [`read()`] may involve a system call, and\n/// therefore, using something that implements [`BufRead`], such as\n/// [`BufReader`], will be more efficient.\n///\n/// # Examples\n///\n/// [`File`]s implement `Read`:\n///\n/// ```no_run\n/// use std::io;\n/// use std::io::prelude::*;\n/// use std::fs::File;\n///\n/// fn main() -> io::Result<()> {\n///     let mut f = File::open(\"foo.txt\")?;\n///     let mut buffer = [0; 10];\n///\n///     // read up to 10 bytes\n///     f.read(&mut buffer)?;\n///\n///     let mut buffer = vec![0; 10];\n///     // read the whole file\n///     f.read_to_end(&mut buffer)?;\n///\n///     // read into a String, so that you don't need to do the conversion.\n///     let mut buffer = String::new();\n///     f.read_to_string(&mut buffer)?;\n///\n///     // and more! See the other methods for more details.\n///     Ok(())\n/// }\n/// ```\n///\n/// Read from [`&str`] because [`&[u8]`][slice] implements `Read`:\n///\n/// ```no_run\n/// # use std::io;\n/// use std::io::prelude::*;\n///\n/// fn main() -> io::Result<()> {\n///     let mut b = \"This string will be read\".as_bytes();\n///     let mut buffer = [0; 10];\n///\n///     // read up to 10 bytes\n///     b.read(&mut buffer)?;\n///\n///     // etc... it works exactly as a File does!\n///     Ok(())\n/// }\n/// ```\n///\n/// [`read()`]: trait.Read.html#tymethod.read\n/// [`std::io`]: ../../std/io/index.html\n/// [`File`]: ../fs/struct.File.html\n/// [`BufRead`]: trait.BufRead.html\n/// [`BufReader`]: struct.BufReader.html\n/// [`&str`]: ../../std/primitive.str.html\n/// [slice]: ../../std/primitive.slice.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(spotlight)]\npub trait Read {\n    /// Pull some bytes from this source into the specified buffer, returning\n    /// how many bytes were read.\n    ///\n    /// This function does not provide any guarantees about whether it blocks\n    /// waiting for data, but if an object needs to block for a read but cannot\n    /// it will typically signal this via an [`Err`] return value.\n    ///\n    /// If the return value of this method is [`Ok(n)`], then it must be\n    /// guaranteed that `0 <= n <= buf.len()`. A nonzero `n` value indicates\n    /// that the buffer `buf` has been filled in with `n` bytes of data from this\n    /// source. If `n` is `0`, then it can indicate one of two scenarios:\n    ///\n    /// 1. This reader has reached its \"end of file\" and will likely no longer\n    ///    be able to produce bytes. Note that this does not mean that the\n    ///    reader will *always* no longer be able to produce bytes.\n    /// 2. The buffer specified was 0 bytes in length.\n    ///\n    /// No guarantees are provided about the contents of `buf` when this\n    /// function is called, implementations cannot rely on any property of the\n    /// contents of `buf` being true. It is recommended that implementations\n    /// only write data to `buf` instead of reading its contents.\n    ///\n    /// # Errors\n    ///\n    /// If this function encounters any form of I/O or other error, an error\n    /// variant will be returned. If an error is returned then it must be\n    /// guaranteed that no bytes were read.\n    ///\n    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the read\n    /// operation should be retried if there is nothing else to do.\n    ///\n    /// # Examples\n    ///\n    /// [`File`]s implement `Read`:\n    ///\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`Ok(n)`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n    /// [`File`]: ../fs/struct.File.html\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = [0; 10];\n    ///\n    ///     // read up to 10 bytes\n    ///     f.read(&mut buffer[..])?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;\n\n    /// Determines if this `Read`er can work with buffers of uninitialized\n    /// memory.\n    ///\n    /// The default implementation returns an initializer which will zero\n    /// buffers.\n    ///\n    /// If a `Read`er guarantees that it can work properly with uninitialized\n    /// memory, it should call [`Initializer::nop()`]. See the documentation for\n    /// [`Initializer`] for details.\n    ///\n    /// The behavior of this method must be independent of the state of the\n    /// `Read`er - the method only takes `&self` so that it can be used through\n    /// trait objects.\n    ///\n    /// # Safety\n    ///\n    /// This method is unsafe because a `Read`er could otherwise return a\n    /// non-zeroing `Initializer` from another `Read` type without an `unsafe`\n    /// block.\n    ///\n    /// [`Initializer::nop()`]: ../../std/io/struct.Initializer.html#method.nop\n    /// [`Initializer`]: ../../std/io/struct.Initializer.html\n    #[unstable(feature = \"read_initializer\", issue = \"42788\")]\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::zeroing()\n    }\n\n    /// Read all bytes until EOF in this source, placing them into `buf`.\n    ///\n    /// All bytes read from this source will be appended to the specified buffer\n    /// `buf`. This function will continuously call [`read()`] to append more data to\n    /// `buf` until [`read()`] returns either [`Ok(0)`] or an error of\n    /// non-[`ErrorKind::Interrupted`] kind.\n    ///\n    /// If successful, this function will return the total number of bytes read.\n    ///\n    /// # Errors\n    ///\n    /// If this function encounters an error of the kind\n    /// [`ErrorKind::Interrupted`] then the error is ignored and the operation\n    /// will continue.\n    ///\n    /// If any other read error is encountered then this function immediately\n    /// returns. Any bytes which have already been read will be appended to\n    /// `buf`.\n    ///\n    /// # Examples\n    ///\n    /// [`File`]s implement `Read`:\n    ///\n    /// [`read()`]: trait.Read.html#tymethod.read\n    /// [`Ok(0)`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n    /// [`File`]: ../fs/struct.File.html\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = Vec::new();\n    ///\n    ///     // read the whole file\n    ///     f.read_to_end(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// (See also the [`std::fs::read`] convenience function for reading from a\n    /// file.)\n    ///\n    /// [`std::fs::read`]: ../fs/fn.read.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {\n        read_to_end(self, buf)\n    }\n\n    /// Read all bytes until EOF in this source, appending them to `buf`.\n    ///\n    /// If successful, this function returns the number of bytes which were read\n    /// and appended to `buf`.\n    ///\n    /// # Errors\n    ///\n    /// If the data in this stream is *not* valid UTF-8 then an error is\n    /// returned and `buf` is unchanged.\n    ///\n    /// See [`read_to_end`][readtoend] for other error semantics.\n    ///\n    /// [readtoend]: #method.read_to_end\n    ///\n    /// # Examples\n    ///\n    /// [`File`][file]s implement `Read`:\n    ///\n    /// [file]: ../fs/struct.File.html\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = String::new();\n    ///\n    ///     f.read_to_string(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// (See also the [`std::fs::read_to_string`] convenience function for\n    /// reading from a file.)\n    ///\n    /// [`std::fs::read_to_string`]: ../fs/fn.read_to_string.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn read_to_string(&mut self, buf: &mut String) -> Result<usize> {\n        // Note that we do *not* call `.read_to_end()` here. We are passing\n        // `&mut Vec<u8>` (the raw contents of `buf`) into the `read_to_end`\n        // method to fill it up. An arbitrary implementation could overwrite the\n        // entire contents of the vector, not just append to it (which is what\n        // we are expecting).\n        //\n        // To prevent extraneously checking the UTF-8-ness of the entire buffer\n        // we pass it to our hardcoded `read_to_end` implementation which we\n        // know is guaranteed to only read data into the end of the buffer.\n        append_to_string(buf, |b| read_to_end(self, b))\n    }\n\n    /// Read the exact number of bytes required to fill `buf`.\n    ///\n    /// This function reads as many bytes as necessary to completely fill the\n    /// specified buffer `buf`.\n    ///\n    /// No guarantees are provided about the contents of `buf` when this\n    /// function is called, implementations cannot rely on any property of the\n    /// contents of `buf` being true. It is recommended that implementations\n    /// only write data to `buf` instead of reading its contents.\n    ///\n    /// # Errors\n    ///\n    /// If this function encounters an error of the kind\n    /// [`ErrorKind::Interrupted`] then the error is ignored and the operation\n    /// will continue.\n    ///\n    /// If this function encounters an \"end of file\" before completely filling\n    /// the buffer, it returns an error of the kind [`ErrorKind::UnexpectedEof`].\n    /// The contents of `buf` are unspecified in this case.\n    ///\n    /// If any other read error is encountered then this function immediately\n    /// returns. The contents of `buf` are unspecified in this case.\n    ///\n    /// If this function returns an error, it is unspecified how many bytes it\n    /// has read, but it will never read more than would be necessary to\n    /// completely fill the buffer.\n    ///\n    /// # Examples\n    ///\n    /// [`File`]s implement `Read`:\n    ///\n    /// [`File`]: ../fs/struct.File.html\n    /// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n    /// [`ErrorKind::UnexpectedEof`]: ../../std/io/enum.ErrorKind.html#variant.UnexpectedEof\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = [0; 10];\n    ///\n    ///     // read exactly 10 bytes\n    ///     f.read_exact(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"read_exact\", since = \"1.6.0\")]\n    fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {\n        while !buf.is_empty() {\n            match self.read(buf) {\n                Ok(0) => break,\n                Ok(n) => { let tmp = buf; buf = &mut tmp[n..]; }\n                Err(ref e) if e.kind() == ErrorKind::Interrupted => {}\n                Err(e) => return Err(e),\n            }\n        }\n        if !buf.is_empty() {\n            Err(Error::new(ErrorKind::UnexpectedEof,\n                           \"failed to fill whole buffer\"))\n        } else {\n            Ok(())\n        }\n    }\n\n    /// Creates a \"by reference\" adaptor for this instance of `Read`.\n    ///\n    /// The returned adaptor also implements `Read` and will simply borrow this\n    /// current reader.\n    ///\n    /// # Examples\n    ///\n    /// [`File`][file]s implement `Read`:\n    ///\n    /// [file]: ../fs/struct.File.html\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::Read;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = Vec::new();\n    ///     let mut other_buffer = Vec::new();\n    ///\n    ///     {\n    ///         let reference = f.by_ref();\n    ///\n    ///         // read at most 5 bytes\n    ///         reference.take(5).read_to_end(&mut buffer)?;\n    ///\n    ///     } // drop our &mut reference so we can use f again\n    ///\n    ///     // original file still usable, read the rest\n    ///     f.read_to_end(&mut other_buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }\n\n    /// Transforms this `Read` instance to an [`Iterator`] over its bytes.\n    ///\n    /// The returned type implements [`Iterator`] where the `Item` is\n    /// [`Result`]`<`[`u8`]`, `[`io::Error`]`>`.\n    /// The yielded item is [`Ok`] if a byte was successfully read and [`Err`]\n    /// otherwise. EOF is mapped to returning [`None`] from this iterator.\n    ///\n    /// # Examples\n    ///\n    /// [`File`][file]s implement `Read`:\n    ///\n    /// [file]: ../fs/struct.File.html\n    /// [`Iterator`]: ../../std/iter/trait.Iterator.html\n    /// [`Result`]: ../../std/result/enum.Result.html\n    /// [`io::Error`]: ../../std/io/struct.Error.html\n    /// [`u8`]: ../../std/primitive.u8.html\n    /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///\n    ///     for byte in f.bytes() {\n    ///         println!(\"{}\", byte.unwrap());\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn bytes(self) -> Bytes<Self> where Self: Sized {\n        Bytes { inner: self }\n    }\n\n    /// Creates an adaptor which will chain this stream with another.\n    ///\n    /// The returned `Read` instance will first read all bytes from this object\n    /// until EOF is encountered. Afterwards the output is equivalent to the\n    /// output of `next`.\n    ///\n    /// # Examples\n    ///\n    /// [`File`][file]s implement `Read`:\n    ///\n    /// [file]: ../fs/struct.File.html\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f1 = File::open(\"foo.txt\")?;\n    ///     let mut f2 = File::open(\"bar.txt\")?;\n    ///\n    ///     let mut handle = f1.chain(f2);\n    ///     let mut buffer = String::new();\n    ///\n    ///     // read the value into a String. We could use any Read method here,\n    ///     // this is just one example.\n    ///     handle.read_to_string(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized {\n        Chain { first: self, second: next, done_first: false }\n    }\n\n    /// Creates an adaptor which will read at most `limit` bytes from it.\n    ///\n    /// This function returns a new instance of `Read` which will read at most\n    /// `limit` bytes, after which it will always return EOF ([`Ok(0)`]). Any\n    /// read errors will not count towards the number of bytes read and future\n    /// calls to [`read()`] may succeed.\n    ///\n    /// # Examples\n    ///\n    /// [`File`]s implement `Read`:\n    ///\n    /// [`File`]: ../fs/struct.File.html\n    /// [`Ok(0)`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`read()`]: trait.Read.html#tymethod.read\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let mut buffer = [0; 5];\n    ///\n    ///     // read at most five bytes\n    ///     let mut handle = f.take(5);\n    ///\n    ///     handle.read(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn take(self, limit: u64) -> Take<Self> where Self: Sized {\n        Take { inner: self, limit: limit }\n    }\n}\n\n/// A type used to conditionally initialize buffers passed to `Read` methods.\n#[unstable(feature = \"read_initializer\", issue = \"42788\")]\n#[derive(Debug)]\npub struct Initializer(bool);\n\nimpl Initializer {\n    /// Returns a new `Initializer` which will zero out buffers.\n    #[unstable(feature = \"read_initializer\", issue = \"42788\")]\n    #[inline]\n    pub fn zeroing() -> Initializer {\n        Initializer(true)\n    }\n\n    /// Returns a new `Initializer` which will not zero out buffers.\n    ///\n    /// # Safety\n    ///\n    /// This may only be called by `Read`ers which guarantee that they will not\n    /// read from buffers passed to `Read` methods, and that the return value of\n    /// the method accurately reflects the number of bytes that have been\n    /// written to the head of the buffer.\n    #[unstable(feature = \"read_initializer\", issue = \"42788\")]\n    #[inline]\n    pub unsafe fn nop() -> Initializer {\n        Initializer(false)\n    }\n\n    /// Indicates if a buffer should be initialized.\n    #[unstable(feature = \"read_initializer\", issue = \"42788\")]\n    #[inline]\n    pub fn should_initialize(&self) -> bool {\n        self.0\n    }\n\n    /// Initializes a buffer if necessary.\n    #[unstable(feature = \"read_initializer\", issue = \"42788\")]\n    #[inline]\n    pub fn initialize(&self, buf: &mut [u8]) {\n        if self.should_initialize() {\n            unsafe { ptr::write_bytes(buf.as_mut_ptr(), 0, buf.len()) }\n        }\n    }\n}\n\n/// A trait for objects which are byte-oriented sinks.\n///\n/// Implementors of the `Write` trait are sometimes called 'writers'.\n///\n/// Writers are defined by two required methods, [`write`] and [`flush`]:\n///\n/// * The [`write`] method will attempt to write some data into the object,\n///   returning how many bytes were successfully written.\n///\n/// * The [`flush`] method is useful for adaptors and explicit buffers\n///   themselves for ensuring that all buffered data has been pushed out to the\n///   'true sink'.\n///\n/// Writers are intended to be composable with one another. Many implementors\n/// throughout [`std::io`] take and provide types which implement the `Write`\n/// trait.\n///\n/// [`write`]: #tymethod.write\n/// [`flush`]: #tymethod.flush\n/// [`std::io`]: index.html\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::io::prelude::*;\n/// use std::fs::File;\n///\n/// fn main() -> std::io::Result<()> {\n///     let mut buffer = File::create(\"foo.txt\")?;\n///\n///     buffer.write(b\"some bytes\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[doc(spotlight)]\npub trait Write {\n    /// Write a buffer into this object, returning how many bytes were written.\n    ///\n    /// This function will attempt to write the entire contents of `buf`, but\n    /// the entire write may not succeed, or the write may also generate an\n    /// error. A call to `write` represents *at most one* attempt to write to\n    /// any wrapped object.\n    ///\n    /// Calls to `write` are not guaranteed to block waiting for data to be\n    /// written, and a write which would otherwise block can be indicated through\n    /// an [`Err`] variant.\n    ///\n    /// If the return value is [`Ok(n)`] then it must be guaranteed that\n    /// `0 <= n <= buf.len()`. A return value of `0` typically means that the\n    /// underlying object is no longer able to accept bytes and will likely not\n    /// be able to in the future as well, or that the buffer provided is empty.\n    ///\n    /// # Errors\n    ///\n    /// Each call to `write` may generate an I/O error indicating that the\n    /// operation could not be completed. If an error is returned then no bytes\n    /// in the buffer were written to this writer.\n    ///\n    /// It is **not** considered an error if the entire buffer could not be\n    /// written to this writer.\n    ///\n    /// An error of the [`ErrorKind::Interrupted`] kind is non-fatal and the\n    /// write operation should be retried if there is nothing else to do.\n    ///\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`Ok(n)`]:  ../../std/result/enum.Result.html#variant.Ok\n    /// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut buffer = File::create(\"foo.txt\")?;\n    ///\n    ///     // Writes some prefix of the byte string, not necessarily all of it.\n    ///     buffer.write(b\"some bytes\")?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn write(&mut self, buf: &[u8]) -> Result<usize>;\n\n    /// Flush this output stream, ensuring that all intermediately buffered\n    /// contents reach their destination.\n    ///\n    /// # Errors\n    ///\n    /// It is considered an error if not all bytes could be written due to\n    /// I/O errors or EOF being reached.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::prelude::*;\n    /// use std::io::BufWriter;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut buffer = BufWriter::new(File::create(\"foo.txt\")?);\n    ///\n    ///     buffer.write(b\"some bytes\")?;\n    ///     buffer.flush()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn flush(&mut self) -> Result<()>;\n\n    /// Attempts to write an entire buffer into this write.\n    ///\n    /// This method will continuously call [`write`] until there is no more data\n    /// to be written or an error of non-[`ErrorKind::Interrupted`] kind is\n    /// returned. This method will not return until the entire buffer has been\n    /// successfully written or such an error occurs. The first error that is\n    /// not of [`ErrorKind::Interrupted`] kind generated from this method will be\n    /// returned.\n    ///\n    /// # Errors\n    ///\n    /// This function will return the first error of\n    /// non-[`ErrorKind::Interrupted`] kind that [`write`] returns.\n    ///\n    /// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n    /// [`write`]: #tymethod.write\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut buffer = File::create(\"foo.txt\")?;\n    ///\n    ///     buffer.write_all(b\"some bytes\")?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn write_all(&mut self, mut buf: &[u8]) -> Result<()> {\n        while !buf.is_empty() {\n            match self.write(buf) {\n                Ok(0) => return Err(Error::new(ErrorKind::WriteZero,\n                                               \"failed to write whole buffer\")),\n                Ok(n) => buf = &buf[n..],\n                Err(ref e) if e.kind() == ErrorKind::Interrupted => {}\n                Err(e) => return Err(e),\n            }\n        }\n        Ok(())\n    }\n\n    /// Writes a formatted string into this writer, returning any error\n    /// encountered.\n    ///\n    /// This method is primarily used to interface with the\n    /// [`format_args!`][formatargs] macro, but it is rare that this should\n    /// explicitly be called. The [`write!`][write] macro should be favored to\n    /// invoke this method instead.\n    ///\n    /// [formatargs]: ../macro.format_args.html\n    /// [write]: ../macro.write.html\n    ///\n    /// This function internally uses the [`write_all`][writeall] method on\n    /// this trait and hence will continuously write data so long as no errors\n    /// are received. This also means that partial writes are not indicated in\n    /// this signature.\n    ///\n    /// [writeall]: #method.write_all\n    ///\n    /// # Errors\n    ///\n    /// This function will return any I/O error reported while formatting.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut buffer = File::create(\"foo.txt\")?;\n    ///\n    ///     // this call\n    ///     write!(buffer, \"{:.*}\", 2, 1.234567)?;\n    ///     // turns into this:\n    ///     buffer.write_fmt(format_args!(\"{:.*}\", 2, 1.234567))?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn write_fmt(&mut self, fmt: fmt::Arguments) -> Result<()> {\n        // Create a shim which translates a Write to a fmt::Write and saves\n        // off I/O errors. instead of discarding them\n        struct Adaptor<'a, T: ?Sized + 'a> {\n            inner: &'a mut T,\n            error: Result<()>,\n        }\n\n        impl<'a, T: Write + ?Sized> fmt::Write for Adaptor<'a, T> {\n            fn write_str(&mut self, s: &str) -> fmt::Result {\n                match self.inner.write_all(s.as_bytes()) {\n                    Ok(()) => Ok(()),\n                    Err(e) => {\n                        self.error = Err(e);\n                        Err(fmt::Error)\n                    }\n                }\n            }\n        }\n\n        let mut output = Adaptor { inner: self, error: Ok(()) };\n        match fmt::write(&mut output, fmt) {\n            Ok(()) => Ok(()),\n            Err(..) => {\n                // check if the error came from the underlying `Write` or not\n                if output.error.is_err() {\n                    output.error\n                } else {\n                    Err(Error::new(ErrorKind::Other, \"formatter error\"))\n                }\n            }\n        }\n    }\n\n    /// Creates a \"by reference\" adaptor for this instance of `Write`.\n    ///\n    /// The returned adaptor also implements `Write` and will simply borrow this\n    /// current writer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::Write;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut buffer = File::create(\"foo.txt\")?;\n    ///\n    ///     let reference = buffer.by_ref();\n    ///\n    ///     // we can use reference just like our original buffer\n    ///     reference.write_all(b\"some bytes\")?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn by_ref(&mut self) -> &mut Self where Self: Sized { self }\n}\n\n/// The `Seek` trait provides a cursor which can be moved within a stream of\n/// bytes.\n///\n/// The stream typically has a fixed size, allowing seeking relative to either\n/// end or the current offset.\n///\n/// # Examples\n///\n/// [`File`][file]s implement `Seek`:\n///\n/// [file]: ../fs/struct.File.html\n///\n/// ```no_run\n/// use std::io;\n/// use std::io::prelude::*;\n/// use std::fs::File;\n/// use std::io::SeekFrom;\n///\n/// fn main() -> io::Result<()> {\n///     let mut f = File::open(\"foo.txt\")?;\n///\n///     // move the cursor 42 bytes from the start of the file\n///     f.seek(SeekFrom::Start(42))?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Seek {\n    /// Seek to an offset, in bytes, in a stream.\n    ///\n    /// A seek beyond the end of a stream is allowed, but behavior is defined\n    /// by the implementation.\n    ///\n    /// If the seek operation completed successfully,\n    /// this method returns the new position from the start of the stream.\n    /// That position can be used later with [`SeekFrom::Start`].\n    ///\n    /// # Errors\n    ///\n    /// Seeking to a negative offset is considered an error.\n    ///\n    /// [`SeekFrom::Start`]: enum.SeekFrom.html#variant.Start\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn seek(&mut self, pos: SeekFrom) -> Result<u64>;\n}\n\n/// Enumeration of possible methods to seek within an I/O object.\n///\n/// It is used by the [`Seek`] trait.\n///\n/// [`Seek`]: trait.Seek.html\n#[derive(Copy, PartialEq, Eq, Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum SeekFrom {\n    /// Set the offset to the provided number of bytes.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Start(#[stable(feature = \"rust1\", since = \"1.0.0\")] u64),\n\n    /// Set the offset to the size of this object plus the specified number of\n    /// bytes.\n    ///\n    /// It is possible to seek beyond the end of an object, but it's an error to\n    /// seek before byte 0.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    End(#[stable(feature = \"rust1\", since = \"1.0.0\")] i64),\n\n    /// Set the offset to the current position plus the specified number of\n    /// bytes.\n    ///\n    /// It is possible to seek beyond the end of an object, but it's an error to\n    /// seek before byte 0.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Current(#[stable(feature = \"rust1\", since = \"1.0.0\")] i64),\n}\n\nfn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)\n                                   -> Result<usize> {\n    let mut read = 0;\n    loop {\n        let (done, used) = {\n            let available = match r.fill_buf() {\n                Ok(n) => n,\n                Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,\n                Err(e) => return Err(e)\n            };\n            match memchr::memchr(delim, available) {\n                Some(i) => {\n                    buf.extend_from_slice(&available[..i + 1]);\n                    (true, i + 1)\n                }\n                None => {\n                    buf.extend_from_slice(available);\n                    (false, available.len())\n                }\n            }\n        };\n        r.consume(used);\n        read += used;\n        if done || used == 0 {\n            return Ok(read);\n        }\n    }\n}\n\n/// A `BufRead` is a type of `Read`er which has an internal buffer, allowing it\n/// to perform extra ways of reading.\n///\n/// For example, reading line-by-line is inefficient without using a buffer, so\n/// if you want to read by line, you'll need `BufRead`, which includes a\n/// [`read_line`] method as well as a [`lines`] iterator.\n///\n/// # Examples\n///\n/// A locked standard input implements `BufRead`:\n///\n/// ```no_run\n/// use std::io;\n/// use std::io::prelude::*;\n///\n/// let stdin = io::stdin();\n/// for line in stdin.lock().lines() {\n///     println!(\"{}\", line.unwrap());\n/// }\n/// ```\n///\n/// If you have something that implements [`Read`], you can use the [`BufReader`\n/// type][`BufReader`] to turn it into a `BufRead`.\n///\n/// For example, [`File`] implements [`Read`], but not `BufRead`.\n/// [`BufReader`] to the rescue!\n///\n/// [`BufReader`]: struct.BufReader.html\n/// [`File`]: ../fs/struct.File.html\n/// [`read_line`]: #method.read_line\n/// [`lines`]: #method.lines\n/// [`Read`]: trait.Read.html\n///\n/// ```no_run\n/// use std::io::{self, BufReader};\n/// use std::io::prelude::*;\n/// use std::fs::File;\n///\n/// fn main() -> io::Result<()> {\n///     let f = File::open(\"foo.txt\")?;\n///     let f = BufReader::new(f);\n///\n///     for line in f.lines() {\n///         println!(\"{}\", line.unwrap());\n///     }\n///\n///     Ok(())\n/// }\n/// ```\n///\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait BufRead: Read {\n    /// Returns the contents of the internal buffer, filling it with more data\n    /// from the inner reader if it is empty.\n    ///\n    /// This function is a lower-level call. It needs to be paired with the\n    /// [`consume`] method to function properly. When calling this\n    /// method, none of the contents will be \"read\" in the sense that later\n    /// calling `read` may return the same contents. As such, [`consume`] must\n    /// be called with the number of bytes that are consumed from this buffer to\n    /// ensure that the bytes are never returned twice.\n    ///\n    /// [`consume`]: #tymethod.consume\n    ///\n    /// An empty buffer returned indicates that the stream has reached EOF.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an I/O error if the underlying reader was\n    /// read, but returned an error.\n    ///\n    /// # Examples\n    ///\n    /// A locked standard input implements `BufRead`:\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    ///\n    /// let stdin = io::stdin();\n    /// let mut stdin = stdin.lock();\n    ///\n    /// // we can't have two `&mut` references to `stdin`, so use a block\n    /// // to end the borrow early.\n    /// let length = {\n    ///     let buffer = stdin.fill_buf().unwrap();\n    ///\n    ///     // work with buffer\n    ///     println!(\"{:?}\", buffer);\n    ///\n    ///     buffer.len()\n    /// };\n    ///\n    /// // ensure the bytes we worked with aren't returned again later\n    /// stdin.consume(length);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn fill_buf(&mut self) -> Result<&[u8]>;\n\n    /// Tells this buffer that `amt` bytes have been consumed from the buffer,\n    /// so they should no longer be returned in calls to `read`.\n    ///\n    /// This function is a lower-level call. It needs to be paired with the\n    /// [`fill_buf`] method to function properly. This function does\n    /// not perform any I/O, it simply informs this object that some amount of\n    /// its buffer, returned from [`fill_buf`], has been consumed and should\n    /// no longer be returned. As such, this function may do odd things if\n    /// [`fill_buf`] isn't called before calling it.\n    ///\n    /// The `amt` must be `<=` the number of bytes in the buffer returned by\n    /// [`fill_buf`].\n    ///\n    /// # Examples\n    ///\n    /// Since `consume()` is meant to be used with [`fill_buf`],\n    /// that method's example includes an example of `consume()`.\n    ///\n    /// [`fill_buf`]: #tymethod.fill_buf\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn consume(&mut self, amt: usize);\n\n    /// Read all bytes into `buf` until the delimiter `byte` or EOF is reached.\n    ///\n    /// This function will read bytes from the underlying stream until the\n    /// delimiter or EOF is found. Once found, all bytes up to, and including,\n    /// the delimiter (if found) will be appended to `buf`.\n    ///\n    /// If successful, this function will return the total number of bytes read.\n    ///\n    /// # Errors\n    ///\n    /// This function will ignore all instances of [`ErrorKind::Interrupted`] and\n    /// will otherwise return any errors returned by [`fill_buf`].\n    ///\n    /// If an I/O error is encountered then all bytes read so far will be\n    /// present in `buf` and its length will have been adjusted appropriately.\n    ///\n    /// [`fill_buf`]: #tymethod.fill_buf\n    /// [`ErrorKind::Interrupted`]: enum.ErrorKind.html#variant.Interrupted\n    ///\n    /// # Examples\n    ///\n    /// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In\n    /// this example, we use [`Cursor`] to read all the bytes in a byte slice\n    /// in hyphen delimited segments:\n    ///\n    /// [`Cursor`]: struct.Cursor.html\n    ///\n    /// ```\n    /// use std::io::{self, BufRead};\n    ///\n    /// let mut cursor = io::Cursor::new(b\"lorem-ipsum\");\n    /// let mut buf = vec![];\n    ///\n    /// // cursor is at 'l'\n    /// let num_bytes = cursor.read_until(b'-', &mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 6);\n    /// assert_eq!(buf, b\"lorem-\");\n    /// buf.clear();\n    ///\n    /// // cursor is at 'i'\n    /// let num_bytes = cursor.read_until(b'-', &mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 5);\n    /// assert_eq!(buf, b\"ipsum\");\n    /// buf.clear();\n    ///\n    /// // cursor is at EOF\n    /// let num_bytes = cursor.read_until(b'-', &mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 0);\n    /// assert_eq!(buf, b\"\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize> {\n        read_until(self, byte, buf)\n    }\n\n    /// Read all bytes until a newline (the 0xA byte) is reached, and append\n    /// them to the provided buffer.\n    ///\n    /// This function will read bytes from the underlying stream until the\n    /// newline delimiter (the 0xA byte) or EOF is found. Once found, all bytes\n    /// up to, and including, the delimiter (if found) will be appended to\n    /// `buf`.\n    ///\n    /// If successful, this function will return the total number of bytes read.\n    ///\n    /// An empty buffer returned indicates that the stream has reached EOF.\n    ///\n    /// # Errors\n    ///\n    /// This function has the same error semantics as [`read_until`] and will\n    /// also return an error if the read bytes are not valid UTF-8. If an I/O\n    /// error is encountered then `buf` may contain some bytes already read in\n    /// the event that all data read so far was valid UTF-8.\n    ///\n    /// [`read_until`]: #method.read_until\n    ///\n    /// # Examples\n    ///\n    /// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In\n    /// this example, we use [`Cursor`] to read all the lines in a byte slice:\n    ///\n    /// [`Cursor`]: struct.Cursor.html\n    ///\n    /// ```\n    /// use std::io::{self, BufRead};\n    ///\n    /// let mut cursor = io::Cursor::new(b\"foo\\nbar\");\n    /// let mut buf = String::new();\n    ///\n    /// // cursor is at 'f'\n    /// let num_bytes = cursor.read_line(&mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 4);\n    /// assert_eq!(buf, \"foo\\n\");\n    /// buf.clear();\n    ///\n    /// // cursor is at 'b'\n    /// let num_bytes = cursor.read_line(&mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 3);\n    /// assert_eq!(buf, \"bar\");\n    /// buf.clear();\n    ///\n    /// // cursor is at EOF\n    /// let num_bytes = cursor.read_line(&mut buf)\n    ///     .expect(\"reading from cursor won't fail\");\n    /// assert_eq!(num_bytes, 0);\n    /// assert_eq!(buf, \"\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn read_line(&mut self, buf: &mut String) -> Result<usize> {\n        // Note that we are not calling the `.read_until` method here, but\n        // rather our hardcoded implementation. For more details as to why, see\n        // the comments in `read_to_end`.\n        append_to_string(buf, |b| read_until(self, b'\\n', b))\n    }\n\n    /// Returns an iterator over the contents of this reader split on the byte\n    /// `byte`.\n    ///\n    /// The iterator returned from this function will return instances of\n    /// [`io::Result`]`<`[`Vec<u8>`]`>`. Each vector returned will *not* have\n    /// the delimiter byte at the end.\n    ///\n    /// This function will yield errors whenever [`read_until`] would have\n    /// also yielded an error.\n    ///\n    /// [`io::Result`]: type.Result.html\n    /// [`Vec<u8>`]: ../vec/struct.Vec.html\n    /// [`read_until`]: #method.read_until\n    ///\n    /// # Examples\n    ///\n    /// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In\n    /// this example, we use [`Cursor`] to iterate over all hyphen delimited\n    /// segments in a byte slice\n    ///\n    /// [`Cursor`]: struct.Cursor.html\n    ///\n    /// ```\n    /// use std::io::{self, BufRead};\n    ///\n    /// let cursor = io::Cursor::new(b\"lorem-ipsum-dolor\");\n    ///\n    /// let mut split_iter = cursor.split(b'-').map(|l| l.unwrap());\n    /// assert_eq!(split_iter.next(), Some(b\"lorem\".to_vec()));\n    /// assert_eq!(split_iter.next(), Some(b\"ipsum\".to_vec()));\n    /// assert_eq!(split_iter.next(), Some(b\"dolor\".to_vec()));\n    /// assert_eq!(split_iter.next(), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn split(self, byte: u8) -> Split<Self> where Self: Sized {\n        Split { buf: self, delim: byte }\n    }\n\n    /// Returns an iterator over the lines of this reader.\n    ///\n    /// The iterator returned from this function will yield instances of\n    /// [`io::Result`]`<`[`String`]`>`. Each string returned will *not* have a newline\n    /// byte (the 0xA byte) or CRLF (0xD, 0xA bytes) at the end.\n    ///\n    /// [`io::Result`]: type.Result.html\n    /// [`String`]: ../string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// [`std::io::Cursor`][`Cursor`] is a type that implements `BufRead`. In\n    /// this example, we use [`Cursor`] to iterate over all the lines in a byte\n    /// slice.\n    ///\n    /// [`Cursor`]: struct.Cursor.html\n    ///\n    /// ```\n    /// use std::io::{self, BufRead};\n    ///\n    /// let cursor = io::Cursor::new(b\"lorem\\nipsum\\r\\ndolor\");\n    ///\n    /// let mut lines_iter = cursor.lines().map(|l| l.unwrap());\n    /// assert_eq!(lines_iter.next(), Some(String::from(\"lorem\")));\n    /// assert_eq!(lines_iter.next(), Some(String::from(\"ipsum\")));\n    /// assert_eq!(lines_iter.next(), Some(String::from(\"dolor\")));\n    /// assert_eq!(lines_iter.next(), None);\n    /// ```\n    ///\n    /// # Errors\n    ///\n    /// Each line of the iterator has the same error semantics as [`BufRead::read_line`].\n    ///\n    /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn lines(self) -> Lines<Self> where Self: Sized {\n        Lines { buf: self }\n    }\n}\n\n/// Adaptor to chain together two readers.\n///\n/// This struct is generally created by calling [`chain`] on a reader.\n/// Please see the documentation of [`chain`] for more details.\n///\n/// [`chain`]: trait.Read.html#method.chain\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Chain<T, U> {\n    first: T,\n    second: U,\n    done_first: bool,\n}\n\nimpl<T, U> Chain<T, U> {\n    /// Consumes the `Chain`, returning the wrapped readers.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut foo_file = File::open(\"foo.txt\")?;\n    ///     let mut bar_file = File::open(\"bar.txt\")?;\n    ///\n    ///     let chain = foo_file.chain(bar_file);\n    ///     let (foo_file, bar_file) = chain.into_inner();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"more_io_inner_methods\", since = \"1.20.0\")]\n    pub fn into_inner(self) -> (T, U) {\n        (self.first, self.second)\n    }\n\n    /// Gets references to the underlying readers in this `Chain`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut foo_file = File::open(\"foo.txt\")?;\n    ///     let mut bar_file = File::open(\"bar.txt\")?;\n    ///\n    ///     let chain = foo_file.chain(bar_file);\n    ///     let (foo_file, bar_file) = chain.get_ref();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"more_io_inner_methods\", since = \"1.20.0\")]\n    pub fn get_ref(&self) -> (&T, &U) {\n        (&self.first, &self.second)\n    }\n\n    /// Gets mutable references to the underlying readers in this `Chain`.\n    ///\n    /// Care should be taken to avoid modifying the internal I/O state of the\n    /// underlying readers as doing so may corrupt the internal state of this\n    /// `Chain`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut foo_file = File::open(\"foo.txt\")?;\n    ///     let mut bar_file = File::open(\"bar.txt\")?;\n    ///\n    ///     let mut chain = foo_file.chain(bar_file);\n    ///     let (foo_file, bar_file) = chain.get_mut();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"more_io_inner_methods\", since = \"1.20.0\")]\n    pub fn get_mut(&mut self) -> (&mut T, &mut U) {\n        (&mut self.first, &mut self.second)\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<T: fmt::Debug, U: fmt::Debug> fmt::Debug for Chain<T, U> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Chain\")\n            .field(\"t\", &self.first)\n            .field(\"u\", &self.second)\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Read, U: Read> Read for Chain<T, U> {\n    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {\n        if !self.done_first {\n            match self.first.read(buf)? {\n                0 if buf.len() != 0 => { self.done_first = true; }\n                n => return Ok(n),\n            }\n        }\n        self.second.read(buf)\n    }\n\n    unsafe fn initializer(&self) -> Initializer {\n        let initializer = self.first.initializer();\n        if initializer.should_initialize() {\n            initializer\n        } else {\n            self.second.initializer()\n        }\n    }\n}\n\n#[stable(feature = \"chain_bufread\", since = \"1.9.0\")]\nimpl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {\n    fn fill_buf(&mut self) -> Result<&[u8]> {\n        if !self.done_first {\n            match self.first.fill_buf()? {\n                buf if buf.len() == 0 => { self.done_first = true; }\n                buf => return Ok(buf),\n            }\n        }\n        self.second.fill_buf()\n    }\n\n    fn consume(&mut self, amt: usize) {\n        if !self.done_first {\n            self.first.consume(amt)\n        } else {\n            self.second.consume(amt)\n        }\n    }\n}\n\n/// Reader adaptor which limits the bytes read from an underlying reader.\n///\n/// This struct is generally created by calling [`take`] on a reader.\n/// Please see the documentation of [`take`] for more details.\n///\n/// [`take`]: trait.Read.html#method.take\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Take<T> {\n    inner: T,\n    limit: u64,\n}\n\nimpl<T> Take<T> {\n    /// Returns the number of bytes that can be read before this instance will\n    /// return EOF.\n    ///\n    /// # Note\n    ///\n    /// This instance may reach `EOF` after reading fewer bytes than indicated by\n    /// this method if the underlying [`Read`] instance reaches EOF.\n    ///\n    /// [`Read`]: ../../std/io/trait.Read.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let f = File::open(\"foo.txt\")?;\n    ///\n    ///     // read at most five bytes\n    ///     let handle = f.take(5);\n    ///\n    ///     println!(\"limit: {}\", handle.limit());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn limit(&self) -> u64 { self.limit }\n\n    /// Sets the number of bytes that can be read before this instance will\n    /// return EOF. This is the same as constructing a new `Take` instance, so\n    /// the amount of bytes read and the previous limit value don't matter when\n    /// calling this method.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let f = File::open(\"foo.txt\")?;\n    ///\n    ///     // read at most five bytes\n    ///     let mut handle = f.take(5);\n    ///     handle.set_limit(10);\n    ///\n    ///     assert_eq!(handle.limit(), 10);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"take_set_limit\", since = \"1.27.0\")]\n    pub fn set_limit(&mut self, limit: u64) {\n        self.limit = limit;\n    }\n\n    /// Consumes the `Take`, returning the wrapped reader.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut file = File::open(\"foo.txt\")?;\n    ///\n    ///     let mut buffer = [0; 5];\n    ///     let mut handle = file.take(5);\n    ///     handle.read(&mut buffer)?;\n    ///\n    ///     let file = handle.into_inner();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"io_take_into_inner\", since = \"1.15.0\")]\n    pub fn into_inner(self) -> T {\n        self.inner\n    }\n\n    /// Gets a reference to the underlying reader.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut file = File::open(\"foo.txt\")?;\n    ///\n    ///     let mut buffer = [0; 5];\n    ///     let mut handle = file.take(5);\n    ///     handle.read(&mut buffer)?;\n    ///\n    ///     let file = handle.get_ref();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"more_io_inner_methods\", since = \"1.20.0\")]\n    pub fn get_ref(&self) -> &T {\n        &self.inner\n    }\n\n    /// Gets a mutable reference to the underlying reader.\n    ///\n    /// Care should be taken to avoid modifying the internal I/O state of the\n    /// underlying reader as doing so may corrupt the internal limit of this\n    /// `Take`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    /// use std::io::prelude::*;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut file = File::open(\"foo.txt\")?;\n    ///\n    ///     let mut buffer = [0; 5];\n    ///     let mut handle = file.take(5);\n    ///     handle.read(&mut buffer)?;\n    ///\n    ///     let file = handle.get_mut();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"more_io_inner_methods\", since = \"1.20.0\")]\n    pub fn get_mut(&mut self) -> &mut T {\n        &mut self.inner\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: Read> Read for Take<T> {\n    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {\n        // Don't call into inner reader at all at EOF because it may still block\n        if self.limit == 0 {\n            return Ok(0);\n        }\n\n        let max = cmp::min(buf.len() as u64, self.limit) as usize;\n        let n = self.inner.read(&mut buf[..max])?;\n        self.limit -= n as u64;\n        Ok(n)\n    }\n\n    unsafe fn initializer(&self) -> Initializer {\n        self.inner.initializer()\n    }\n\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize> {\n        let reservation_size = cmp::min(self.limit, 32) as usize;\n\n        read_to_end_with_reservation(self, buf, reservation_size)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: BufRead> BufRead for Take<T> {\n    fn fill_buf(&mut self) -> Result<&[u8]> {\n        // Don't call into inner reader at all at EOF because it may still block\n        if self.limit == 0 {\n            return Ok(&[]);\n        }\n\n        let buf = self.inner.fill_buf()?;\n        let cap = cmp::min(buf.len() as u64, self.limit) as usize;\n        Ok(&buf[..cap])\n    }\n\n    fn consume(&mut self, amt: usize) {\n        // Don't let callers reset the limit by passing an overlarge value\n        let amt = cmp::min(amt as u64, self.limit) as usize;\n        self.limit -= amt as u64;\n        self.inner.consume(amt);\n    }\n}\n\nfn read_one_byte(reader: &mut dyn Read) -> Option<Result<u8>> {\n    let mut buf = [0];\n    loop {\n        return match reader.read(&mut buf) {\n            Ok(0) => None,\n            Ok(..) => Some(Ok(buf[0])),\n            Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,\n            Err(e) => Some(Err(e)),\n        };\n    }\n}\n\n/// An iterator over `u8` values of a reader.\n///\n/// This struct is generally created by calling [`bytes`] on a reader.\n/// Please see the documentation of [`bytes`] for more details.\n///\n/// [`bytes`]: trait.Read.html#method.bytes\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Bytes<R> {\n    inner: R,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R: Read> Iterator for Bytes<R> {\n    type Item = Result<u8>;\n\n    fn next(&mut self) -> Option<Result<u8>> {\n        read_one_byte(&mut self.inner)\n    }\n}\n\n/// An iterator over the contents of an instance of `BufRead` split on a\n/// particular byte.\n///\n/// This struct is generally created by calling [`split`][split] on a\n/// `BufRead`. Please see the documentation of `split()` for more details.\n///\n/// [split]: trait.BufRead.html#method.split\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Split<B> {\n    buf: B,\n    delim: u8,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B: BufRead> Iterator for Split<B> {\n    type Item = Result<Vec<u8>>;\n\n    fn next(&mut self) -> Option<Result<Vec<u8>>> {\n        let mut buf = Vec::new();\n        match self.buf.read_until(self.delim, &mut buf) {\n            Ok(0) => None,\n            Ok(_n) => {\n                if buf[buf.len() - 1] == self.delim {\n                    buf.pop();\n                }\n                Some(Ok(buf))\n            }\n            Err(e) => Some(Err(e))\n        }\n    }\n}\n\n/// An iterator over the lines of an instance of `BufRead`.\n///\n/// This struct is generally created by calling [`lines`][lines] on a\n/// `BufRead`. Please see the documentation of `lines()` for more details.\n///\n/// [lines]: trait.BufRead.html#method.lines\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Lines<B> {\n    buf: B,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B: BufRead> Iterator for Lines<B> {\n    type Item = Result<String>;\n\n    fn next(&mut self) -> Option<Result<String>> {\n        let mut buf = String::new();\n        match self.buf.read_line(&mut buf) {\n            Ok(0) => None,\n            Ok(_n) => {\n                if buf.ends_with(\"\\n\") {\n                    buf.pop();\n                    if buf.ends_with(\"\\r\") {\n                        buf.pop();\n                    }\n                }\n                Some(Ok(buf))\n            }\n            Err(e) => Some(Err(e))\n        }\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use io::prelude::*;\n    use io;\n    use super::Cursor;\n    use test;\n    use super::repeat;\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn read_until() {\n        let mut buf = Cursor::new(&b\"12\"[..]);\n        let mut v = Vec::new();\n        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 2);\n        assert_eq!(v, b\"12\");\n\n        let mut buf = Cursor::new(&b\"1233\"[..]);\n        let mut v = Vec::new();\n        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 3);\n        assert_eq!(v, b\"123\");\n        v.truncate(0);\n        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 1);\n        assert_eq!(v, b\"3\");\n        v.truncate(0);\n        assert_eq!(buf.read_until(b'3', &mut v).unwrap(), 0);\n        assert_eq!(v, []);\n    }\n\n    #[test]\n    fn split() {\n        let buf = Cursor::new(&b\"12\"[..]);\n        let mut s = buf.split(b'3');\n        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);\n        assert!(s.next().is_none());\n\n        let buf = Cursor::new(&b\"1233\"[..]);\n        let mut s = buf.split(b'3');\n        assert_eq!(s.next().unwrap().unwrap(), vec![b'1', b'2']);\n        assert_eq!(s.next().unwrap().unwrap(), vec![]);\n        assert!(s.next().is_none());\n    }\n\n    #[test]\n    fn read_line() {\n        let mut buf = Cursor::new(&b\"12\"[..]);\n        let mut v = String::new();\n        assert_eq!(buf.read_line(&mut v).unwrap(), 2);\n        assert_eq!(v, \"12\");\n\n        let mut buf = Cursor::new(&b\"12\\n\\n\"[..]);\n        let mut v = String::new();\n        assert_eq!(buf.read_line(&mut v).unwrap(), 3);\n        assert_eq!(v, \"12\\n\");\n        v.truncate(0);\n        assert_eq!(buf.read_line(&mut v).unwrap(), 1);\n        assert_eq!(v, \"\\n\");\n        v.truncate(0);\n        assert_eq!(buf.read_line(&mut v).unwrap(), 0);\n        assert_eq!(v, \"\");\n    }\n\n    #[test]\n    fn lines() {\n        let buf = Cursor::new(&b\"12\\r\"[..]);\n        let mut s = buf.lines();\n        assert_eq!(s.next().unwrap().unwrap(), \"12\\r\".to_string());\n        assert!(s.next().is_none());\n\n        let buf = Cursor::new(&b\"12\\r\\n\\n\"[..]);\n        let mut s = buf.lines();\n        assert_eq!(s.next().unwrap().unwrap(), \"12\".to_string());\n        assert_eq!(s.next().unwrap().unwrap(), \"\".to_string());\n        assert!(s.next().is_none());\n    }\n\n    #[test]\n    fn read_to_end() {\n        let mut c = Cursor::new(&b\"\"[..]);\n        let mut v = Vec::new();\n        assert_eq!(c.read_to_end(&mut v).unwrap(), 0);\n        assert_eq!(v, []);\n\n        let mut c = Cursor::new(&b\"1\"[..]);\n        let mut v = Vec::new();\n        assert_eq!(c.read_to_end(&mut v).unwrap(), 1);\n        assert_eq!(v, b\"1\");\n\n        let cap = 1024 * 1024;\n        let data = (0..cap).map(|i| (i / 3) as u8).collect::<Vec<_>>();\n        let mut v = Vec::new();\n        let (a, b) = data.split_at(data.len() / 2);\n        assert_eq!(Cursor::new(a).read_to_end(&mut v).unwrap(), a.len());\n        assert_eq!(Cursor::new(b).read_to_end(&mut v).unwrap(), b.len());\n        assert_eq!(v, data);\n    }\n\n    #[test]\n    fn read_to_string() {\n        let mut c = Cursor::new(&b\"\"[..]);\n        let mut v = String::new();\n        assert_eq!(c.read_to_string(&mut v).unwrap(), 0);\n        assert_eq!(v, \"\");\n\n        let mut c = Cursor::new(&b\"1\"[..]);\n        let mut v = String::new();\n        assert_eq!(c.read_to_string(&mut v).unwrap(), 1);\n        assert_eq!(v, \"1\");\n\n        let mut c = Cursor::new(&b\"\\xff\"[..]);\n        let mut v = String::new();\n        assert!(c.read_to_string(&mut v).is_err());\n    }\n\n    #[test]\n    fn read_exact() {\n        let mut buf = [0; 4];\n\n        let mut c = Cursor::new(&b\"\"[..]);\n        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),\n                   io::ErrorKind::UnexpectedEof);\n\n        let mut c = Cursor::new(&b\"123\"[..]).chain(Cursor::new(&b\"456789\"[..]));\n        c.read_exact(&mut buf).unwrap();\n        assert_eq!(&buf, b\"1234\");\n        c.read_exact(&mut buf).unwrap();\n        assert_eq!(&buf, b\"5678\");\n        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),\n                   io::ErrorKind::UnexpectedEof);\n    }\n\n    #[test]\n    fn read_exact_slice() {\n        let mut buf = [0; 4];\n\n        let mut c = &b\"\"[..];\n        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),\n                   io::ErrorKind::UnexpectedEof);\n\n        let mut c = &b\"123\"[..];\n        assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),\n                   io::ErrorKind::UnexpectedEof);\n        // make sure the optimized (early returning) method is being used\n        assert_eq!(&buf, &[0; 4]);\n\n        let mut c = &b\"1234\"[..];\n        c.read_exact(&mut buf).unwrap();\n        assert_eq!(&buf, b\"1234\");\n\n        let mut c = &b\"56789\"[..];\n        c.read_exact(&mut buf).unwrap();\n        assert_eq!(&buf, b\"5678\");\n        assert_eq!(c, b\"9\");\n    }\n\n    #[test]\n    fn take_eof() {\n        struct R;\n\n        impl Read for R {\n            fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {\n                Err(io::Error::new(io::ErrorKind::Other, \"\"))\n            }\n        }\n        impl BufRead for R {\n            fn fill_buf(&mut self) -> io::Result<&[u8]> {\n                Err(io::Error::new(io::ErrorKind::Other, \"\"))\n            }\n            fn consume(&mut self, _amt: usize) { }\n        }\n\n        let mut buf = [0; 1];\n        assert_eq!(0, R.take(0).read(&mut buf).unwrap());\n        assert_eq!(b\"\", R.take(0).fill_buf().unwrap());\n    }\n\n    fn cmp_bufread<Br1: BufRead, Br2: BufRead>(mut br1: Br1, mut br2: Br2, exp: &[u8]) {\n        let mut cat = Vec::new();\n        loop {\n            let consume = {\n                let buf1 = br1.fill_buf().unwrap();\n                let buf2 = br2.fill_buf().unwrap();\n                let minlen = if buf1.len() < buf2.len() { buf1.len() } else { buf2.len() };\n                assert_eq!(buf1[..minlen], buf2[..minlen]);\n                cat.extend_from_slice(&buf1[..minlen]);\n                minlen\n            };\n            if consume == 0 {\n                break;\n            }\n            br1.consume(consume);\n            br2.consume(consume);\n        }\n        assert_eq!(br1.fill_buf().unwrap().len(), 0);\n        assert_eq!(br2.fill_buf().unwrap().len(), 0);\n        assert_eq!(&cat[..], &exp[..])\n    }\n\n    #[test]\n    fn chain_bufread() {\n        let testdata = b\"ABCDEFGHIJKL\";\n        let chain1 = (&testdata[..3]).chain(&testdata[3..6])\n                                     .chain(&testdata[6..9])\n                                     .chain(&testdata[9..]);\n        let chain2 = (&testdata[..4]).chain(&testdata[4..8])\n                                     .chain(&testdata[8..]);\n        cmp_bufread(chain1, chain2, &testdata[..]);\n    }\n\n    #[test]\n    fn chain_zero_length_read_is_not_eof() {\n        let a = b\"A\";\n        let b = b\"B\";\n        let mut s = String::new();\n        let mut chain = (&a[..]).chain(&b[..]);\n        chain.read(&mut []).unwrap();\n        chain.read_to_string(&mut s).unwrap();\n        assert_eq!(\"AB\", s);\n    }\n\n    #[bench]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn bench_read_to_end(b: &mut test::Bencher) {\n        b.iter(|| {\n            let mut lr = repeat(1).take(10000000);\n            let mut vec = Vec::with_capacity(1024);\n            super::read_to_end(&mut lr, &mut vec)\n        });\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse error;\nuse fmt;\nuse result;\nuse sys;\nuse convert::From;\n\n/// A specialized [`Result`](../result/enum.Result.html) type for I/O\n/// operations.\n///\n/// This type is broadly used across [`std::io`] for any operation which may\n/// produce an error.\n///\n/// This typedef is generally used to avoid writing out [`io::Error`] directly and\n/// is otherwise a direct mapping to [`Result`].\n///\n/// While usual Rust style is to import types directly, aliases of [`Result`]\n/// often are not, to make it easier to distinguish between them. [`Result`] is\n/// generally assumed to be [`std::result::Result`][`Result`], and so users of this alias\n/// will generally use `io::Result` instead of shadowing the prelude's import\n/// of [`std::result::Result`][`Result`].\n///\n/// [`std::io`]: ../io/index.html\n/// [`io::Error`]: ../io/struct.Error.html\n/// [`Result`]: ../result/enum.Result.html\n///\n/// # Examples\n///\n/// A convenience function that bubbles an `io::Result` to its caller:\n///\n/// ```\n/// use std::io;\n///\n/// fn get_string() -> io::Result<String> {\n///     let mut buffer = String::new();\n///\n///     io::stdin().read_line(&mut buffer)?;\n///\n///     Ok(buffer)\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub type Result<T> = result::Result<T, Error>;\n\n/// The error type for I/O operations of the [`Read`], [`Write`], [`Seek`], and\n/// associated traits.\n///\n/// Errors mostly originate from the underlying OS, but custom instances of\n/// `Error` can be created with crafted error messages and a particular value of\n/// [`ErrorKind`].\n///\n/// [`Read`]: ../io/trait.Read.html\n/// [`Write`]: ../io/trait.Write.html\n/// [`Seek`]: ../io/trait.Seek.html\n/// [`ErrorKind`]: enum.ErrorKind.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Error {\n    repr: Repr,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for Error {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.repr, f)\n    }\n}\n\nenum Repr {\n    Os(i32),\n    Simple(ErrorKind),\n    Custom(Box<Custom>),\n}\n\n#[derive(Debug)]\nstruct Custom {\n    kind: ErrorKind,\n    error: Box<dyn error::Error+Send+Sync>,\n}\n\n/// A list specifying general categories of I/O error.\n///\n/// This list is intended to grow over time and it is not recommended to\n/// exhaustively match against it.\n///\n/// It is used with the [`io::Error`] type.\n///\n/// [`io::Error`]: struct.Error.html\n#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[allow(deprecated)]\n#[non_exhaustive]\npub enum ErrorKind {\n    /// An entity was not found, often a file.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    NotFound,\n    /// The operation lacked the necessary privileges to complete.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    PermissionDenied,\n    /// The connection was refused by the remote server.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    ConnectionRefused,\n    /// The connection was reset by the remote server.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    ConnectionReset,\n    /// The connection was aborted (terminated) by the remote server.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    ConnectionAborted,\n    /// The network operation failed because it was not connected yet.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    NotConnected,\n    /// A socket address could not be bound because the address is already in\n    /// use elsewhere.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    AddrInUse,\n    /// A nonexistent interface was requested or the requested address was not\n    /// local.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    AddrNotAvailable,\n    /// The operation failed because a pipe was closed.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    BrokenPipe,\n    /// An entity already exists, often a file.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    AlreadyExists,\n    /// The operation needs to block to complete, but the blocking operation was\n    /// requested to not occur.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    WouldBlock,\n    /// A parameter was incorrect.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    InvalidInput,\n    /// Data not valid for the operation were encountered.\n    ///\n    /// Unlike [`InvalidInput`], this typically means that the operation\n    /// parameters were valid, however the error was caused by malformed\n    /// input data.\n    ///\n    /// For example, a function that reads a file into a string will error with\n    /// `InvalidData` if the file's contents are not valid UTF-8.\n    ///\n    /// [`InvalidInput`]: #variant.InvalidInput\n    #[stable(feature = \"io_invalid_data\", since = \"1.2.0\")]\n    InvalidData,\n    /// The I/O operation's timeout expired, causing it to be canceled.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    TimedOut,\n    /// An error returned when an operation could not be completed because a\n    /// call to [`write`] returned [`Ok(0)`].\n    ///\n    /// This typically means that an operation could only succeed if it wrote a\n    /// particular number of bytes but only a smaller number of bytes could be\n    /// written.\n    ///\n    /// [`write`]: ../../std/io/trait.Write.html#tymethod.write\n    /// [`Ok(0)`]: ../../std/io/type.Result.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    WriteZero,\n    /// This operation was interrupted.\n    ///\n    /// Interrupted operations can typically be retried.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Interrupted,\n    /// Any I/O error not part of this list.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Other,\n\n    /// An error returned when an operation could not be completed because an\n    /// \"end of file\" was reached prematurely.\n    ///\n    /// This typically means that an operation could only succeed if it read a\n    /// particular number of bytes but only a smaller number of bytes could be\n    /// read.\n    #[stable(feature = \"read_exact\", since = \"1.6.0\")]\n    UnexpectedEof,\n}\n\nimpl ErrorKind {\n    fn as_str(&self) -> &'static str {\n        match *self {\n            ErrorKind::NotFound => \"entity not found\",\n            ErrorKind::PermissionDenied => \"permission denied\",\n            ErrorKind::ConnectionRefused => \"connection refused\",\n            ErrorKind::ConnectionReset => \"connection reset\",\n            ErrorKind::ConnectionAborted => \"connection aborted\",\n            ErrorKind::NotConnected => \"not connected\",\n            ErrorKind::AddrInUse => \"address in use\",\n            ErrorKind::AddrNotAvailable => \"address not available\",\n            ErrorKind::BrokenPipe => \"broken pipe\",\n            ErrorKind::AlreadyExists => \"entity already exists\",\n            ErrorKind::WouldBlock => \"operation would block\",\n            ErrorKind::InvalidInput => \"invalid input parameter\",\n            ErrorKind::InvalidData => \"invalid data\",\n            ErrorKind::TimedOut => \"timed out\",\n            ErrorKind::WriteZero => \"write zero\",\n            ErrorKind::Interrupted => \"operation interrupted\",\n            ErrorKind::Other => \"other os error\",\n            ErrorKind::UnexpectedEof => \"unexpected end of file\",\n        }\n    }\n}\n\n/// Intended for use for errors not exposed to the user, where allocating onto\n/// the heap (for normal construction via Error::new) is too costly.\n#[stable(feature = \"io_error_from_errorkind\", since = \"1.14.0\")]\nimpl From<ErrorKind> for Error {\n    /// Converts an [`ErrorKind`] into an [`Error`].\n    ///\n    /// This conversion allocates a new error with a simple representation of error kind.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// let not_found = ErrorKind::NotFound;\n    /// let error = Error::from(not_found);\n    /// assert_eq!(\"entity not found\", format!(\"{}\", error));\n    /// ```\n    #[inline]\n    fn from(kind: ErrorKind) -> Error {\n        Error {\n            repr: Repr::Simple(kind)\n        }\n    }\n}\n\nimpl Error {\n    /// Creates a new I/O error from a known kind of error as well as an\n    /// arbitrary error payload.\n    ///\n    /// This function is used to generically create I/O errors which do not\n    /// originate from the OS itself. The `error` argument is an arbitrary\n    /// payload which will be contained in this `Error`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// // errors can be created from strings\n    /// let custom_error = Error::new(ErrorKind::Other, \"oh no!\");\n    ///\n    /// // errors can also be created from other errors\n    /// let custom_error2 = Error::new(ErrorKind::Interrupted, custom_error);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new<E>(kind: ErrorKind, error: E) -> Error\n        where E: Into<Box<dyn error::Error+Send+Sync>>\n    {\n        Self::_new(kind, error.into())\n    }\n\n    fn _new(kind: ErrorKind, error: Box<dyn error::Error+Send+Sync>) -> Error {\n        Error {\n            repr: Repr::Custom(Box::new(Custom {\n                kind,\n                error,\n            }))\n        }\n    }\n\n    /// Returns an error representing the last OS error which occurred.\n    ///\n    /// This function reads the value of `errno` for the target platform (e.g.\n    /// `GetLastError` on Windows) and will return a corresponding instance of\n    /// `Error` for the error code.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Error;\n    ///\n    /// println!(\"last OS error: {:?}\", Error::last_os_error());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn last_os_error() -> Error {\n        Error::from_raw_os_error(sys::os::errno() as i32)\n    }\n\n    /// Creates a new instance of an `Error` from a particular OS error code.\n    ///\n    /// # Examples\n    ///\n    /// On Linux:\n    ///\n    /// ```\n    /// # if cfg!(target_os = \"linux\") {\n    /// use std::io;\n    ///\n    /// let error = io::Error::from_raw_os_error(22);\n    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);\n    /// # }\n    /// ```\n    ///\n    /// On Windows:\n    ///\n    /// ```\n    /// # if cfg!(windows) {\n    /// use std::io;\n    ///\n    /// let error = io::Error::from_raw_os_error(10022);\n    /// assert_eq!(error.kind(), io::ErrorKind::InvalidInput);\n    /// # }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn from_raw_os_error(code: i32) -> Error {\n        Error { repr: Repr::Os(code) }\n    }\n\n    /// Returns the OS error that this error represents (if any).\n    ///\n    /// If this `Error` was constructed via `last_os_error` or\n    /// `from_raw_os_error`, then this function will return `Some`, otherwise\n    /// it will return `None`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// fn print_os_error(err: &Error) {\n    ///     if let Some(raw_os_err) = err.raw_os_error() {\n    ///         println!(\"raw OS error: {:?}\", raw_os_err);\n    ///     } else {\n    ///         println!(\"Not an OS error\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     // Will print \"raw OS error: ...\".\n    ///     print_os_error(&Error::last_os_error());\n    ///     // Will print \"Not an OS error\".\n    ///     print_os_error(&Error::new(ErrorKind::Other, \"oh no!\"));\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn raw_os_error(&self) -> Option<i32> {\n        match self.repr {\n            Repr::Os(i) => Some(i),\n            Repr::Custom(..) => None,\n            Repr::Simple(..) => None,\n        }\n    }\n\n    /// Returns a reference to the inner error wrapped by this error (if any).\n    ///\n    /// If this `Error` was constructed via `new` then this function will\n    /// return `Some`, otherwise it will return `None`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// fn print_error(err: &Error) {\n    ///     if let Some(inner_err) = err.get_ref() {\n    ///         println!(\"Inner error: {:?}\", inner_err);\n    ///     } else {\n    ///         println!(\"No inner error\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     // Will print \"No inner error\".\n    ///     print_error(&Error::last_os_error());\n    ///     // Will print \"Inner error: ...\".\n    ///     print_error(&Error::new(ErrorKind::Other, \"oh no!\"));\n    /// }\n    /// ```\n    #[stable(feature = \"io_error_inner\", since = \"1.3.0\")]\n    pub fn get_ref(&self) -> Option<&(dyn error::Error+Send+Sync+'static)> {\n        match self.repr {\n            Repr::Os(..) => None,\n            Repr::Simple(..) => None,\n            Repr::Custom(ref c) => Some(&*c.error),\n        }\n    }\n\n    /// Returns a mutable reference to the inner error wrapped by this error\n    /// (if any).\n    ///\n    /// If this `Error` was constructed via `new` then this function will\n    /// return `Some`, otherwise it will return `None`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    /// use std::{error, fmt};\n    /// use std::fmt::Display;\n    ///\n    /// #[derive(Debug)]\n    /// struct MyError {\n    ///     v: String,\n    /// }\n    ///\n    /// impl MyError {\n    ///     fn new() -> MyError {\n    ///         MyError {\n    ///             v: \"oh no!\".to_string()\n    ///         }\n    ///     }\n    ///\n    ///     fn change_message(&mut self, new_message: &str) {\n    ///         self.v = new_message.to_string();\n    ///     }\n    /// }\n    ///\n    /// impl error::Error for MyError {\n    ///     fn description(&self) -> &str { &self.v }\n    /// }\n    ///\n    /// impl Display for MyError {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"MyError: {}\", &self.v)\n    ///     }\n    /// }\n    ///\n    /// fn change_error(mut err: Error) -> Error {\n    ///     if let Some(inner_err) = err.get_mut() {\n    ///         inner_err.downcast_mut::<MyError>().unwrap().change_message(\"I've been changed!\");\n    ///     }\n    ///     err\n    /// }\n    ///\n    /// fn print_error(err: &Error) {\n    ///     if let Some(inner_err) = err.get_ref() {\n    ///         println!(\"Inner error: {}\", inner_err);\n    ///     } else {\n    ///         println!(\"No inner error\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     // Will print \"No inner error\".\n    ///     print_error(&change_error(Error::last_os_error()));\n    ///     // Will print \"Inner error: ...\".\n    ///     print_error(&change_error(Error::new(ErrorKind::Other, MyError::new())));\n    /// }\n    /// ```\n    #[stable(feature = \"io_error_inner\", since = \"1.3.0\")]\n    pub fn get_mut(&mut self) -> Option<&mut (dyn error::Error+Send+Sync+'static)> {\n        match self.repr {\n            Repr::Os(..) => None,\n            Repr::Simple(..) => None,\n            Repr::Custom(ref mut c) => Some(&mut *c.error),\n        }\n    }\n\n    /// Consumes the `Error`, returning its inner error (if any).\n    ///\n    /// If this `Error` was constructed via `new` then this function will\n    /// return `Some`, otherwise it will return `None`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// fn print_error(err: Error) {\n    ///     if let Some(inner_err) = err.into_inner() {\n    ///         println!(\"Inner error: {}\", inner_err);\n    ///     } else {\n    ///         println!(\"No inner error\");\n    ///     }\n    /// }\n    ///\n    /// fn main() {\n    ///     // Will print \"No inner error\".\n    ///     print_error(Error::last_os_error());\n    ///     // Will print \"Inner error: ...\".\n    ///     print_error(Error::new(ErrorKind::Other, \"oh no!\"));\n    /// }\n    /// ```\n    #[stable(feature = \"io_error_inner\", since = \"1.3.0\")]\n    pub fn into_inner(self) -> Option<Box<dyn error::Error+Send+Sync>> {\n        match self.repr {\n            Repr::Os(..) => None,\n            Repr::Simple(..) => None,\n            Repr::Custom(c) => Some(c.error)\n        }\n    }\n\n    /// Returns the corresponding `ErrorKind` for this error.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{Error, ErrorKind};\n    ///\n    /// fn print_error(err: Error) {\n    ///     println!(\"{:?}\", err.kind());\n    /// }\n    ///\n    /// fn main() {\n    ///     // Will print \"No inner error\".\n    ///     print_error(Error::last_os_error());\n    ///     // Will print \"Inner error: ...\".\n    ///     print_error(Error::new(ErrorKind::AddrInUse, \"oh no!\"));\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn kind(&self) -> ErrorKind {\n        match self.repr {\n            Repr::Os(code) => sys::decode_error_kind(code),\n            Repr::Custom(ref c) => c.kind,\n            Repr::Simple(kind) => kind,\n        }\n    }\n}\n\nimpl fmt::Debug for Repr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            Repr::Os(code) =>\n                fmt.debug_struct(\"Os\")\n                    .field(\"code\", &code)\n                    .field(\"kind\", &sys::decode_error_kind(code))\n                    .field(\"message\", &sys::os::error_string(code)).finish(),\n            Repr::Custom(ref c) => fmt::Debug::fmt(&c, fmt),\n            Repr::Simple(kind) => fmt.debug_tuple(\"Kind\").field(&kind).finish(),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for Error {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        match self.repr {\n            Repr::Os(code) => {\n                let detail = sys::os::error_string(code);\n                write!(fmt, \"{} (os error {})\", detail, code)\n            }\n            Repr::Custom(ref c) => c.error.fmt(fmt),\n            Repr::Simple(kind) => write!(fmt, \"{}\", kind.as_str()),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl error::Error for Error {\n    fn description(&self) -> &str {\n        match self.repr {\n            Repr::Os(..) | Repr::Simple(..) => self.kind().as_str(),\n            Repr::Custom(ref c) => c.error.description(),\n        }\n    }\n\n    fn cause(&self) -> Option<&dyn error::Error> {\n        match self.repr {\n            Repr::Os(..) => None,\n            Repr::Simple(..) => None,\n            Repr::Custom(ref c) => c.error.cause(),\n        }\n    }\n}\n\nfn _assert_error_is_sync_send() {\n    fn _is_sync_send<T: Sync+Send>() {}\n    _is_sync_send::<Error>();\n}\n\n#[cfg(test)]\nmod test {\n    use super::{Error, ErrorKind, Repr, Custom};\n    use error;\n    use fmt;\n    use sys::os::error_string;\n    use sys::decode_error_kind;\n\n    #[test]\n    fn test_debug_error() {\n        let code = 6;\n        let msg = error_string(code);\n        let kind = decode_error_kind(code);\n        let err = Error {\n            repr: Repr::Custom(box Custom {\n                kind: ErrorKind::InvalidInput,\n                error: box Error {\n                    repr: super::Repr::Os(code)\n                },\n            })\n        };\n        let expected = format!(\n            \"Custom {{ \\\n                kind: InvalidInput, \\\n                error: Os {{ \\\n                    code: {:?}, \\\n                    kind: {:?}, \\\n                    message: {:?} \\\n                }} \\\n            }}\",\n            code, kind, msg\n        );\n        assert_eq!(format!(\"{:?}\", err), expected);\n    }\n\n    #[test]\n    fn test_downcasting() {\n        #[derive(Debug)]\n        struct TestError;\n\n        impl fmt::Display for TestError {\n            fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {\n                Ok(())\n            }\n        }\n\n        impl error::Error for TestError {\n            fn description(&self) -> &str {\n                \"asdf\"\n            }\n        }\n\n        // we have to call all of these UFCS style right now since method\n        // resolution won't implicitly drop the Send+Sync bounds\n        let mut err = Error::new(ErrorKind::Other, TestError);\n        assert!(err.get_ref().unwrap().is::<TestError>());\n        assert_eq!(\"asdf\", err.get_ref().unwrap().description());\n        assert!(err.get_mut().unwrap().is::<TestError>());\n        let extracted = err.into_inner().unwrap();\n        extracted.downcast::<TestError>().unwrap();\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse io::prelude::*;\n\nuse cell::RefCell;\nuse fmt;\nuse io::lazy::Lazy;\nuse io::{self, Initializer, BufReader, LineWriter};\nuse sync::{Arc, Mutex, MutexGuard};\nuse sys::stdio;\nuse sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};\nuse thread::LocalKey;\n\n/// Stdout used by print! and println! macros\nthread_local! {\n    static LOCAL_STDOUT: RefCell<Option<Box<dyn Write + Send>>> = {\n        RefCell::new(None)\n    }\n}\n\n/// A handle to a raw instance of the standard input stream of this process.\n///\n/// This handle is not synchronized or buffered in any fashion. Constructed via\n/// the `std::io::stdio::stdin_raw` function.\nstruct StdinRaw(stdio::Stdin);\n\n/// A handle to a raw instance of the standard output stream of this process.\n///\n/// This handle is not synchronized or buffered in any fashion. Constructed via\n/// the `std::io::stdio::stdout_raw` function.\nstruct StdoutRaw(stdio::Stdout);\n\n/// A handle to a raw instance of the standard output stream of this process.\n///\n/// This handle is not synchronized or buffered in any fashion. Constructed via\n/// the `std::io::stdio::stderr_raw` function.\nstruct StderrRaw(stdio::Stderr);\n\n/// Constructs a new raw handle to the standard input of this process.\n///\n/// The returned handle does not interact with any other handles created nor\n/// handles returned by `std::io::stdin`. Data buffered by the `std::io::stdin`\n/// handles is **not** available to raw handles returned from this function.\n///\n/// The returned handle has no external synchronization or buffering.\nfn stdin_raw() -> io::Result<StdinRaw> { stdio::Stdin::new().map(StdinRaw) }\n\n/// Constructs a new raw handle to the standard output stream of this process.\n///\n/// The returned handle does not interact with any other handles created nor\n/// handles returned by `std::io::stdout`. Note that data is buffered by the\n/// `std::io::stdout` handles so writes which happen via this raw handle may\n/// appear before previous writes.\n///\n/// The returned handle has no external synchronization or buffering layered on\n/// top.\nfn stdout_raw() -> io::Result<StdoutRaw> { stdio::Stdout::new().map(StdoutRaw) }\n\n/// Constructs a new raw handle to the standard error stream of this process.\n///\n/// The returned handle does not interact with any other handles created nor\n/// handles returned by `std::io::stderr`.\n///\n/// The returned handle has no external synchronization or buffering layered on\n/// top.\nfn stderr_raw() -> io::Result<StderrRaw> { stdio::Stderr::new().map(StderrRaw) }\n\nimpl Read for StdinRaw {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> { self.0.read(buf) }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n}\nimpl Write for StdoutRaw {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.write(buf) }\n    fn flush(&mut self) -> io::Result<()> { self.0.flush() }\n}\nimpl Write for StderrRaw {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { self.0.write(buf) }\n    fn flush(&mut self) -> io::Result<()> { self.0.flush() }\n}\n\nenum Maybe<T> {\n    Real(T),\n    Fake,\n}\n\nimpl<W: io::Write> io::Write for Maybe<W> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        match *self {\n            Maybe::Real(ref mut w) => handle_ebadf(w.write(buf), buf.len()),\n            Maybe::Fake => Ok(buf.len())\n        }\n    }\n\n    fn flush(&mut self) -> io::Result<()> {\n        match *self {\n            Maybe::Real(ref mut w) => handle_ebadf(w.flush(), ()),\n            Maybe::Fake => Ok(())\n        }\n    }\n}\n\nimpl<R: io::Read> io::Read for Maybe<R> {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        match *self {\n            Maybe::Real(ref mut r) => handle_ebadf(r.read(buf), 0),\n            Maybe::Fake => Ok(0)\n        }\n    }\n}\n\nfn handle_ebadf<T>(r: io::Result<T>, default: T) -> io::Result<T> {\n    match r {\n        Err(ref e) if stdio::is_ebadf(e) => Ok(default),\n        r => r\n    }\n}\n\n/// A handle to the standard input stream of a process.\n///\n/// Each handle is a shared reference to a global buffer of input data to this\n/// process. A handle can be `lock`'d to gain full access to [`BufRead`] methods\n/// (e.g. `.lines()`). Reads to this handle are otherwise locked with respect\n/// to other reads.\n///\n/// This handle implements the `Read` trait, but beware that concurrent reads\n/// of `Stdin` must be executed with care.\n///\n/// Created by the [`io::stdin`] method.\n///\n/// [`io::stdin`]: fn.stdin.html\n/// [`BufRead`]: trait.BufRead.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Stdin {\n    inner: Arc<Mutex<BufReader<Maybe<StdinRaw>>>>,\n}\n\n/// A locked reference to the `Stdin` handle.\n///\n/// This handle implements both the [`Read`] and [`BufRead`] traits, and\n/// is constructed via the [`Stdin::lock`] method.\n///\n/// [`Read`]: trait.Read.html\n/// [`BufRead`]: trait.BufRead.html\n/// [`Stdin::lock`]: struct.Stdin.html#method.lock\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct StdinLock<'a> {\n    inner: MutexGuard<'a, BufReader<Maybe<StdinRaw>>>,\n}\n\n/// Constructs a new handle to the standard input of the current process.\n///\n/// Each handle returned is a reference to a shared global buffer whose access\n/// is synchronized via a mutex. If you need more explicit control over\n/// locking, see the [`lock() method`][lock].\n///\n/// [lock]: struct.Stdin.html#method.lock\n///\n/// # Examples\n///\n/// Using implicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Read};\n///\n/// fn main() -> io::Result<()> {\n///     let mut buffer = String::new();\n///     io::stdin().read_to_string(&mut buffer)?;\n///     Ok(())\n/// }\n/// ```\n///\n/// Using explicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Read};\n///\n/// fn main() -> io::Result<()> {\n///     let mut buffer = String::new();\n///     let stdin = io::stdin();\n///     let mut handle = stdin.lock();\n///\n///     handle.read_to_string(&mut buffer)?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn stdin() -> Stdin {\n    static INSTANCE: Lazy<Mutex<BufReader<Maybe<StdinRaw>>>> = Lazy::new();\n    return Stdin {\n        inner: unsafe {\n            INSTANCE.get(stdin_init).expect(\"cannot access stdin during shutdown\")\n        },\n    };\n\n    fn stdin_init() -> Arc<Mutex<BufReader<Maybe<StdinRaw>>>> {\n        // This must not reentrantly access `INSTANCE`\n        let stdin = match stdin_raw() {\n            Ok(stdin) => Maybe::Real(stdin),\n            _ => Maybe::Fake\n        };\n\n        Arc::new(Mutex::new(BufReader::with_capacity(stdio::STDIN_BUF_SIZE, stdin)))\n    }\n}\n\nimpl Stdin {\n    /// Locks this handle to the standard input stream, returning a readable\n    /// guard.\n    ///\n    /// The lock is released when the returned lock goes out of scope. The\n    /// returned guard also implements the [`Read`] and [`BufRead`] traits for\n    /// accessing the underlying data.\n    ///\n    /// [`Read`]: trait.Read.html\n    /// [`BufRead`]: trait.BufRead.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::{self, Read};\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let mut buffer = String::new();\n    ///     let stdin = io::stdin();\n    ///     let mut handle = stdin.lock();\n    ///\n    ///     handle.read_to_string(&mut buffer)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn lock(&self) -> StdinLock {\n        StdinLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) }\n    }\n\n    /// Locks this handle and reads a line of input into the specified buffer.\n    ///\n    /// For detailed semantics of this method, see the documentation on\n    /// [`BufRead::read_line`].\n    ///\n    /// [`BufRead::read_line`]: trait.BufRead.html#method.read_line\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io;\n    ///\n    /// let mut input = String::new();\n    /// match io::stdin().read_line(&mut input) {\n    ///     Ok(n) => {\n    ///         println!(\"{} bytes read\", n);\n    ///         println!(\"{}\", input);\n    ///     }\n    ///     Err(error) => println!(\"error: {}\", error),\n    /// }\n    /// ```\n    ///\n    /// You can run the example one of two ways:\n    ///\n    /// - Pipe some text to it, e.g. `printf foo | path/to/executable`\n    /// - Give it text interactively by running the executable directly,\n    ///   in which case it will wait for the Enter key to be pressed before\n    ///   continuing\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn read_line(&self, buf: &mut String) -> io::Result<usize> {\n        self.lock().read_line(buf)\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Stdin {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Stdin { .. }\")\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Read for Stdin {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        self.lock().read(buf)\n    }\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {\n        self.lock().read_to_end(buf)\n    }\n    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {\n        self.lock().read_to_string(buf)\n    }\n    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {\n        self.lock().read_exact(buf)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Read for StdinLock<'a> {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        self.inner.read(buf)\n    }\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> BufRead for StdinLock<'a> {\n    fn fill_buf(&mut self) -> io::Result<&[u8]> { self.inner.fill_buf() }\n    fn consume(&mut self, n: usize) { self.inner.consume(n) }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a> fmt::Debug for StdinLock<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"StdinLock { .. }\")\n    }\n}\n\n/// A handle to the global standard output stream of the current process.\n///\n/// Each handle shares a global buffer of data to be written to the standard\n/// output stream. Access is also synchronized via a lock and explicit control\n/// over locking is available via the [`lock`] method.\n///\n/// Created by the [`io::stdout`] method.\n///\n/// [`lock`]: #method.lock\n/// [`io::stdout`]: fn.stdout.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Stdout {\n    // FIXME: this should be LineWriter or BufWriter depending on the state of\n    //        stdout (tty or not). Note that if this is not line buffered it\n    //        should also flush-on-panic or some form of flush-on-abort.\n    inner: Arc<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>>,\n}\n\n/// A locked reference to the `Stdout` handle.\n///\n/// This handle implements the [`Write`] trait, and is constructed via\n/// the [`Stdout::lock`] method.\n///\n/// [`Write`]: trait.Write.html\n/// [`Stdout::lock`]: struct.Stdout.html#method.lock\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct StdoutLock<'a> {\n    inner: ReentrantMutexGuard<'a, RefCell<LineWriter<Maybe<StdoutRaw>>>>,\n}\n\n/// Constructs a new handle to the standard output of the current process.\n///\n/// Each handle returned is a reference to a shared global buffer whose access\n/// is synchronized via a mutex. If you need more explicit control over\n/// locking, see the [Stdout::lock] method.\n///\n/// [Stdout::lock]: struct.Stdout.html#method.lock\n///\n/// # Examples\n///\n/// Using implicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Write};\n///\n/// fn main() -> io::Result<()> {\n///     io::stdout().write(b\"hello world\")?;\n///\n///     Ok(())\n/// }\n/// ```\n///\n/// Using explicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Write};\n///\n/// fn main() -> io::Result<()> {\n///     let stdout = io::stdout();\n///     let mut handle = stdout.lock();\n///\n///     handle.write(b\"hello world\")?;\n///\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn stdout() -> Stdout {\n    static INSTANCE: Lazy<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>> = Lazy::new();\n    return Stdout {\n        inner: unsafe {\n            INSTANCE.get(stdout_init).expect(\"cannot access stdout during shutdown\")\n        },\n    };\n\n    fn stdout_init() -> Arc<ReentrantMutex<RefCell<LineWriter<Maybe<StdoutRaw>>>>> {\n        // This must not reentrantly access `INSTANCE`\n        let stdout = match stdout_raw() {\n            Ok(stdout) => Maybe::Real(stdout),\n            _ => Maybe::Fake,\n        };\n        Arc::new(ReentrantMutex::new(RefCell::new(LineWriter::new(stdout))))\n    }\n}\n\nimpl Stdout {\n    /// Locks this handle to the standard output stream, returning a writable\n    /// guard.\n    ///\n    /// The lock is released when the returned lock goes out of scope. The\n    /// returned guard also implements the `Write` trait for writing data.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::{self, Write};\n    ///\n    /// fn main() -> io::Result<()> {\n    ///     let stdout = io::stdout();\n    ///     let mut handle = stdout.lock();\n    ///\n    ///     handle.write(b\"hello world\")?;\n    ///\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn lock(&self) -> StdoutLock {\n        StdoutLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Stdout {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Stdout { .. }\")\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Write for Stdout {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.lock().write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        self.lock().flush()\n    }\n    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {\n        self.lock().write_all(buf)\n    }\n    fn write_fmt(&mut self, args: fmt::Arguments) -> io::Result<()> {\n        self.lock().write_fmt(args)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Write for StdoutLock<'a> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.inner.borrow_mut().write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        self.inner.borrow_mut().flush()\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a> fmt::Debug for StdoutLock<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"StdoutLock { .. }\")\n    }\n}\n\n/// A handle to the standard error stream of a process.\n///\n/// For more information, see the [`io::stderr`] method.\n///\n/// [`io::stderr`]: fn.stderr.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Stderr {\n    inner: Arc<ReentrantMutex<RefCell<Maybe<StderrRaw>>>>,\n}\n\n/// A locked reference to the `Stderr` handle.\n///\n/// This handle implements the `Write` trait and is constructed via\n/// the [`Stderr::lock`] method.\n///\n/// [`Stderr::lock`]: struct.Stderr.html#method.lock\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct StderrLock<'a> {\n    inner: ReentrantMutexGuard<'a, RefCell<Maybe<StderrRaw>>>,\n}\n\n/// Constructs a new handle to the standard error of the current process.\n///\n/// This handle is not buffered.\n///\n/// # Examples\n///\n/// Using implicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Write};\n///\n/// fn main() -> io::Result<()> {\n///     io::stderr().write(b\"hello world\")?;\n///\n///     Ok(())\n/// }\n/// ```\n///\n/// Using explicit synchronization:\n///\n/// ```no_run\n/// use std::io::{self, Write};\n///\n/// fn main() -> io::Result<()> {\n///     let stderr = io::stderr();\n///     let mut handle = stderr.lock();\n///\n///     handle.write(b\"hello world\")?;\n///\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn stderr() -> Stderr {\n    static INSTANCE: Lazy<ReentrantMutex<RefCell<Maybe<StderrRaw>>>> = Lazy::new();\n    return Stderr {\n        inner: unsafe {\n            INSTANCE.get(stderr_init).expect(\"cannot access stderr during shutdown\")\n        },\n    };\n\n    fn stderr_init() -> Arc<ReentrantMutex<RefCell<Maybe<StderrRaw>>>> {\n        // This must not reentrantly access `INSTANCE`\n        let stderr = match stderr_raw() {\n            Ok(stderr) => Maybe::Real(stderr),\n            _ => Maybe::Fake,\n        };\n        Arc::new(ReentrantMutex::new(RefCell::new(stderr)))\n    }\n}\n\nimpl Stderr {\n    /// Locks this handle to the standard error stream, returning a writable\n    /// guard.\n    ///\n    /// The lock is released when the returned lock goes out of scope. The\n    /// returned guard also implements the `Write` trait for writing data.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::{self, Write};\n    ///\n    /// fn foo() -> io::Result<()> {\n    ///     let stderr = io::stderr();\n    ///     let mut handle = stderr.lock();\n    ///\n    ///     handle.write(b\"hello world\")?;\n    ///\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn lock(&self) -> StderrLock {\n        StderrLock { inner: self.inner.lock().unwrap_or_else(|e| e.into_inner()) }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Stderr {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Stderr { .. }\")\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Write for Stderr {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.lock().write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        self.lock().flush()\n    }\n    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {\n        self.lock().write_all(buf)\n    }\n    fn write_fmt(&mut self, args: fmt::Arguments) -> io::Result<()> {\n        self.lock().write_fmt(args)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Write for StderrLock<'a> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.inner.borrow_mut().write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        self.inner.borrow_mut().flush()\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a> fmt::Debug for StderrLock<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"StderrLock { .. }\")\n    }\n}\n\n/// Resets the thread-local stderr handle to the specified writer\n///\n/// This will replace the current thread's stderr handle, returning the old\n/// handle. All future calls to `panic!` and friends will emit their output to\n/// this specified handle.\n///\n/// Note that this does not need to be called for all new threads; the default\n/// output handle is to the process's stderr stream.\n#[unstable(feature = \"set_stdio\",\n           reason = \"this function may disappear completely or be replaced \\\n                     with a more general mechanism\",\n           issue = \"0\")]\n#[doc(hidden)]\npub fn set_panic(sink: Option<Box<dyn Write + Send>>) -> Option<Box<dyn Write + Send>> {\n    use panicking::LOCAL_STDERR;\n    use mem;\n    LOCAL_STDERR.with(move |slot| {\n        mem::replace(&mut *slot.borrow_mut(), sink)\n    }).and_then(|mut s| {\n        let _ = s.flush();\n        Some(s)\n    })\n}\n\n/// Resets the thread-local stdout handle to the specified writer\n///\n/// This will replace the current thread's stdout handle, returning the old\n/// handle. All future calls to `print!` and friends will emit their output to\n/// this specified handle.\n///\n/// Note that this does not need to be called for all new threads; the default\n/// output handle is to the process's stdout stream.\n#[unstable(feature = \"set_stdio\",\n           reason = \"this function may disappear completely or be replaced \\\n                     with a more general mechanism\",\n           issue = \"0\")]\n#[doc(hidden)]\npub fn set_print(sink: Option<Box<dyn Write + Send>>) -> Option<Box<dyn Write + Send>> {\n    use mem;\n    LOCAL_STDOUT.with(move |slot| {\n        mem::replace(&mut *slot.borrow_mut(), sink)\n    }).and_then(|mut s| {\n        let _ = s.flush();\n        Some(s)\n    })\n}\n\n/// Write `args` to output stream `local_s` if possible, `global_s`\n/// otherwise. `label` identifies the stream in a panic message.\n///\n/// This function is used to print error messages, so it takes extra\n/// care to avoid causing a panic when `local_stream` is unusable.\n/// For instance, if the TLS key for the local stream is\n/// already destroyed, or if the local stream is locked by another\n/// thread, it will just fall back to the global stream.\n///\n/// However, if the actual I/O causes an error, this function does panic.\nfn print_to<T>(\n    args: fmt::Arguments,\n    local_s: &'static LocalKey<RefCell<Option<Box<dyn Write+Send>>>>,\n    global_s: fn() -> T,\n    label: &str,\n)\nwhere\n    T: Write,\n{\n    let result = local_s.try_with(|s| {\n        if let Ok(mut borrowed) = s.try_borrow_mut() {\n            if let Some(w) = borrowed.as_mut() {\n                return w.write_fmt(args);\n            }\n        }\n        global_s().write_fmt(args)\n    }).unwrap_or_else(|_| {\n        global_s().write_fmt(args)\n    });\n\n    if let Err(e) = result {\n        panic!(\"failed printing to {}: {}\", label, e);\n    }\n}\n\n#[unstable(feature = \"print_internals\",\n           reason = \"implementation detail which may disappear or be replaced at any time\",\n           issue = \"0\")]\n#[doc(hidden)]\npub fn _print(args: fmt::Arguments) {\n    print_to(args, &LOCAL_STDOUT, stdout, \"stdout\");\n}\n\n#[unstable(feature = \"print_internals\",\n           reason = \"implementation detail which may disappear or be replaced at any time\",\n           issue = \"0\")]\n#[doc(hidden)]\npub fn _eprint(args: fmt::Arguments) {\n    use panicking::LOCAL_STDERR;\n    print_to(args, &LOCAL_STDERR, stderr, \"stderr\");\n}\n\n#[cfg(test)]\nmod tests {\n    use panic::{UnwindSafe, RefUnwindSafe};\n    use thread;\n    use super::*;\n\n    #[test]\n    fn stdout_unwind_safe() {\n        assert_unwind_safe::<Stdout>();\n    }\n    #[test]\n    fn stdoutlock_unwind_safe() {\n        assert_unwind_safe::<StdoutLock>();\n        assert_unwind_safe::<StdoutLock<'static>>();\n    }\n    #[test]\n    fn stderr_unwind_safe() {\n        assert_unwind_safe::<Stderr>();\n    }\n    #[test]\n    fn stderrlock_unwind_safe() {\n        assert_unwind_safe::<StderrLock>();\n        assert_unwind_safe::<StderrLock<'static>>();\n    }\n\n    fn assert_unwind_safe<T: UnwindSafe + RefUnwindSafe>() {}\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn panic_doesnt_poison() {\n        thread::spawn(|| {\n            let _a = stdin();\n            let _a = _a.lock();\n            let _a = stdout();\n            let _a = _a.lock();\n            let _a = stderr();\n            let _a = _a.lock();\n            panic!();\n        }).join().unwrap_err();\n\n        let _a = stdin();\n        let _a = _a.lock();\n        let _a = stdout();\n        let _a = _a.lock();\n        let _a = stderr();\n        let _a = _a.lock();\n    }\n}\n","// Copyright 2013 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Buffering wrappers for I/O traits\n\nuse io::prelude::*;\n\nuse cmp;\nuse error;\nuse fmt;\nuse io::{self, Initializer, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};\nuse memchr;\n\n/// The `BufReader` struct adds buffering to any reader.\n///\n/// It can be excessively inefficient to work directly with a [`Read`] instance.\n/// For example, every call to [`read`][`TcpStream::read`] on [`TcpStream`]\n/// results in a system call. A `BufReader` performs large, infrequent reads on\n/// the underlying [`Read`] and maintains an in-memory buffer of the results.\n///\n/// `BufReader` can improve the speed of programs that make *small* and\n/// *repeated* read calls to the same file or network socket.  It does not\n/// help when reading very large amounts at once, or reading just one or a few\n/// times.  It also provides no advantage when reading from a source that is\n/// already in memory, like a `Vec<u8>`.\n///\n/// [`Read`]: ../../std/io/trait.Read.html\n/// [`TcpStream::read`]: ../../std/net/struct.TcpStream.html#method.read\n/// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::io::prelude::*;\n/// use std::io::BufReader;\n/// use std::fs::File;\n///\n/// fn main() -> std::io::Result<()> {\n///     let f = File::open(\"log.txt\")?;\n///     let mut reader = BufReader::new(f);\n///\n///     let mut line = String::new();\n///     let len = reader.read_line(&mut line)?;\n///     println!(\"First line is {} bytes long\", len);\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct BufReader<R> {\n    inner: R,\n    buf: Box<[u8]>,\n    pos: usize,\n    cap: usize,\n}\n\nimpl<R: Read> BufReader<R> {\n    /// Creates a new `BufReader` with a default buffer capacity. The default is currently 8 KB,\n    /// but may change in the future.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufReader;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f = File::open(\"log.txt\")?;\n    ///     let reader = BufReader::new(f);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(inner: R) -> BufReader<R> {\n        BufReader::with_capacity(DEFAULT_BUF_SIZE, inner)\n    }\n\n    /// Creates a new `BufReader` with the specified buffer capacity.\n    ///\n    /// # Examples\n    ///\n    /// Creating a buffer with ten bytes of capacity:\n    ///\n    /// ```no_run\n    /// use std::io::BufReader;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f = File::open(\"log.txt\")?;\n    ///     let reader = BufReader::with_capacity(10, f);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(cap: usize, inner: R) -> BufReader<R> {\n        unsafe {\n            let mut buffer = Vec::with_capacity(cap);\n            buffer.set_len(cap);\n            inner.initializer().initialize(&mut buffer);\n            BufReader {\n                inner,\n                buf: buffer.into_boxed_slice(),\n                pos: 0,\n                cap: 0,\n            }\n        }\n    }\n\n    /// Gets a reference to the underlying reader.\n    ///\n    /// It is inadvisable to directly read from the underlying reader.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufReader;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f1 = File::open(\"log.txt\")?;\n    ///     let reader = BufReader::new(f1);\n    ///\n    ///     let f2 = reader.get_ref();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_ref(&self) -> &R { &self.inner }\n\n    /// Gets a mutable reference to the underlying reader.\n    ///\n    /// It is inadvisable to directly read from the underlying reader.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufReader;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f1 = File::open(\"log.txt\")?;\n    ///     let mut reader = BufReader::new(f1);\n    ///\n    ///     let f2 = reader.get_mut();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut R { &mut self.inner }\n\n    /// Returns a reference to the internally buffered data.\n    ///\n    /// Unlike `fill_buf`, this will not attempt to fill the buffer if it is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// # #![feature(bufreader_buffer)]\n    /// use std::io::{BufReader, BufRead};\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f = File::open(\"log.txt\")?;\n    ///     let mut reader = BufReader::new(f);\n    ///     assert!(reader.buffer().is_empty());\n    ///\n    ///     if reader.fill_buf()?.len() > 0 {\n    ///         assert!(!reader.buffer().is_empty());\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    #[unstable(feature = \"bufreader_buffer\", issue = \"45323\")]\n    pub fn buffer(&self) -> &[u8] {\n        &self.buf[self.pos..self.cap]\n    }\n\n    /// Unwraps this `BufReader`, returning the underlying reader.\n    ///\n    /// Note that any leftover data in the internal buffer is lost.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufReader;\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f1 = File::open(\"log.txt\")?;\n    ///     let reader = BufReader::new(f1);\n    ///\n    ///     let f2 = reader.into_inner();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(self) -> R { self.inner }\n}\n\nimpl<R: Seek> BufReader<R> {\n    /// Seeks relative to the current position. If the new position lies within the buffer,\n    /// the buffer will not be flushed, allowing for more efficient seeks.\n    /// This method does not return the location of the underlying reader, so the caller\n    /// must track this information themselves if it is required.\n    #[unstable(feature = \"bufreader_seek_relative\", issue = \"31100\")]\n    pub fn seek_relative(&mut self, offset: i64) -> io::Result<()> {\n        let pos = self.pos as u64;\n        if offset < 0 {\n            if let Some(new_pos) = pos.checked_sub((-offset) as u64) {\n                self.pos = new_pos as usize;\n                return Ok(())\n            }\n        } else {\n            if let Some(new_pos) = pos.checked_add(offset as u64) {\n                if new_pos <= self.cap as u64 {\n                    self.pos = new_pos as usize;\n                    return Ok(())\n                }\n            }\n        }\n        self.seek(SeekFrom::Current(offset)).map(|_|())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R: Read> Read for BufReader<R> {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        // If we don't have any buffered data and we're doing a massive read\n        // (larger than our internal buffer), bypass our internal buffer\n        // entirely.\n        if self.pos == self.cap && buf.len() >= self.buf.len() {\n            return self.inner.read(buf);\n        }\n        let nread = {\n            let mut rem = self.fill_buf()?;\n            rem.read(buf)?\n        };\n        self.consume(nread);\n        Ok(nread)\n    }\n\n    // we can't skip unconditionally because of the large buffer case in read.\n    unsafe fn initializer(&self) -> Initializer {\n        self.inner.initializer()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R: Read> BufRead for BufReader<R> {\n    fn fill_buf(&mut self) -> io::Result<&[u8]> {\n        // If we've reached the end of our internal buffer then we need to fetch\n        // some more data from the underlying reader.\n        // Branch using `>=` instead of the more correct `==`\n        // to tell the compiler that the pos..cap slice is always valid.\n        if self.pos >= self.cap {\n            debug_assert!(self.pos == self.cap);\n            self.cap = self.inner.read(&mut self.buf)?;\n            self.pos = 0;\n        }\n        Ok(&self.buf[self.pos..self.cap])\n    }\n\n    fn consume(&mut self, amt: usize) {\n        self.pos = cmp::min(self.pos + amt, self.cap);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R> fmt::Debug for BufReader<R> where R: fmt::Debug {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt.debug_struct(\"BufReader\")\n            .field(\"reader\", &self.inner)\n            .field(\"buffer\", &format_args!(\"{}/{}\", self.cap - self.pos, self.buf.len()))\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R: Seek> Seek for BufReader<R> {\n    /// Seek to an offset, in bytes, in the underlying reader.\n    ///\n    /// The position used for seeking with `SeekFrom::Current(_)` is the\n    /// position the underlying reader would be at if the `BufReader` had no\n    /// internal buffer.\n    ///\n    /// Seeking always discards the internal buffer, even if the seek position\n    /// would otherwise fall within it. This guarantees that calling\n    /// `.into_inner()` immediately after a seek yields the underlying reader\n    /// at the same position.\n    ///\n    /// To seek without discarding the internal buffer, use [`Seek::seek_relative`].\n    ///\n    /// See [`std::io::Seek`] for more details.\n    ///\n    /// Note: In the edge case where you're seeking with `SeekFrom::Current(n)`\n    /// where `n` minus the internal buffer length overflows an `i64`, two\n    /// seeks will be performed instead of one. If the second seek returns\n    /// `Err`, the underlying reader will be left at the same position it would\n    /// have if you called `seek` with `SeekFrom::Current(0)`.\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {\n        let result: u64;\n        if let SeekFrom::Current(n) = pos {\n            let remainder = (self.cap - self.pos) as i64;\n            // it should be safe to assume that remainder fits within an i64 as the alternative\n            // means we managed to allocate 8 exbibytes and that's absurd.\n            // But it's not out of the realm of possibility for some weird underlying reader to\n            // support seeking by i64::min_value() so we need to handle underflow when subtracting\n            // remainder.\n            if let Some(offset) = n.checked_sub(remainder) {\n                result = self.inner.seek(SeekFrom::Current(offset))?;\n            } else {\n                // seek backwards by our remainder, and then by the offset\n                self.inner.seek(SeekFrom::Current(-remainder))?;\n                self.pos = self.cap; // empty the buffer\n                result = self.inner.seek(SeekFrom::Current(n))?;\n            }\n        } else {\n            // Seeking with Start/End doesn't care about our buffer length.\n            result = self.inner.seek(pos)?;\n        }\n        self.pos = self.cap; // empty the buffer\n        Ok(result)\n    }\n}\n\n/// Wraps a writer and buffers its output.\n///\n/// It can be excessively inefficient to work directly with something that\n/// implements [`Write`]. For example, every call to\n/// [`write`][`Tcpstream::write`] on [`TcpStream`] results in a system call. A\n/// `BufWriter` keeps an in-memory buffer of data and writes it to an underlying\n/// writer in large, infrequent batches.\n///\n/// `BufWriter` can improve the speed of programs that make *small* and\n/// *repeated* write calls to the same file or network socket.  It does not\n/// help when writing very large amounts at once, or writing just one or a few\n/// times.  It also provides no advantage when writing to a destination that is\n/// in memory, like a `Vec<u8>`.\n///\n/// When the `BufWriter` is dropped, the contents of its buffer will be written\n/// out. However, any errors that happen in the process of flushing the buffer\n/// when the writer is dropped will be ignored. Code that wishes to handle such\n/// errors must manually call [`flush`] before the writer is dropped.\n///\n/// # Examples\n///\n/// Let's write the numbers one through ten to a [`TcpStream`]:\n///\n/// ```no_run\n/// use std::io::prelude::*;\n/// use std::net::TcpStream;\n///\n/// let mut stream = TcpStream::connect(\"127.0.0.1:34254\").unwrap();\n///\n/// for i in 0..10 {\n///     stream.write(&[i+1]).unwrap();\n/// }\n/// ```\n///\n/// Because we're not buffering, we write each one in turn, incurring the\n/// overhead of a system call per byte written. We can fix this with a\n/// `BufWriter`:\n///\n/// ```no_run\n/// use std::io::prelude::*;\n/// use std::io::BufWriter;\n/// use std::net::TcpStream;\n///\n/// let mut stream = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n///\n/// for i in 0..10 {\n///     stream.write(&[i+1]).unwrap();\n/// }\n/// ```\n///\n/// By wrapping the stream with a `BufWriter`, these ten writes are all grouped\n/// together by the buffer, and will all be written out in one system call when\n/// the `stream` is dropped.\n///\n/// [`Write`]: ../../std/io/trait.Write.html\n/// [`Tcpstream::write`]: ../../std/net/struct.TcpStream.html#method.write\n/// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n/// [`flush`]: #method.flush\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct BufWriter<W: Write> {\n    inner: Option<W>,\n    buf: Vec<u8>,\n    // #30888: If the inner writer panics in a call to write, we don't want to\n    // write the buffered data a second time in BufWriter's destructor. This\n    // flag tells the Drop impl if it should skip the flush.\n    panicked: bool,\n}\n\n/// An error returned by `into_inner` which combines an error that\n/// happened while writing out the buffer, and the buffered writer object\n/// which may be used to recover from the condition.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::io::BufWriter;\n/// use std::net::TcpStream;\n///\n/// let mut stream = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n///\n/// // do stuff with the stream\n///\n/// // we want to get our `TcpStream` back, so let's try:\n///\n/// let stream = match stream.into_inner() {\n///     Ok(s) => s,\n///     Err(e) => {\n///         // Here, e is an IntoInnerError\n///         panic!(\"An error occurred\");\n///     }\n/// };\n/// ```\n#[derive(Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoInnerError<W>(W, Error);\n\nimpl<W: Write> BufWriter<W> {\n    /// Creates a new `BufWriter` with a default buffer capacity. The default is currently 8 KB,\n    /// but may change in the future.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut buffer = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(inner: W) -> BufWriter<W> {\n        BufWriter::with_capacity(DEFAULT_BUF_SIZE, inner)\n    }\n\n    /// Creates a new `BufWriter` with the specified buffer capacity.\n    ///\n    /// # Examples\n    ///\n    /// Creating a buffer with a buffer of a hundred bytes.\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let stream = TcpStream::connect(\"127.0.0.1:34254\").unwrap();\n    /// let mut buffer = BufWriter::with_capacity(100, stream);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(cap: usize, inner: W) -> BufWriter<W> {\n        BufWriter {\n            inner: Some(inner),\n            buf: Vec::with_capacity(cap),\n            panicked: false,\n        }\n    }\n\n    fn flush_buf(&mut self) -> io::Result<()> {\n        let mut written = 0;\n        let len = self.buf.len();\n        let mut ret = Ok(());\n        while written < len {\n            self.panicked = true;\n            let r = self.inner.as_mut().unwrap().write(&self.buf[written..]);\n            self.panicked = false;\n\n            match r {\n                Ok(0) => {\n                    ret = Err(Error::new(ErrorKind::WriteZero,\n                                         \"failed to write the buffered data\"));\n                    break;\n                }\n                Ok(n) => written += n,\n                Err(ref e) if e.kind() == io::ErrorKind::Interrupted => {}\n                Err(e) => { ret = Err(e); break }\n\n            }\n        }\n        if written > 0 {\n            self.buf.drain(..written);\n        }\n        ret\n    }\n\n    /// Gets a reference to the underlying writer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut buffer = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    ///\n    /// // we can use reference just like buffer\n    /// let reference = buffer.get_ref();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_ref(&self) -> &W { self.inner.as_ref().unwrap() }\n\n    /// Gets a mutable reference to the underlying writer.\n    ///\n    /// It is inadvisable to directly write to the underlying writer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut buffer = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    ///\n    /// // we can use reference just like buffer\n    /// let reference = buffer.get_mut();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut W { self.inner.as_mut().unwrap() }\n\n    /// Unwraps this `BufWriter`, returning the underlying writer.\n    ///\n    /// The buffer is written out before returning the writer.\n    ///\n    /// # Errors\n    ///\n    /// An `Err` will be returned if an error occurs while flushing the buffer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut buffer = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    ///\n    /// // unwrap the TcpStream and flush the buffer\n    /// let stream = buffer.into_inner().unwrap();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(mut self) -> Result<W, IntoInnerError<BufWriter<W>>> {\n        match self.flush_buf() {\n            Err(e) => Err(IntoInnerError(self, e)),\n            Ok(()) => Ok(self.inner.take().unwrap())\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write> Write for BufWriter<W> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        if self.buf.len() + buf.len() > self.buf.capacity() {\n            self.flush_buf()?;\n        }\n        if buf.len() >= self.buf.capacity() {\n            self.panicked = true;\n            let r = self.inner.as_mut().unwrap().write(buf);\n            self.panicked = false;\n            r\n        } else {\n            Write::write(&mut self.buf, buf)\n        }\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        self.flush_buf().and_then(|()| self.get_mut().flush())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write> fmt::Debug for BufWriter<W> where W: fmt::Debug {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt.debug_struct(\"BufWriter\")\n            .field(\"writer\", &self.inner.as_ref().unwrap())\n            .field(\"buffer\", &format_args!(\"{}/{}\", self.buf.len(), self.buf.capacity()))\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write + Seek> Seek for BufWriter<W> {\n    /// Seek to the offset, in bytes, in the underlying writer.\n    ///\n    /// Seeking always writes out the internal buffer before seeking.\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {\n        self.flush_buf().and_then(|_| self.get_mut().seek(pos))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write> Drop for BufWriter<W> {\n    fn drop(&mut self) {\n        if self.inner.is_some() && !self.panicked {\n            // dtors should not panic, so we ignore a failed flush\n            let _r = self.flush_buf();\n        }\n    }\n}\n\nimpl<W> IntoInnerError<W> {\n    /// Returns the error which caused the call to `into_inner()` to fail.\n    ///\n    /// This error was returned when attempting to write the internal buffer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut stream = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    ///\n    /// // do stuff with the stream\n    ///\n    /// // we want to get our `TcpStream` back, so let's try:\n    ///\n    /// let stream = match stream.into_inner() {\n    ///     Ok(s) => s,\n    ///     Err(e) => {\n    ///         // Here, e is an IntoInnerError, let's log the inner error.\n    ///         //\n    ///         // We'll just 'log' to stdout for this example.\n    ///         println!(\"{}\", e.error());\n    ///\n    ///         panic!(\"An unexpected error occurred.\");\n    ///     }\n    /// };\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn error(&self) -> &Error { &self.1 }\n\n    /// Returns the buffered writer instance which generated the error.\n    ///\n    /// The returned object can be used for error recovery, such as\n    /// re-inspecting the buffer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::io::BufWriter;\n    /// use std::net::TcpStream;\n    ///\n    /// let mut stream = BufWriter::new(TcpStream::connect(\"127.0.0.1:34254\").unwrap());\n    ///\n    /// // do stuff with the stream\n    ///\n    /// // we want to get our `TcpStream` back, so let's try:\n    ///\n    /// let stream = match stream.into_inner() {\n    ///     Ok(s) => s,\n    ///     Err(e) => {\n    ///         // Here, e is an IntoInnerError, let's re-examine the buffer:\n    ///         let buffer = e.into_inner();\n    ///\n    ///         // do stuff to try to recover\n    ///\n    ///         // afterwards, let's just return the stream\n    ///         buffer.into_inner().unwrap()\n    ///     }\n    /// };\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(self) -> W { self.0 }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W> From<IntoInnerError<W>> for Error {\n    fn from(iie: IntoInnerError<W>) -> Error { iie.1 }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Send + fmt::Debug> error::Error for IntoInnerError<W> {\n    fn description(&self) -> &str {\n        error::Error::description(self.error())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W> fmt::Display for IntoInnerError<W> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.error().fmt(f)\n    }\n}\n\n/// Wraps a writer and buffers output to it, flushing whenever a newline\n/// (`0x0a`, `'\\n'`) is detected.\n///\n/// The [`BufWriter`][bufwriter] struct wraps a writer and buffers its output.\n/// But it only does this batched write when it goes out of scope, or when the\n/// internal buffer is full. Sometimes, you'd prefer to write each line as it's\n/// completed, rather than the entire buffer at once. Enter `LineWriter`. It\n/// does exactly that.\n///\n/// Like [`BufWriter`], a `LineWriter`\u2019s buffer will also be flushed when the\n/// `LineWriter` goes out of scope or when its internal buffer is full.\n///\n/// [bufwriter]: struct.BufWriter.html\n///\n/// If there's still a partial line in the buffer when the `LineWriter` is\n/// dropped, it will flush those contents.\n///\n/// # Examples\n///\n/// We can use `LineWriter` to write one line at a time, significantly\n/// reducing the number of actual writes to the file.\n///\n/// ```no_run\n/// use std::fs::{self, File};\n/// use std::io::prelude::*;\n/// use std::io::LineWriter;\n///\n/// fn main() -> std::io::Result<()> {\n///     let road_not_taken = b\"I shall be telling this with a sigh\n/// Somewhere ages and ages hence:\n/// Two roads diverged in a wood, and I -\n/// I took the one less traveled by,\n/// And that has made all the difference.\";\n///\n///     let file = File::create(\"poem.txt\")?;\n///     let mut file = LineWriter::new(file);\n///\n///     file.write_all(b\"I shall be telling this with a sigh\")?;\n///\n///     // No bytes are written until a newline is encountered (or\n///     // the internal buffer is filled).\n///     assert_eq!(fs::read_to_string(\"poem.txt\")?, \"\");\n///     file.write_all(b\"\\n\")?;\n///     assert_eq!(\n///         fs::read_to_string(\"poem.txt\")?,\n///         \"I shall be telling this with a sigh\\n\",\n///     );\n///\n///     // Write the rest of the poem.\n///     file.write_all(b\"Somewhere ages and ages hence:\n/// Two roads diverged in a wood, and I -\n/// I took the one less traveled by,\n/// And that has made all the difference.\")?;\n///\n///     // The last line of the poem doesn't end in a newline, so\n///     // we have to flush or drop the `LineWriter` to finish\n///     // writing.\n///     file.flush()?;\n///\n///     // Confirm the whole poem was written.\n///     assert_eq!(fs::read(\"poem.txt\")?, &road_not_taken[..]);\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct LineWriter<W: Write> {\n    inner: BufWriter<W>,\n    need_flush: bool,\n}\n\nimpl<W: Write> LineWriter<W> {\n    /// Creates a new `LineWriter`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::LineWriter;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let file = File::create(\"poem.txt\")?;\n    ///     let file = LineWriter::new(file);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(inner: W) -> LineWriter<W> {\n        // Lines typically aren't that long, don't use a giant buffer\n        LineWriter::with_capacity(1024, inner)\n    }\n\n    /// Creates a new `LineWriter` with a specified capacity for the internal\n    /// buffer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::LineWriter;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let file = File::create(\"poem.txt\")?;\n    ///     let file = LineWriter::with_capacity(100, file);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(cap: usize, inner: W) -> LineWriter<W> {\n        LineWriter {\n            inner: BufWriter::with_capacity(cap, inner),\n            need_flush: false,\n        }\n    }\n\n    /// Gets a reference to the underlying writer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::LineWriter;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let file = File::create(\"poem.txt\")?;\n    ///     let file = LineWriter::new(file);\n    ///\n    ///     let reference = file.get_ref();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_ref(&self) -> &W { self.inner.get_ref() }\n\n    /// Gets a mutable reference to the underlying writer.\n    ///\n    /// Caution must be taken when calling methods on the mutable reference\n    /// returned as extra writes could corrupt the output stream.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::LineWriter;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let file = File::create(\"poem.txt\")?;\n    ///     let mut file = LineWriter::new(file);\n    ///\n    ///     // we can use reference just like file\n    ///     let reference = file.get_mut();\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut W { self.inner.get_mut() }\n\n    /// Unwraps this `LineWriter`, returning the underlying writer.\n    ///\n    /// The internal buffer is written out before returning the writer.\n    ///\n    /// # Errors\n    ///\n    /// An `Err` will be returned if an error occurs while flushing the buffer.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::LineWriter;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let file = File::create(\"poem.txt\")?;\n    ///\n    ///     let writer: LineWriter<File> = LineWriter::new(file);\n    ///\n    ///     let file: File = writer.into_inner()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {\n        self.inner.into_inner().map_err(|IntoInnerError(buf, e)| {\n            IntoInnerError(LineWriter {\n                inner: buf,\n                need_flush: false,\n            }, e)\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write> Write for LineWriter<W> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        if self.need_flush {\n            self.flush()?;\n        }\n\n        // Find the last newline character in the buffer provided. If found then\n        // we're going to write all the data up to that point and then flush,\n        // otherwise we just write the whole block to the underlying writer.\n        let i = match memchr::memrchr(b'\\n', buf) {\n            Some(i) => i,\n            None => return self.inner.write(buf),\n        };\n\n\n        // Ok, we're going to write a partial amount of the data given first\n        // followed by flushing the newline. After we've successfully written\n        // some data then we *must* report that we wrote that data, so future\n        // errors are ignored. We set our internal `need_flush` flag, though, in\n        // case flushing fails and we need to try it first next time.\n        let n = self.inner.write(&buf[..i + 1])?;\n        self.need_flush = true;\n        if self.flush().is_err() || n != i + 1 {\n            return Ok(n)\n        }\n\n        // At this point we successfully wrote `i + 1` bytes and flushed it out,\n        // meaning that the entire line is now flushed out on the screen. While\n        // we can attempt to finish writing the rest of the data provided.\n        // Remember though that we ignore errors here as we've successfully\n        // written data, so we need to report that.\n        match self.inner.write(&buf[i + 1..]) {\n            Ok(i) => Ok(n + i),\n            Err(_) => Ok(n),\n        }\n    }\n\n    fn flush(&mut self) -> io::Result<()> {\n        self.inner.flush()?;\n        self.need_flush = false;\n        Ok(())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write> fmt::Debug for LineWriter<W> where W: fmt::Debug {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt.debug_struct(\"LineWriter\")\n            .field(\"writer\", &self.inner.inner)\n            .field(\"buffer\",\n                   &format_args!(\"{}/{}\", self.inner.buf.len(), self.inner.buf.capacity()))\n            .finish()\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use io::prelude::*;\n    use io::{self, BufReader, BufWriter, LineWriter, SeekFrom};\n    use sync::atomic::{AtomicUsize, Ordering};\n    use thread;\n    use test;\n\n    /// A dummy reader intended at testing short-reads propagation.\n    pub struct ShortReader {\n        lengths: Vec<usize>,\n    }\n\n    impl Read for ShortReader {\n        fn read(&mut self, _: &mut [u8]) -> io::Result<usize> {\n            if self.lengths.is_empty() {\n                Ok(0)\n            } else {\n                Ok(self.lengths.remove(0))\n            }\n        }\n    }\n\n    #[test]\n    fn test_buffered_reader() {\n        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];\n        let mut reader = BufReader::with_capacity(2, inner);\n\n        let mut buf = [0, 0, 0];\n        let nread = reader.read(&mut buf);\n        assert_eq!(nread.unwrap(), 3);\n        let b: &[_] = &[5, 6, 7];\n        assert_eq!(buf, b);\n\n        let mut buf = [0, 0];\n        let nread = reader.read(&mut buf);\n        assert_eq!(nread.unwrap(), 2);\n        let b: &[_] = &[0, 1];\n        assert_eq!(buf, b);\n\n        let mut buf = [0];\n        let nread = reader.read(&mut buf);\n        assert_eq!(nread.unwrap(), 1);\n        let b: &[_] = &[2];\n        assert_eq!(buf, b);\n\n        let mut buf = [0, 0, 0];\n        let nread = reader.read(&mut buf);\n        assert_eq!(nread.unwrap(), 1);\n        let b: &[_] = &[3, 0, 0];\n        assert_eq!(buf, b);\n\n        let nread = reader.read(&mut buf);\n        assert_eq!(nread.unwrap(), 1);\n        let b: &[_] = &[4, 0, 0];\n        assert_eq!(buf, b);\n\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    fn test_buffered_reader_seek() {\n        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];\n        let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));\n\n        assert_eq!(reader.seek(SeekFrom::Start(3)).ok(), Some(3));\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));\n        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(3));\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));\n        assert_eq!(reader.seek(SeekFrom::Current(1)).ok(), Some(4));\n        assert_eq!(reader.fill_buf().ok(), Some(&[1, 2][..]));\n        reader.consume(1);\n        assert_eq!(reader.seek(SeekFrom::Current(-2)).ok(), Some(3));\n    }\n\n    #[test]\n    fn test_buffered_reader_seek_relative() {\n        let inner: &[u8] = &[5, 6, 7, 0, 1, 2, 3, 4];\n        let mut reader = BufReader::with_capacity(2, io::Cursor::new(inner));\n\n        assert!(reader.seek_relative(3).is_ok());\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));\n        assert!(reader.seek_relative(0).is_ok());\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));\n        assert!(reader.seek_relative(1).is_ok());\n        assert_eq!(reader.fill_buf().ok(), Some(&[1][..]));\n        assert!(reader.seek_relative(-1).is_ok());\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1][..]));\n        assert!(reader.seek_relative(2).is_ok());\n        assert_eq!(reader.fill_buf().ok(), Some(&[2, 3][..]));\n    }\n\n    #[test]\n    fn test_buffered_reader_seek_underflow() {\n        // gimmick reader that yields its position modulo 256 for each byte\n        struct PositionReader {\n            pos: u64\n        }\n        impl Read for PositionReader {\n            fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n                let len = buf.len();\n                for x in buf {\n                    *x = self.pos as u8;\n                    self.pos = self.pos.wrapping_add(1);\n                }\n                Ok(len)\n            }\n        }\n        impl Seek for PositionReader {\n            fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {\n                match pos {\n                    SeekFrom::Start(n) => {\n                        self.pos = n;\n                    }\n                    SeekFrom::Current(n) => {\n                        self.pos = self.pos.wrapping_add(n as u64);\n                    }\n                    SeekFrom::End(n) => {\n                        self.pos = u64::max_value().wrapping_add(n as u64);\n                    }\n                }\n                Ok(self.pos)\n            }\n        }\n\n        let mut reader = BufReader::with_capacity(5, PositionReader { pos: 0 });\n        assert_eq!(reader.fill_buf().ok(), Some(&[0, 1, 2, 3, 4][..]));\n        assert_eq!(reader.seek(SeekFrom::End(-5)).ok(), Some(u64::max_value()-5));\n        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));\n        // the following seek will require two underlying seeks\n        let expected = 9223372036854775802;\n        assert_eq!(reader.seek(SeekFrom::Current(i64::min_value())).ok(), Some(expected));\n        assert_eq!(reader.fill_buf().ok().map(|s| s.len()), Some(5));\n        // seeking to 0 should empty the buffer.\n        assert_eq!(reader.seek(SeekFrom::Current(0)).ok(), Some(expected));\n        assert_eq!(reader.get_ref().pos, expected);\n    }\n\n    #[test]\n    fn test_buffered_writer() {\n        let inner = Vec::new();\n        let mut writer = BufWriter::with_capacity(2, inner);\n\n        writer.write(&[0, 1]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1]);\n\n        writer.write(&[2]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1]);\n\n        writer.write(&[3]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1]);\n\n        writer.flush().unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);\n\n        writer.write(&[4]).unwrap();\n        writer.write(&[5]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);\n\n        writer.write(&[6]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);\n\n        writer.write(&[7, 8]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);\n\n        writer.write(&[9, 10, 11]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);\n\n        writer.flush().unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);\n    }\n\n    #[test]\n    fn test_buffered_writer_inner_flushes() {\n        let mut w = BufWriter::with_capacity(3, Vec::new());\n        w.write(&[0, 1]).unwrap();\n        assert_eq!(*w.get_ref(), []);\n        let w = w.into_inner().unwrap();\n        assert_eq!(w, [0, 1]);\n    }\n\n    #[test]\n    fn test_buffered_writer_seek() {\n        let mut w = BufWriter::with_capacity(3, io::Cursor::new(Vec::new()));\n        w.write_all(&[0, 1, 2, 3, 4, 5]).unwrap();\n        w.write_all(&[6, 7]).unwrap();\n        assert_eq!(w.seek(SeekFrom::Current(0)).ok(), Some(8));\n        assert_eq!(&w.get_ref().get_ref()[..], &[0, 1, 2, 3, 4, 5, 6, 7][..]);\n        assert_eq!(w.seek(SeekFrom::Start(2)).ok(), Some(2));\n        w.write_all(&[8, 9]).unwrap();\n        assert_eq!(&w.into_inner().unwrap().into_inner()[..], &[0, 1, 8, 9, 4, 5, 6, 7]);\n    }\n\n    #[test]\n    fn test_read_until() {\n        let inner: &[u8] = &[0, 1, 2, 1, 0];\n        let mut reader = BufReader::with_capacity(2, inner);\n        let mut v = Vec::new();\n        reader.read_until(0, &mut v).unwrap();\n        assert_eq!(v, [0]);\n        v.truncate(0);\n        reader.read_until(2, &mut v).unwrap();\n        assert_eq!(v, [1, 2]);\n        v.truncate(0);\n        reader.read_until(1, &mut v).unwrap();\n        assert_eq!(v, [1]);\n        v.truncate(0);\n        reader.read_until(8, &mut v).unwrap();\n        assert_eq!(v, [0]);\n        v.truncate(0);\n        reader.read_until(9, &mut v).unwrap();\n        assert_eq!(v, []);\n    }\n\n    #[test]\n    fn test_line_buffer_fail_flush() {\n        // Issue #32085\n        struct FailFlushWriter<'a>(&'a mut Vec<u8>);\n\n        impl<'a> Write for FailFlushWriter<'a> {\n            fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n                self.0.extend_from_slice(buf);\n                Ok(buf.len())\n            }\n            fn flush(&mut self) -> io::Result<()> {\n                Err(io::Error::new(io::ErrorKind::Other, \"flush failed\"))\n            }\n        }\n\n        let mut buf = Vec::new();\n        {\n            let mut writer = LineWriter::new(FailFlushWriter(&mut buf));\n            let to_write = b\"abc\\ndef\";\n            if let Ok(written) = writer.write(to_write) {\n                assert!(written < to_write.len(), \"didn't flush on new line\");\n                // PASS\n                return;\n            }\n        }\n        assert!(buf.is_empty(), \"write returned an error but wrote data\");\n    }\n\n    #[test]\n    fn test_line_buffer() {\n        let mut writer = LineWriter::new(Vec::new());\n        writer.write(&[0]).unwrap();\n        assert_eq!(*writer.get_ref(), []);\n        writer.write(&[1]).unwrap();\n        assert_eq!(*writer.get_ref(), []);\n        writer.flush().unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1]);\n        writer.write(&[0, b'\\n', 1, b'\\n', 2]).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\\n', 1, b'\\n']);\n        writer.flush().unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\\n', 1, b'\\n', 2]);\n        writer.write(&[3, b'\\n']).unwrap();\n        assert_eq!(*writer.get_ref(), [0, 1, 0, b'\\n', 1, b'\\n', 2, 3, b'\\n']);\n    }\n\n    #[test]\n    fn test_read_line() {\n        let in_buf: &[u8] = b\"a\\nb\\nc\";\n        let mut reader = BufReader::with_capacity(2, in_buf);\n        let mut s = String::new();\n        reader.read_line(&mut s).unwrap();\n        assert_eq!(s, \"a\\n\");\n        s.truncate(0);\n        reader.read_line(&mut s).unwrap();\n        assert_eq!(s, \"b\\n\");\n        s.truncate(0);\n        reader.read_line(&mut s).unwrap();\n        assert_eq!(s, \"c\");\n        s.truncate(0);\n        reader.read_line(&mut s).unwrap();\n        assert_eq!(s, \"\");\n    }\n\n    #[test]\n    fn test_lines() {\n        let in_buf: &[u8] = b\"a\\nb\\nc\";\n        let reader = BufReader::with_capacity(2, in_buf);\n        let mut it = reader.lines();\n        assert_eq!(it.next().unwrap().unwrap(), \"a\".to_string());\n        assert_eq!(it.next().unwrap().unwrap(), \"b\".to_string());\n        assert_eq!(it.next().unwrap().unwrap(), \"c\".to_string());\n        assert!(it.next().is_none());\n    }\n\n    #[test]\n    fn test_short_reads() {\n        let inner = ShortReader{lengths: vec![0, 1, 2, 0, 1, 0]};\n        let mut reader = BufReader::new(inner);\n        let mut buf = [0, 0];\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.read(&mut buf).unwrap(), 2);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    #[should_panic]\n    fn dont_panic_in_drop_on_panicked_flush() {\n        struct FailFlushWriter;\n\n        impl Write for FailFlushWriter {\n            fn write(&mut self, buf: &[u8]) -> io::Result<usize> { Ok(buf.len()) }\n            fn flush(&mut self) -> io::Result<()> {\n                Err(io::Error::last_os_error())\n            }\n        }\n\n        let writer = FailFlushWriter;\n        let _writer = BufWriter::new(writer);\n\n        // If writer panics *again* due to the flush error then the process will\n        // abort.\n        panic!();\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn panic_in_write_doesnt_flush_in_drop() {\n        static WRITES: AtomicUsize = AtomicUsize::new(0);\n\n        struct PanicWriter;\n\n        impl Write for PanicWriter {\n            fn write(&mut self, _: &[u8]) -> io::Result<usize> {\n                WRITES.fetch_add(1, Ordering::SeqCst);\n                panic!();\n            }\n            fn flush(&mut self) -> io::Result<()> { Ok(()) }\n        }\n\n        thread::spawn(|| {\n            let mut writer = BufWriter::new(PanicWriter);\n            let _ = writer.write(b\"hello world\");\n            let _ = writer.flush();\n        }).join().unwrap_err();\n\n        assert_eq!(WRITES.load(Ordering::SeqCst), 1);\n    }\n\n    #[bench]\n    fn bench_buffered_reader(b: &mut test::Bencher) {\n        b.iter(|| {\n            BufReader::new(io::empty())\n        });\n    }\n\n    #[bench]\n    fn bench_buffered_writer(b: &mut test::Bencher) {\n        b.iter(|| {\n            BufWriter::new(io::sink())\n        });\n    }\n\n    struct AcceptOneThenFail {\n        written: bool,\n        flushed: bool,\n    }\n\n    impl Write for AcceptOneThenFail {\n        fn write(&mut self, data: &[u8]) -> io::Result<usize> {\n            if !self.written {\n                assert_eq!(data, b\"a\\nb\\n\");\n                self.written = true;\n                Ok(data.len())\n            } else {\n                Err(io::Error::new(io::ErrorKind::NotFound, \"test\"))\n            }\n        }\n\n        fn flush(&mut self) -> io::Result<()> {\n            assert!(self.written);\n            assert!(!self.flushed);\n            self.flushed = true;\n            Err(io::Error::new(io::ErrorKind::Other, \"test\"))\n        }\n    }\n\n    #[test]\n    fn erroneous_flush_retried() {\n        let a = AcceptOneThenFail {\n            written: false,\n            flushed: false,\n        };\n\n        let mut l = LineWriter::new(a);\n        assert_eq!(l.write(b\"a\\nb\\na\").unwrap(), 4);\n        assert!(l.get_ref().written);\n        assert!(l.get_ref().flushed);\n        l.get_mut().flushed = false;\n\n        assert_eq!(l.write(b\"a\").unwrap_err().kind(), io::ErrorKind::Other)\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cell::Cell;\nuse ptr;\nuse sync::Arc;\nuse sys_common;\nuse sys_common::mutex::Mutex;\n\npub struct Lazy<T> {\n    // We never call `lock.init()`, so it is UB to attempt to acquire this mutex reentrantly!\n    lock: Mutex,\n    ptr: Cell<*mut Arc<T>>,\n}\n\n#[inline]\nconst fn done<T>() -> *mut Arc<T> { 1_usize as *mut _ }\n\nunsafe impl<T> Sync for Lazy<T> {}\n\nimpl<T> Lazy<T> {\n    pub const fn new() -> Lazy<T> {\n        Lazy {\n            lock: Mutex::new(),\n            ptr: Cell::new(ptr::null_mut()),\n        }\n    }\n}\n\nimpl<T: Send + Sync + 'static> Lazy<T> {\n    /// Safety: `init` must not call `get` on the variable that is being\n    /// initialized.\n    pub unsafe fn get(&'static self, init: fn() -> Arc<T>) -> Option<Arc<T>> {\n        let _guard = self.lock.lock();\n        let ptr = self.ptr.get();\n        if ptr.is_null() {\n            Some(self.init(init))\n        } else if ptr == done() {\n            None\n        } else {\n            Some((*ptr).clone())\n        }\n    }\n\n    // Must only be called with `lock` held\n    unsafe fn init(&'static self, init: fn() -> Arc<T>) -> Arc<T> {\n        // If we successfully register an at exit handler, then we cache the\n        // `Arc` allocation in our own internal box (it will get deallocated by\n        // the at exit handler). Otherwise we just return the freshly allocated\n        // `Arc`.\n        let registered = sys_common::at_exit(move || {\n            let ptr = {\n                let _guard = self.lock.lock();\n                self.ptr.replace(done())\n            };\n            drop(Box::from_raw(ptr))\n        });\n        // This could reentrantly call `init` again, which is a problem\n        // because our `lock` allows reentrancy!\n        // That's why `get` is unsafe and requires the caller to ensure no reentrancy happens.\n        let ret = init();\n        if registered.is_ok() {\n            self.ptr.set(Box::into_raw(Box::new(ret.clone())));\n        }\n        ret\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cmp;\nuse io::{self, SeekFrom, Read, Initializer, Write, Seek, BufRead, Error, ErrorKind};\nuse fmt;\nuse mem;\n\n// =============================================================================\n// Forwarding implementations\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, R: Read + ?Sized> Read for &'a mut R {\n    #[inline]\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        (**self).read(buf)\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        (**self).initializer()\n    }\n\n    #[inline]\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {\n        (**self).read_to_end(buf)\n    }\n\n    #[inline]\n    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {\n        (**self).read_to_string(buf)\n    }\n\n    #[inline]\n    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {\n        (**self).read_exact(buf)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, W: Write + ?Sized> Write for &'a mut W {\n    #[inline]\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }\n\n    #[inline]\n    fn flush(&mut self) -> io::Result<()> { (**self).flush() }\n\n    #[inline]\n    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {\n        (**self).write_all(buf)\n    }\n\n    #[inline]\n    fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {\n        (**self).write_fmt(fmt)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, S: Seek + ?Sized> Seek for &'a mut S {\n    #[inline]\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, B: BufRead + ?Sized> BufRead for &'a mut B {\n    #[inline]\n    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }\n\n    #[inline]\n    fn consume(&mut self, amt: usize) { (**self).consume(amt) }\n\n    #[inline]\n    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {\n        (**self).read_until(byte, buf)\n    }\n\n    #[inline]\n    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {\n        (**self).read_line(buf)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<R: Read + ?Sized> Read for Box<R> {\n    #[inline]\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        (**self).read(buf)\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        (**self).initializer()\n    }\n\n    #[inline]\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {\n        (**self).read_to_end(buf)\n    }\n\n    #[inline]\n    fn read_to_string(&mut self, buf: &mut String) -> io::Result<usize> {\n        (**self).read_to_string(buf)\n    }\n\n    #[inline]\n    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {\n        (**self).read_exact(buf)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<W: Write + ?Sized> Write for Box<W> {\n    #[inline]\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> { (**self).write(buf) }\n\n    #[inline]\n    fn flush(&mut self) -> io::Result<()> { (**self).flush() }\n\n    #[inline]\n    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {\n        (**self).write_all(buf)\n    }\n\n    #[inline]\n    fn write_fmt(&mut self, fmt: fmt::Arguments) -> io::Result<()> {\n        (**self).write_fmt(fmt)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<S: Seek + ?Sized> Seek for Box<S> {\n    #[inline]\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> { (**self).seek(pos) }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<B: BufRead + ?Sized> BufRead for Box<B> {\n    #[inline]\n    fn fill_buf(&mut self) -> io::Result<&[u8]> { (**self).fill_buf() }\n\n    #[inline]\n    fn consume(&mut self, amt: usize) { (**self).consume(amt) }\n\n    #[inline]\n    fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> io::Result<usize> {\n        (**self).read_until(byte, buf)\n    }\n\n    #[inline]\n    fn read_line(&mut self, buf: &mut String) -> io::Result<usize> {\n        (**self).read_line(buf)\n    }\n}\n\n// =============================================================================\n// In-memory buffer implementations\n\n/// Read is implemented for `&[u8]` by copying from the slice.\n///\n/// Note that reading updates the slice to point to the yet unread part.\n/// The slice will be empty when EOF is reached.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Read for &'a [u8] {\n    #[inline]\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        let amt = cmp::min(buf.len(), self.len());\n        let (a, b) = self.split_at(amt);\n\n        // First check if the amount of bytes we want to read is small:\n        // `copy_from_slice` will generally expand to a call to `memcpy`, and\n        // for a single byte the overhead is significant.\n        if amt == 1 {\n            buf[0] = a[0];\n        } else {\n            buf[..amt].copy_from_slice(a);\n        }\n\n        *self = b;\n        Ok(amt)\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n\n    #[inline]\n    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {\n        if buf.len() > self.len() {\n            return Err(Error::new(ErrorKind::UnexpectedEof,\n                                  \"failed to fill whole buffer\"));\n        }\n        let (a, b) = self.split_at(buf.len());\n\n        // First check if the amount of bytes we want to read is small:\n        // `copy_from_slice` will generally expand to a call to `memcpy`, and\n        // for a single byte the overhead is significant.\n        if buf.len() == 1 {\n            buf[0] = a[0];\n        } else {\n            buf.copy_from_slice(a);\n        }\n\n        *self = b;\n        Ok(())\n    }\n\n    #[inline]\n    fn read_to_end(&mut self, buf: &mut Vec<u8>) -> io::Result<usize> {\n        buf.extend_from_slice(*self);\n        let len = self.len();\n        *self = &self[len..];\n        Ok(len)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> BufRead for &'a [u8] {\n    #[inline]\n    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }\n\n    #[inline]\n    fn consume(&mut self, amt: usize) { *self = &self[amt..]; }\n}\n\n/// Write is implemented for `&mut [u8]` by copying into the slice, overwriting\n/// its data.\n///\n/// Note that writing updates the slice to point to the yet unwritten part.\n/// The slice will be empty when it has been completely overwritten.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Write for &'a mut [u8] {\n    #[inline]\n    fn write(&mut self, data: &[u8]) -> io::Result<usize> {\n        let amt = cmp::min(data.len(), self.len());\n        let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);\n        a.copy_from_slice(&data[..amt]);\n        *self = b;\n        Ok(amt)\n    }\n\n    #[inline]\n    fn write_all(&mut self, data: &[u8]) -> io::Result<()> {\n        if self.write(data)? == data.len() {\n            Ok(())\n        } else {\n            Err(Error::new(ErrorKind::WriteZero, \"failed to write whole buffer\"))\n        }\n    }\n\n    #[inline]\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n/// Write is implemented for `Vec<u8>` by appending to the vector.\n/// The vector will grow as needed.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Write for Vec<u8> {\n    #[inline]\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.extend_from_slice(buf);\n        Ok(buf.len())\n    }\n\n    #[inline]\n    fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {\n        self.extend_from_slice(buf);\n        Ok(())\n    }\n\n    #[inline]\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n#[cfg(test)]\nmod tests {\n    use io::prelude::*;\n    use test;\n\n    #[bench]\n    fn bench_read_slice(b: &mut test::Bencher) {\n        let buf = [5; 1024];\n        let mut dst = [0; 128];\n\n        b.iter(|| {\n            let mut rd = &buf[..];\n            for _ in 0..8 {\n                let _ = rd.read(&mut dst);\n                test::black_box(&dst);\n            }\n        })\n    }\n\n    #[bench]\n    fn bench_write_slice(b: &mut test::Bencher) {\n        let mut buf = [0; 1024];\n        let src = [5; 128];\n\n        b.iter(|| {\n            let mut wr = &mut buf[..];\n            for _ in 0..8 {\n                let _ = wr.write_all(&src);\n                test::black_box(&wr);\n            }\n        })\n    }\n\n    #[bench]\n    fn bench_read_vec(b: &mut test::Bencher) {\n        let buf = vec![5; 1024];\n        let mut dst = [0; 128];\n\n        b.iter(|| {\n            let mut rd = &buf[..];\n            for _ in 0..8 {\n                let _ = rd.read(&mut dst);\n                test::black_box(&dst);\n            }\n        })\n    }\n\n    #[bench]\n    fn bench_write_vec(b: &mut test::Bencher) {\n        let mut buf = Vec::with_capacity(1024);\n        let src = [5; 128];\n\n        b.iter(|| {\n            let mut wr = &mut buf[..];\n            for _ in 0..8 {\n                let _ = wr.write_all(&src);\n                test::black_box(&wr);\n            }\n        })\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse io::prelude::*;\n\nuse core::convert::TryInto;\nuse cmp;\nuse io::{self, Initializer, SeekFrom, Error, ErrorKind};\n\n/// A `Cursor` wraps an in-memory buffer and provides it with a\n/// [`Seek`] implementation.\n///\n/// `Cursor`s are used with in-memory buffers, anything implementing\n/// `AsRef<[u8]>`, to allow them to implement [`Read`] and/or [`Write`],\n/// allowing these buffers to be used anywhere you might use a reader or writer\n/// that does actual I/O.\n///\n/// The standard library implements some I/O traits on various types which\n/// are commonly used as a buffer, like `Cursor<`[`Vec`]`<u8>>` and\n/// `Cursor<`[`&[u8]`][bytes]`>`.\n///\n/// # Examples\n///\n/// We may want to write bytes to a [`File`] in our production\n/// code, but use an in-memory buffer in our tests. We can do this with\n/// `Cursor`:\n///\n/// [`Seek`]: trait.Seek.html\n/// [`Read`]: ../../std/io/trait.Read.html\n/// [`Write`]: ../../std/io/trait.Write.html\n/// [`Vec`]: ../../std/vec/struct.Vec.html\n/// [bytes]: ../../std/primitive.slice.html\n/// [`File`]: ../fs/struct.File.html\n///\n/// ```no_run\n/// use std::io::prelude::*;\n/// use std::io::{self, SeekFrom};\n/// use std::fs::File;\n///\n/// // a library function we've written\n/// fn write_ten_bytes_at_end<W: Write + Seek>(writer: &mut W) -> io::Result<()> {\n///     writer.seek(SeekFrom::End(-10))?;\n///\n///     for i in 0..10 {\n///         writer.write(&[i])?;\n///     }\n///\n///     // all went well\n///     Ok(())\n/// }\n///\n/// # fn foo() -> io::Result<()> {\n/// // Here's some code that uses this library function.\n/// //\n/// // We might want to use a BufReader here for efficiency, but let's\n/// // keep this example focused.\n/// let mut file = File::create(\"foo.txt\")?;\n///\n/// write_ten_bytes_at_end(&mut file)?;\n/// # Ok(())\n/// # }\n///\n/// // now let's write a test\n/// #[test]\n/// fn test_writes_bytes() {\n///     // setting up a real File is much slower than an in-memory buffer,\n///     // let's use a cursor instead\n///     use std::io::Cursor;\n///     let mut buff = Cursor::new(vec![0; 15]);\n///\n///     write_ten_bytes_at_end(&mut buff).unwrap();\n///\n///     assert_eq!(&buff.get_ref()[5..15], &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone, Debug)]\npub struct Cursor<T> {\n    inner: T,\n    pos: u64,\n}\n\nimpl<T> Cursor<T> {\n    /// Creates a new cursor wrapping the provided underlying in-memory buffer.\n    ///\n    /// Cursor initial position is `0` even if underlying buffer (e.g. `Vec`)\n    /// is not empty. So writing to cursor starts with overwriting `Vec`\n    /// content, not with appending to it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    ///\n    /// let buff = Cursor::new(Vec::new());\n    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}\n    /// # force_inference(&buff);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(inner: T) -> Cursor<T> {\n        Cursor { pos: 0, inner: inner }\n    }\n\n    /// Consumes this cursor, returning the underlying value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    ///\n    /// let buff = Cursor::new(Vec::new());\n    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}\n    /// # force_inference(&buff);\n    ///\n    /// let vec = buff.into_inner();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_inner(self) -> T { self.inner }\n\n    /// Gets a reference to the underlying value in this cursor.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    ///\n    /// let buff = Cursor::new(Vec::new());\n    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}\n    /// # force_inference(&buff);\n    ///\n    /// let reference = buff.get_ref();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_ref(&self) -> &T { &self.inner }\n\n    /// Gets a mutable reference to the underlying value in this cursor.\n    ///\n    /// Care should be taken to avoid modifying the internal I/O state of the\n    /// underlying value as it may corrupt this cursor's position.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    ///\n    /// let mut buff = Cursor::new(Vec::new());\n    /// # fn force_inference(_: &Cursor<Vec<u8>>) {}\n    /// # force_inference(&buff);\n    ///\n    /// let reference = buff.get_mut();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut T { &mut self.inner }\n\n    /// Returns the current position of this cursor.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    /// use std::io::prelude::*;\n    /// use std::io::SeekFrom;\n    ///\n    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);\n    ///\n    /// assert_eq!(buff.position(), 0);\n    ///\n    /// buff.seek(SeekFrom::Current(2)).unwrap();\n    /// assert_eq!(buff.position(), 2);\n    ///\n    /// buff.seek(SeekFrom::Current(-1)).unwrap();\n    /// assert_eq!(buff.position(), 1);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn position(&self) -> u64 { self.pos }\n\n    /// Sets the position of this cursor.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::io::Cursor;\n    ///\n    /// let mut buff = Cursor::new(vec![1, 2, 3, 4, 5]);\n    ///\n    /// assert_eq!(buff.position(), 0);\n    ///\n    /// buff.set_position(2);\n    /// assert_eq!(buff.position(), 2);\n    ///\n    /// buff.set_position(4);\n    /// assert_eq!(buff.position(), 4);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set_position(&mut self, pos: u64) { self.pos = pos; }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> io::Seek for Cursor<T> where T: AsRef<[u8]> {\n    fn seek(&mut self, style: SeekFrom) -> io::Result<u64> {\n        let (base_pos, offset) = match style {\n            SeekFrom::Start(n) => { self.pos = n; return Ok(n); }\n            SeekFrom::End(n) => (self.inner.as_ref().len() as u64, n),\n            SeekFrom::Current(n) => (self.pos, n),\n        };\n        let new_pos = if offset >= 0 {\n            base_pos.checked_add(offset as u64)\n        } else {\n            base_pos.checked_sub((offset.wrapping_neg()) as u64)\n        };\n        match new_pos {\n            Some(n) => {self.pos = n; Ok(self.pos)}\n            None => Err(Error::new(ErrorKind::InvalidInput,\n                           \"invalid seek to a negative or overflowing position\"))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Read for Cursor<T> where T: AsRef<[u8]> {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        let n = Read::read(&mut self.fill_buf()?, buf)?;\n        self.pos += n as u64;\n        Ok(n)\n    }\n\n    fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {\n        let n = buf.len();\n        Read::read_exact(&mut self.fill_buf()?, buf)?;\n        self.pos += n as u64;\n        Ok(())\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> BufRead for Cursor<T> where T: AsRef<[u8]> {\n    fn fill_buf(&mut self) -> io::Result<&[u8]> {\n        let amt = cmp::min(self.pos, self.inner.as_ref().len() as u64);\n        Ok(&self.inner.as_ref()[(amt as usize)..])\n    }\n    fn consume(&mut self, amt: usize) { self.pos += amt as u64; }\n}\n\n// Non-resizing write implementation\nfn slice_write(pos_mut: &mut u64, slice: &mut [u8], buf: &[u8]) -> io::Result<usize> {\n    let pos = cmp::min(*pos_mut, slice.len() as u64);\n    let amt = (&mut slice[(pos as usize)..]).write(buf)?;\n    *pos_mut += amt as u64;\n    Ok(amt)\n}\n\n// Resizing write implementation\nfn vec_write(pos_mut: &mut u64, vec: &mut Vec<u8>, buf: &[u8]) -> io::Result<usize> {\n    let pos: usize = (*pos_mut).try_into().map_err(|_| {\n        Error::new(ErrorKind::InvalidInput,\n                    \"cursor position exceeds maximum possible vector length\")\n    })?;\n    // Make sure the internal buffer is as least as big as where we\n    // currently are\n    let len = vec.len();\n    if len < pos {\n        // use `resize` so that the zero filling is as efficient as possible\n        vec.resize(pos, 0);\n    }\n    // Figure out what bytes will be used to overwrite what's currently\n    // there (left), and what will be appended on the end (right)\n    {\n        let space = vec.len() - pos;\n        let (left, right) = buf.split_at(cmp::min(space, buf.len()));\n        vec[pos..pos + left.len()].copy_from_slice(left);\n        vec.extend_from_slice(right);\n    }\n\n    // Bump us forward\n    *pos_mut = (pos + buf.len()) as u64;\n    Ok(buf.len())\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Write for Cursor<&'a mut [u8]> {\n    #[inline]\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        slice_write(&mut self.pos, self.inner, buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n#[stable(feature = \"cursor_mut_vec\", since = \"1.25.0\")]\nimpl<'a> Write for Cursor<&'a mut Vec<u8>> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        vec_write(&mut self.pos, self.inner, buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Write for Cursor<Vec<u8>> {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        vec_write(&mut self.pos, &mut self.inner, buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n#[stable(feature = \"cursor_box_slice\", since = \"1.5.0\")]\nimpl Write for Cursor<Box<[u8]>> {\n    #[inline]\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        slice_write(&mut self.pos, &mut self.inner, buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { Ok(()) }\n}\n\n#[cfg(test)]\nmod tests {\n    use io::prelude::*;\n    use io::{Cursor, SeekFrom};\n\n    #[test]\n    fn test_vec_writer() {\n        let mut writer = Vec::new();\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];\n        assert_eq!(writer, b);\n    }\n\n    #[test]\n    fn test_mem_writer() {\n        let mut writer = Cursor::new(Vec::new());\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];\n        assert_eq!(&writer.get_ref()[..], b);\n    }\n\n    #[test]\n    fn test_mem_mut_writer() {\n        let mut vec = Vec::new();\n        let mut writer = Cursor::new(&mut vec);\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];\n        assert_eq!(&writer.get_ref()[..], b);\n    }\n\n    #[test]\n    fn test_box_slice_writer() {\n        let mut writer = Cursor::new(vec![0u8; 9].into_boxed_slice());\n        assert_eq!(writer.position(), 0);\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.position(), 1);\n        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n        assert_eq!(writer.position(), 8);\n        assert_eq!(writer.write(&[]).unwrap(), 0);\n        assert_eq!(writer.position(), 8);\n\n        assert_eq!(writer.write(&[8, 9]).unwrap(), 1);\n        assert_eq!(writer.write(&[10]).unwrap(), 0);\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];\n        assert_eq!(&**writer.get_ref(), b);\n    }\n\n    #[test]\n    fn test_buf_writer() {\n        let mut buf = [0 as u8; 9];\n        {\n            let mut writer = Cursor::new(&mut buf[..]);\n            assert_eq!(writer.position(), 0);\n            assert_eq!(writer.write(&[0]).unwrap(), 1);\n            assert_eq!(writer.position(), 1);\n            assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n            assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n            assert_eq!(writer.position(), 8);\n            assert_eq!(writer.write(&[]).unwrap(), 0);\n            assert_eq!(writer.position(), 8);\n\n            assert_eq!(writer.write(&[8, 9]).unwrap(), 1);\n            assert_eq!(writer.write(&[10]).unwrap(), 0);\n        }\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8];\n        assert_eq!(buf, b);\n    }\n\n    #[test]\n    fn test_buf_writer_seek() {\n        let mut buf = [0 as u8; 8];\n        {\n            let mut writer = Cursor::new(&mut buf[..]);\n            assert_eq!(writer.position(), 0);\n            assert_eq!(writer.write(&[1]).unwrap(), 1);\n            assert_eq!(writer.position(), 1);\n\n            assert_eq!(writer.seek(SeekFrom::Start(2)).unwrap(), 2);\n            assert_eq!(writer.position(), 2);\n            assert_eq!(writer.write(&[2]).unwrap(), 1);\n            assert_eq!(writer.position(), 3);\n\n            assert_eq!(writer.seek(SeekFrom::Current(-2)).unwrap(), 1);\n            assert_eq!(writer.position(), 1);\n            assert_eq!(writer.write(&[3]).unwrap(), 1);\n            assert_eq!(writer.position(), 2);\n\n            assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);\n            assert_eq!(writer.position(), 7);\n            assert_eq!(writer.write(&[4]).unwrap(), 1);\n            assert_eq!(writer.position(), 8);\n\n        }\n        let b: &[_] = &[1, 3, 2, 0, 0, 0, 0, 4];\n        assert_eq!(buf, b);\n    }\n\n    #[test]\n    fn test_buf_writer_error() {\n        let mut buf = [0 as u8; 2];\n        let mut writer = Cursor::new(&mut buf[..]);\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.write(&[0, 0]).unwrap(), 1);\n        assert_eq!(writer.write(&[0, 0]).unwrap(), 0);\n    }\n\n    #[test]\n    fn test_mem_reader() {\n        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);\n        let mut buf = [];\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.position(), 0);\n        let mut buf = [0];\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.position(), 1);\n        let b: &[_] = &[0];\n        assert_eq!(buf, b);\n        let mut buf = [0; 4];\n        assert_eq!(reader.read(&mut buf).unwrap(), 4);\n        assert_eq!(reader.position(), 5);\n        let b: &[_] = &[1, 2, 3, 4];\n        assert_eq!(buf, b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 3);\n        let b: &[_] = &[5, 6, 7];\n        assert_eq!(&buf[..3], b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    fn test_boxed_slice_reader() {\n        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7].into_boxed_slice());\n        let mut buf = [];\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.position(), 0);\n        let mut buf = [0];\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.position(), 1);\n        let b: &[_] = &[0];\n        assert_eq!(buf, b);\n        let mut buf = [0; 4];\n        assert_eq!(reader.read(&mut buf).unwrap(), 4);\n        assert_eq!(reader.position(), 5);\n        let b: &[_] = &[1, 2, 3, 4];\n        assert_eq!(buf, b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 3);\n        let b: &[_] = &[5, 6, 7];\n        assert_eq!(&buf[..3], b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    fn read_to_end() {\n        let mut reader = Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7]);\n        let mut v = Vec::new();\n        reader.read_to_end(&mut v).unwrap();\n        assert_eq!(v, [0, 1, 2, 3, 4, 5, 6, 7]);\n    }\n\n    #[test]\n    fn test_slice_reader() {\n        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];\n        let reader = &mut &in_buf[..];\n        let mut buf = [];\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        let mut buf = [0];\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.len(), 7);\n        let b: &[_] = &[0];\n        assert_eq!(&buf[..], b);\n        let mut buf = [0; 4];\n        assert_eq!(reader.read(&mut buf).unwrap(), 4);\n        assert_eq!(reader.len(), 3);\n        let b: &[_] = &[1, 2, 3, 4];\n        assert_eq!(&buf[..], b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 3);\n        let b: &[_] = &[5, 6, 7];\n        assert_eq!(&buf[..3], b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    fn test_read_exact() {\n        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];\n        let reader = &mut &in_buf[..];\n        let mut buf = [];\n        assert!(reader.read_exact(&mut buf).is_ok());\n        let mut buf = [8];\n        assert!(reader.read_exact(&mut buf).is_ok());\n        assert_eq!(buf[0], 0);\n        assert_eq!(reader.len(), 7);\n        let mut buf = [0, 0, 0, 0, 0, 0, 0];\n        assert!(reader.read_exact(&mut buf).is_ok());\n        assert_eq!(buf, [1, 2, 3, 4, 5, 6, 7]);\n        assert_eq!(reader.len(), 0);\n        let mut buf = [0];\n        assert!(reader.read_exact(&mut buf).is_err());\n    }\n\n    #[test]\n    fn test_buf_reader() {\n        let in_buf = vec![0, 1, 2, 3, 4, 5, 6, 7];\n        let mut reader = Cursor::new(&in_buf[..]);\n        let mut buf = [];\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n        assert_eq!(reader.position(), 0);\n        let mut buf = [0];\n        assert_eq!(reader.read(&mut buf).unwrap(), 1);\n        assert_eq!(reader.position(), 1);\n        let b: &[_] = &[0];\n        assert_eq!(buf, b);\n        let mut buf = [0; 4];\n        assert_eq!(reader.read(&mut buf).unwrap(), 4);\n        assert_eq!(reader.position(), 5);\n        let b: &[_] = &[1, 2, 3, 4];\n        assert_eq!(buf, b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 3);\n        let b: &[_] = &[5, 6, 7];\n        assert_eq!(&buf[..3], b);\n        assert_eq!(reader.read(&mut buf).unwrap(), 0);\n    }\n\n    #[test]\n    fn seek_past_end() {\n        let buf = [0xff];\n        let mut r = Cursor::new(&buf[..]);\n        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);\n        assert_eq!(r.read(&mut [0]).unwrap(), 0);\n\n        let mut r = Cursor::new(vec![10]);\n        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);\n        assert_eq!(r.read(&mut [0]).unwrap(), 0);\n\n        let mut buf = [0];\n        let mut r = Cursor::new(&mut buf[..]);\n        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);\n        assert_eq!(r.write(&[3]).unwrap(), 0);\n\n        let mut r = Cursor::new(vec![10].into_boxed_slice());\n        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);\n        assert_eq!(r.write(&[3]).unwrap(), 0);\n    }\n\n    #[test]\n    fn seek_past_i64() {\n        let buf = [0xff];\n        let mut r = Cursor::new(&buf[..]);\n        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);\n        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);\n        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);\n        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);\n        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());\n        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);\n\n        let mut r = Cursor::new(vec![10]);\n        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);\n        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);\n        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);\n        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);\n        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());\n        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);\n\n        let mut buf = [0];\n        let mut r = Cursor::new(&mut buf[..]);\n        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);\n        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);\n        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);\n        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);\n        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());\n        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);\n\n        let mut r = Cursor::new(vec![10].into_boxed_slice());\n        assert_eq!(r.seek(SeekFrom::Start(6)).unwrap(), 6);\n        assert_eq!(r.seek(SeekFrom::Current(0x7ffffffffffffff0)).unwrap(), 0x7ffffffffffffff6);\n        assert_eq!(r.seek(SeekFrom::Current(0x10)).unwrap(), 0x8000000000000006);\n        assert_eq!(r.seek(SeekFrom::Current(0)).unwrap(), 0x8000000000000006);\n        assert!(r.seek(SeekFrom::Current(0x7ffffffffffffffd)).is_err());\n        assert_eq!(r.seek(SeekFrom::Current(-0x8000000000000000)).unwrap(), 6);\n    }\n\n    #[test]\n    fn seek_before_0() {\n        let buf = [0xff];\n        let mut r = Cursor::new(&buf[..]);\n        assert!(r.seek(SeekFrom::End(-2)).is_err());\n\n        let mut r = Cursor::new(vec![10]);\n        assert!(r.seek(SeekFrom::End(-2)).is_err());\n\n        let mut buf = [0];\n        let mut r = Cursor::new(&mut buf[..]);\n        assert!(r.seek(SeekFrom::End(-2)).is_err());\n\n        let mut r = Cursor::new(vec![10].into_boxed_slice());\n        assert!(r.seek(SeekFrom::End(-2)).is_err());\n    }\n\n    #[test]\n    fn test_seekable_mem_writer() {\n        let mut writer = Cursor::new(Vec::<u8>::new());\n        assert_eq!(writer.position(), 0);\n        assert_eq!(writer.write(&[0]).unwrap(), 1);\n        assert_eq!(writer.position(), 1);\n        assert_eq!(writer.write(&[1, 2, 3]).unwrap(), 3);\n        assert_eq!(writer.write(&[4, 5, 6, 7]).unwrap(), 4);\n        assert_eq!(writer.position(), 8);\n        let b: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7];\n        assert_eq!(&writer.get_ref()[..], b);\n\n        assert_eq!(writer.seek(SeekFrom::Start(0)).unwrap(), 0);\n        assert_eq!(writer.position(), 0);\n        assert_eq!(writer.write(&[3, 4]).unwrap(), 2);\n        let b: &[_] = &[3, 4, 2, 3, 4, 5, 6, 7];\n        assert_eq!(&writer.get_ref()[..], b);\n\n        assert_eq!(writer.seek(SeekFrom::Current(1)).unwrap(), 3);\n        assert_eq!(writer.write(&[0, 1]).unwrap(), 2);\n        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 7];\n        assert_eq!(&writer.get_ref()[..], b);\n\n        assert_eq!(writer.seek(SeekFrom::End(-1)).unwrap(), 7);\n        assert_eq!(writer.write(&[1, 2]).unwrap(), 2);\n        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2];\n        assert_eq!(&writer.get_ref()[..], b);\n\n        assert_eq!(writer.seek(SeekFrom::End(1)).unwrap(), 10);\n        assert_eq!(writer.write(&[1]).unwrap(), 1);\n        let b: &[_] = &[3, 4, 2, 0, 1, 5, 6, 1, 2, 0, 1];\n        assert_eq!(&writer.get_ref()[..], b);\n    }\n\n    #[test]\n    fn vec_seek_past_end() {\n        let mut r = Cursor::new(Vec::new());\n        assert_eq!(r.seek(SeekFrom::Start(10)).unwrap(), 10);\n        assert_eq!(r.write(&[3]).unwrap(), 1);\n    }\n\n    #[test]\n    fn vec_seek_before_0() {\n        let mut r = Cursor::new(Vec::new());\n        assert!(r.seek(SeekFrom::End(-2)).is_err());\n    }\n\n    #[test]\n    #[cfg(target_pointer_width = \"32\")]\n    fn vec_seek_and_write_past_usize_max() {\n        let mut c = Cursor::new(Vec::new());\n        c.set_position(<usize>::max_value() as u64 + 1);\n        assert!(c.write_all(&[1, 2, 3]).is_err());\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse io;\nuse sys::{ReadSysCall, WriteSysCall};\n\npub struct Stdin;\npub struct Stdout;\npub struct Stderr;\n\nimpl Stdin {\n    pub fn new() -> io::Result<Stdin> {\n        Ok(Stdin)\n    }\n\n    pub fn read(&self, data: &mut [u8]) -> io::Result<usize> {\n        Ok(ReadSysCall::perform(0, data))\n    }\n}\n\nimpl Stdout {\n    pub fn new() -> io::Result<Stdout> {\n        Ok(Stdout)\n    }\n\n    pub fn write(&self, data: &[u8]) -> io::Result<usize> {\n        WriteSysCall::perform(1, data);\n        Ok(data.len())\n    }\n\n    pub fn flush(&self) -> io::Result<()> {\n        Ok(())\n    }\n}\n\nimpl Stderr {\n    pub fn new() -> io::Result<Stderr> {\n        Ok(Stderr)\n    }\n\n    pub fn write(&self, data: &[u8]) -> io::Result<usize> {\n        WriteSysCall::perform(2, data);\n        Ok(data.len())\n    }\n\n    pub fn flush(&self) -> io::Result<()> {\n        Ok(())\n    }\n}\n\nimpl io::Write for Stderr {\n    fn write(&mut self, data: &[u8]) -> io::Result<usize> {\n        (&*self).write(data)\n    }\n    fn flush(&mut self) -> io::Result<()> {\n        (&*self).flush()\n    }\n}\n\npub const STDIN_BUF_SIZE: usize = 0;\n\npub fn is_ebadf(_err: &io::Error) -> bool {\n    true\n}\n\npub fn stderr_prints_nothing() -> bool {\n    !cfg!(feature = \"wasm_syscall\")\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cell::UnsafeCell;\n\npub struct Mutex {\n    locked: UnsafeCell<bool>,\n}\n\nunsafe impl Send for Mutex {}\nunsafe impl Sync for Mutex {} // no threads on wasm\n\nimpl Mutex {\n    pub const fn new() -> Mutex {\n        Mutex { locked: UnsafeCell::new(false) }\n    }\n\n    #[inline]\n    pub unsafe fn init(&mut self) {\n    }\n\n    #[inline]\n    pub unsafe fn lock(&self) {\n        let locked = self.locked.get();\n        assert!(!*locked, \"cannot recursively acquire mutex\");\n        *locked = true;\n    }\n\n    #[inline]\n    pub unsafe fn unlock(&self) {\n        *self.locked.get() = false;\n    }\n\n    #[inline]\n    pub unsafe fn try_lock(&self) -> bool {\n        let locked = self.locked.get();\n        if *locked {\n            false\n        } else {\n            *locked = true;\n            true\n        }\n    }\n\n    #[inline]\n    pub unsafe fn destroy(&self) {\n    }\n}\n\n// All empty stubs because wasm has no threads yet, so lock acquisition always\n// succeeds.\npub struct ReentrantMutex {\n}\n\nimpl ReentrantMutex {\n    pub unsafe fn uninitialized() -> ReentrantMutex {\n        ReentrantMutex { }\n    }\n\n    pub unsafe fn init(&mut self) {}\n\n    pub unsafe fn lock(&self) {}\n\n    #[inline]\n    pub unsafe fn try_lock(&self) -> bool {\n        true\n    }\n\n    pub unsafe fn unlock(&self) {}\n\n    pub unsafe fn destroy(&self) {}\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// The underlying OsString/OsStr implementation on Unix systems: just\n/// a `Vec<u8>`/`[u8]`.\n\nuse borrow::Cow;\nuse fmt;\nuse str;\nuse mem;\nuse rc::Rc;\nuse sync::Arc;\nuse sys_common::{AsInner, IntoInner};\nuse sys_common::bytestring::debug_fmt_bytestring;\nuse core::str::lossy::Utf8Lossy;\n\n#[derive(Clone, Hash)]\npub struct Buf {\n    pub inner: Vec<u8>\n}\n\npub struct Slice {\n    pub inner: [u8]\n}\n\nimpl fmt::Debug for Slice {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        debug_fmt_bytestring(&self.inner, formatter)\n    }\n}\n\nimpl fmt::Display for Slice {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&Utf8Lossy::from_bytes(&self.inner), formatter)\n    }\n}\n\nimpl fmt::Debug for Buf {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(self.as_slice(), formatter)\n    }\n}\n\nimpl fmt::Display for Buf {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self.as_slice(), formatter)\n    }\n}\n\nimpl IntoInner<Vec<u8>> for Buf {\n    fn into_inner(self) -> Vec<u8> {\n        self.inner\n    }\n}\n\nimpl AsInner<[u8]> for Buf {\n    fn as_inner(&self) -> &[u8] {\n        &self.inner\n    }\n}\n\n\nimpl Buf {\n    pub fn from_string(s: String) -> Buf {\n        Buf { inner: s.into_bytes() }\n    }\n\n    #[inline]\n    pub fn with_capacity(capacity: usize) -> Buf {\n        Buf {\n            inner: Vec::with_capacity(capacity)\n        }\n    }\n\n    #[inline]\n    pub fn clear(&mut self) {\n        self.inner.clear()\n    }\n\n    #[inline]\n    pub fn capacity(&self) -> usize {\n        self.inner.capacity()\n    }\n\n    #[inline]\n    pub fn reserve(&mut self, additional: usize) {\n        self.inner.reserve(additional)\n    }\n\n    #[inline]\n    pub fn reserve_exact(&mut self, additional: usize) {\n        self.inner.reserve_exact(additional)\n    }\n\n    #[inline]\n    pub fn shrink_to_fit(&mut self) {\n        self.inner.shrink_to_fit()\n    }\n\n    #[inline]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        self.inner.shrink_to(min_capacity)\n    }\n\n    pub fn as_slice(&self) -> &Slice {\n        unsafe { mem::transmute(&*self.inner) }\n    }\n\n    pub fn into_string(self) -> Result<String, Buf> {\n        String::from_utf8(self.inner).map_err(|p| Buf { inner: p.into_bytes() } )\n    }\n\n    pub fn push_slice(&mut self, s: &Slice) {\n        self.inner.extend_from_slice(&s.inner)\n    }\n\n    #[inline]\n    pub fn into_box(self) -> Box<Slice> {\n        unsafe { mem::transmute(self.inner.into_boxed_slice()) }\n    }\n\n    #[inline]\n    pub fn from_box(boxed: Box<Slice>) -> Buf {\n        let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };\n        Buf { inner: inner.into_vec() }\n    }\n\n    #[inline]\n    pub fn into_arc(&self) -> Arc<Slice> {\n        self.as_slice().into_arc()\n    }\n\n    #[inline]\n    pub fn into_rc(&self) -> Rc<Slice> {\n        self.as_slice().into_rc()\n    }\n}\n\nimpl Slice {\n    fn from_u8_slice(s: &[u8]) -> &Slice {\n        unsafe { mem::transmute(s) }\n    }\n\n    pub fn from_str(s: &str) -> &Slice {\n        Slice::from_u8_slice(s.as_bytes())\n    }\n\n    pub fn to_str(&self) -> Option<&str> {\n        str::from_utf8(&self.inner).ok()\n    }\n\n    pub fn to_string_lossy(&self) -> Cow<str> {\n        String::from_utf8_lossy(&self.inner)\n    }\n\n    pub fn to_owned(&self) -> Buf {\n        Buf { inner: self.inner.to_vec() }\n    }\n\n    #[inline]\n    pub fn into_box(&self) -> Box<Slice> {\n        let boxed: Box<[u8]> = self.inner.into();\n        unsafe { mem::transmute(boxed) }\n    }\n\n    pub fn empty_box() -> Box<Slice> {\n        let boxed: Box<[u8]> = Default::default();\n        unsafe { mem::transmute(boxed) }\n    }\n\n    #[inline]\n    pub fn into_arc(&self) -> Arc<Slice> {\n        let arc: Arc<[u8]> = Arc::from(&self.inner);\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Slice) }\n    }\n\n    #[inline]\n    pub fn into_rc(&self) -> Rc<Slice> {\n        let rc: Rc<[u8]> = Rc::from(&self.inner);\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse time::Duration;\nuse sys::{TimeSysCall, TimeClock};\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]\npub struct Instant(Duration);\n\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]\npub struct SystemTime(Duration);\n\npub const UNIX_EPOCH: SystemTime = SystemTime(Duration::from_secs(0));\n\nimpl Instant {\n    pub fn now() -> Instant {\n        Instant(TimeSysCall::perform(TimeClock::Monotonic))\n    }\n\n    pub fn sub_instant(&self, other: &Instant) -> Duration {\n        self.0 - other.0\n    }\n\n    pub fn add_duration(&self, other: &Duration) -> Instant {\n        Instant(self.0 + *other)\n    }\n\n    pub fn sub_duration(&self, other: &Duration) -> Instant {\n        Instant(self.0 - *other)\n    }\n}\n\nimpl SystemTime {\n    pub fn now() -> SystemTime {\n        SystemTime(TimeSysCall::perform(TimeClock::System))\n    }\n\n    pub fn sub_time(&self, other: &SystemTime)\n                    -> Result<Duration, Duration> {\n        self.0.checked_sub(other.0).ok_or_else(|| other.0 - self.0)\n    }\n\n    pub fn add_duration(&self, other: &Duration) -> SystemTime {\n        SystemTime(self.0 + *other)\n    }\n\n    pub fn sub_duration(&self, other: &Duration) -> SystemTime {\n        SystemTime(self.0 - *other)\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse ffi::OsString;\nuse fmt;\nuse hash::{Hash, Hasher};\nuse io::{self, SeekFrom};\nuse path::{Path, PathBuf};\nuse sys::time::SystemTime;\nuse sys::{unsupported, Void};\n\npub struct File(Void);\n\npub struct FileAttr(Void);\n\npub struct ReadDir(Void);\n\npub struct DirEntry(Void);\n\n#[derive(Clone, Debug)]\npub struct OpenOptions { }\n\npub struct FilePermissions(Void);\n\npub struct FileType(Void);\n\n#[derive(Debug)]\npub struct DirBuilder { }\n\nimpl FileAttr {\n    pub fn size(&self) -> u64 {\n        match self.0 {}\n    }\n\n    pub fn perm(&self) -> FilePermissions {\n        match self.0 {}\n    }\n\n    pub fn file_type(&self) -> FileType {\n        match self.0 {}\n    }\n\n    pub fn modified(&self) -> io::Result<SystemTime> {\n        match self.0 {}\n    }\n\n    pub fn accessed(&self) -> io::Result<SystemTime> {\n        match self.0 {}\n    }\n\n    pub fn created(&self) -> io::Result<SystemTime> {\n        match self.0 {}\n    }\n}\n\nimpl Clone for FileAttr {\n    fn clone(&self) -> FileAttr {\n        match self.0 {}\n    }\n}\n\nimpl FilePermissions {\n    pub fn readonly(&self) -> bool {\n        match self.0 {}\n    }\n\n    pub fn set_readonly(&mut self, _readonly: bool) {\n        match self.0 {}\n    }\n}\n\nimpl Clone for FilePermissions {\n    fn clone(&self) -> FilePermissions {\n        match self.0 {}\n    }\n}\n\nimpl PartialEq for FilePermissions {\n    fn eq(&self, _other: &FilePermissions) -> bool {\n        match self.0 {}\n    }\n}\n\nimpl Eq for FilePermissions {\n}\n\nimpl fmt::Debug for FilePermissions {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\nimpl FileType {\n    pub fn is_dir(&self) -> bool {\n        match self.0 {}\n    }\n\n    pub fn is_file(&self) -> bool {\n        match self.0 {}\n    }\n\n    pub fn is_symlink(&self) -> bool {\n        match self.0 {}\n    }\n}\n\nimpl Clone for FileType {\n    fn clone(&self) -> FileType {\n        match self.0 {}\n    }\n}\n\nimpl Copy for FileType {}\n\nimpl PartialEq for FileType {\n    fn eq(&self, _other: &FileType) -> bool {\n        match self.0 {}\n    }\n}\n\nimpl Eq for FileType {\n}\n\nimpl Hash for FileType {\n    fn hash<H: Hasher>(&self, _h: &mut H) {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Debug for FileType {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Debug for ReadDir {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\nimpl Iterator for ReadDir {\n    type Item = io::Result<DirEntry>;\n\n    fn next(&mut self) -> Option<io::Result<DirEntry>> {\n        match self.0 {}\n    }\n}\n\nimpl DirEntry {\n    pub fn path(&self) -> PathBuf {\n        match self.0 {}\n    }\n\n    pub fn file_name(&self) -> OsString {\n        match self.0 {}\n    }\n\n    pub fn metadata(&self) -> io::Result<FileAttr> {\n        match self.0 {}\n    }\n\n    pub fn file_type(&self) -> io::Result<FileType> {\n        match self.0 {}\n    }\n}\n\nimpl OpenOptions {\n    pub fn new() -> OpenOptions {\n        OpenOptions { }\n    }\n\n    pub fn read(&mut self, _read: bool) { }\n    pub fn write(&mut self, _write: bool) { }\n    pub fn append(&mut self, _append: bool) { }\n    pub fn truncate(&mut self, _truncate: bool) { }\n    pub fn create(&mut self, _create: bool) { }\n    pub fn create_new(&mut self, _create_new: bool) { }\n}\n\nimpl File {\n    pub fn open(_path: &Path, _opts: &OpenOptions) -> io::Result<File> {\n        unsupported()\n    }\n\n    pub fn file_attr(&self) -> io::Result<FileAttr> {\n        match self.0 {}\n    }\n\n    pub fn fsync(&self) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn datasync(&self) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn truncate(&self, _size: u64) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn read(&self, _buf: &mut [u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn write(&self, _buf: &[u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn flush(&self) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn seek(&self, _pos: SeekFrom) -> io::Result<u64> {\n        match self.0 {}\n    }\n\n    pub fn duplicate(&self) -> io::Result<File> {\n        match self.0 {}\n    }\n\n    pub fn set_permissions(&self, _perm: FilePermissions) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn diverge(&self) -> ! {\n        match self.0 {}\n    }\n}\n\nimpl DirBuilder {\n    pub fn new() -> DirBuilder {\n        DirBuilder { }\n    }\n\n    pub fn mkdir(&self, _p: &Path) -> io::Result<()> {\n        unsupported()\n    }\n}\n\nimpl fmt::Debug for File {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\npub fn readdir(_p: &Path) -> io::Result<ReadDir> {\n    unsupported()\n}\n\npub fn unlink(_p: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn rename(_old: &Path, _new: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn set_perm(_p: &Path, perm: FilePermissions) -> io::Result<()> {\n    match perm.0 {}\n}\n\npub fn rmdir(_p: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn remove_dir_all(_path: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn readlink(_p: &Path) -> io::Result<PathBuf> {\n    unsupported()\n}\n\npub fn symlink(_src: &Path, _dst: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn link(_src: &Path, _dst: &Path) -> io::Result<()> {\n    unsupported()\n}\n\npub fn stat(_p: &Path) -> io::Result<FileAttr> {\n    unsupported()\n}\n\npub fn lstat(_p: &Path) -> io::Result<FileAttr> {\n    unsupported()\n}\n\npub fn canonicalize(_p: &Path) -> io::Result<PathBuf> {\n    unsupported()\n}\n\npub fn copy(_from: &Path, _to: &Path) -> io::Result<u64> {\n    unsupported()\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse ffi::OsStr;\nuse fmt;\nuse io;\nuse sys::fs::File;\nuse sys::pipe::AnonPipe;\nuse sys::{unsupported, Void};\nuse sys_common::process::{CommandEnv, DefaultEnvKey};\n\n////////////////////////////////////////////////////////////////////////////////\n// Command\n////////////////////////////////////////////////////////////////////////////////\n\npub struct Command {\n    env: CommandEnv<DefaultEnvKey>\n}\n\n// passed back to std::process with the pipes connected to the child, if any\n// were requested\npub struct StdioPipes {\n    pub stdin: Option<AnonPipe>,\n    pub stdout: Option<AnonPipe>,\n    pub stderr: Option<AnonPipe>,\n}\n\npub enum Stdio {\n    Inherit,\n    Null,\n    MakePipe,\n}\n\nimpl Command {\n    pub fn new(_program: &OsStr) -> Command {\n        Command {\n            env: Default::default()\n        }\n    }\n\n    pub fn arg(&mut self, _arg: &OsStr) {\n    }\n\n    pub fn env_mut(&mut self) -> &mut CommandEnv<DefaultEnvKey> {\n        &mut self.env\n    }\n\n    pub fn cwd(&mut self, _dir: &OsStr) {\n    }\n\n    pub fn stdin(&mut self, _stdin: Stdio) {\n    }\n\n    pub fn stdout(&mut self, _stdout: Stdio) {\n    }\n\n    pub fn stderr(&mut self, _stderr: Stdio) {\n    }\n\n    pub fn spawn(&mut self, _default: Stdio, _needs_stdin: bool)\n        -> io::Result<(Process, StdioPipes)> {\n        unsupported()\n    }\n}\n\nimpl From<AnonPipe> for Stdio {\n    fn from(pipe: AnonPipe) -> Stdio {\n        pipe.diverge()\n    }\n}\n\nimpl From<File> for Stdio {\n    fn from(file: File) -> Stdio {\n        file.diverge()\n    }\n}\n\nimpl fmt::Debug for Command {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        Ok(())\n    }\n}\n\npub struct ExitStatus(Void);\n\nimpl ExitStatus {\n    pub fn success(&self) -> bool {\n        match self.0 {}\n    }\n\n    pub fn code(&self) -> Option<i32> {\n        match self.0 {}\n    }\n}\n\nimpl Clone for ExitStatus {\n    fn clone(&self) -> ExitStatus {\n        match self.0 {}\n    }\n}\n\nimpl Copy for ExitStatus {}\n\nimpl PartialEq for ExitStatus {\n    fn eq(&self, _other: &ExitStatus) -> bool {\n        match self.0 {}\n    }\n}\n\nimpl Eq for ExitStatus {\n}\n\nimpl fmt::Debug for ExitStatus {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Display for ExitStatus {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\n#[derive(PartialEq, Eq, Clone, Copy, Debug)]\npub struct ExitCode(bool);\n\nimpl ExitCode {\n    pub const SUCCESS: ExitCode = ExitCode(false);\n    pub const FAILURE: ExitCode = ExitCode(true);\n\n    pub fn as_i32(&self) -> i32 {\n        self.0 as i32\n    }\n}\n\npub struct Process(Void);\n\nimpl Process {\n    pub fn id(&self) -> u32 {\n        match self.0 {}\n    }\n\n    pub fn kill(&mut self) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn wait(&mut self) -> io::Result<ExitStatus> {\n        match self.0 {}\n    }\n\n    pub fn try_wait(&mut self) -> io::Result<Option<ExitStatus>> {\n        match self.0 {}\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse error::Error as StdError;\nuse ffi::{OsString, OsStr};\nuse fmt;\nuse io;\nuse path::{self, PathBuf};\nuse str;\nuse sys::{unsupported, Void, ExitSysCall, GetEnvSysCall, SetEnvSysCall};\n\npub fn errno() -> i32 {\n    0\n}\n\npub fn error_string(_errno: i32) -> String {\n    \"operation successful\".to_string()\n}\n\npub fn getcwd() -> io::Result<PathBuf> {\n    unsupported()\n}\n\npub fn chdir(_: &path::Path) -> io::Result<()> {\n    unsupported()\n}\n\npub struct SplitPaths<'a>(&'a Void);\n\npub fn split_paths(_unparsed: &OsStr) -> SplitPaths {\n    panic!(\"unsupported\")\n}\n\nimpl<'a> Iterator for SplitPaths<'a> {\n    type Item = PathBuf;\n    fn next(&mut self) -> Option<PathBuf> {\n        match *self.0 {}\n    }\n}\n\n#[derive(Debug)]\npub struct JoinPathsError;\n\npub fn join_paths<I, T>(_paths: I) -> Result<OsString, JoinPathsError>\n    where I: Iterator<Item=T>, T: AsRef<OsStr>\n{\n    Err(JoinPathsError)\n}\n\nimpl fmt::Display for JoinPathsError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        \"not supported on wasm yet\".fmt(f)\n    }\n}\n\nimpl StdError for JoinPathsError {\n    fn description(&self) -> &str {\n        \"not supported on wasm yet\"\n    }\n}\n\npub fn current_exe() -> io::Result<PathBuf> {\n    unsupported()\n}\n\npub struct Env(Void);\n\nimpl Iterator for Env {\n    type Item = (OsString, OsString);\n    fn next(&mut self) -> Option<(OsString, OsString)> {\n        match self.0 {}\n    }\n}\n\npub fn env() -> Env {\n    panic!(\"not supported on web assembly\")\n}\n\npub fn getenv(k: &OsStr) -> io::Result<Option<OsString>> {\n    Ok(GetEnvSysCall::perform(k))\n}\n\npub fn setenv(k: &OsStr, v: &OsStr) -> io::Result<()> {\n    Ok(SetEnvSysCall::perform(k, Some(v)))\n}\n\npub fn unsetenv(k: &OsStr) -> io::Result<()> {\n    Ok(SetEnvSysCall::perform(k, None))\n}\n\npub fn temp_dir() -> PathBuf {\n    panic!(\"no filesystem on wasm\")\n}\n\npub fn home_dir() -> Option<PathBuf> {\n    None\n}\n\npub fn exit(_code: i32) -> ! {\n    ExitSysCall::perform(_code as isize as usize)\n}\n\npub fn getpid() -> u32 {\n    panic!(\"no pids on wasm\")\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse io;\nuse net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr};\nuse time::Duration;\nuse sys::{unsupported, Void};\n\npub struct TcpStream(Void);\n\nimpl TcpStream {\n    pub fn connect(_: &SocketAddr) -> io::Result<TcpStream> {\n        unsupported()\n    }\n\n    pub fn connect_timeout(_: &SocketAddr, _: Duration) -> io::Result<TcpStream> {\n        unsupported()\n    }\n\n    pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {\n        match self.0 {}\n    }\n\n    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {\n        match self.0 {}\n    }\n\n    pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn read(&self, _: &mut [u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn write(&self, _: &[u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn peer_addr(&self) -> io::Result<SocketAddr> {\n        match self.0 {}\n    }\n\n    pub fn socket_addr(&self) -> io::Result<SocketAddr> {\n        match self.0 {}\n    }\n\n    pub fn shutdown(&self, _: Shutdown) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn duplicate(&self) -> io::Result<TcpStream> {\n        match self.0 {}\n    }\n\n    pub fn set_nodelay(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn nodelay(&self) -> io::Result<bool> {\n        match self.0 {}\n    }\n\n    pub fn set_ttl(&self, _: u32) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn ttl(&self) -> io::Result<u32> {\n        match self.0 {}\n    }\n\n    pub fn take_error(&self) -> io::Result<Option<io::Error>> {\n        match self.0 {}\n    }\n\n    pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Debug for TcpStream {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\npub struct TcpListener(Void);\n\nimpl TcpListener {\n    pub fn bind(_: &SocketAddr) -> io::Result<TcpListener> {\n        unsupported()\n    }\n\n    pub fn socket_addr(&self) -> io::Result<SocketAddr> {\n        match self.0 {}\n    }\n\n    pub fn accept(&self) -> io::Result<(TcpStream, SocketAddr)> {\n        match self.0 {}\n    }\n\n    pub fn duplicate(&self) -> io::Result<TcpListener> {\n        match self.0 {}\n    }\n\n    pub fn set_ttl(&self, _: u32) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn ttl(&self) -> io::Result<u32> {\n        match self.0 {}\n    }\n\n    pub fn set_only_v6(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn only_v6(&self) -> io::Result<bool> {\n        match self.0 {}\n    }\n\n    pub fn take_error(&self) -> io::Result<Option<io::Error>> {\n        match self.0 {}\n    }\n\n    pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Debug for TcpListener {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\npub struct UdpSocket(Void);\n\nimpl UdpSocket {\n    pub fn bind(_: &SocketAddr) -> io::Result<UdpSocket> {\n        unsupported()\n    }\n\n    pub fn socket_addr(&self) -> io::Result<SocketAddr> {\n        match self.0 {}\n    }\n\n    pub fn recv_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {\n        match self.0 {}\n    }\n\n    pub fn peek_from(&self, _: &mut [u8]) -> io::Result<(usize, SocketAddr)> {\n        match self.0 {}\n    }\n\n    pub fn send_to(&self, _: &[u8], _: &SocketAddr) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn duplicate(&self) -> io::Result<UdpSocket> {\n        match self.0 {}\n    }\n\n    pub fn set_read_timeout(&self, _: Option<Duration>) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn set_write_timeout(&self, _: Option<Duration>) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn read_timeout(&self) -> io::Result<Option<Duration>> {\n        match self.0 {}\n    }\n\n    pub fn write_timeout(&self) -> io::Result<Option<Duration>> {\n        match self.0 {}\n    }\n\n    pub fn set_broadcast(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn broadcast(&self) -> io::Result<bool> {\n        match self.0 {}\n    }\n\n    pub fn set_multicast_loop_v4(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn multicast_loop_v4(&self) -> io::Result<bool> {\n        match self.0 {}\n    }\n\n    pub fn set_multicast_ttl_v4(&self, _: u32) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn multicast_ttl_v4(&self) -> io::Result<u32> {\n        match self.0 {}\n    }\n\n    pub fn set_multicast_loop_v6(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn multicast_loop_v6(&self) -> io::Result<bool> {\n        match self.0 {}\n    }\n\n    pub fn join_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr)\n                         -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn join_multicast_v6(&self, _: &Ipv6Addr, _: u32)\n                         -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn leave_multicast_v4(&self, _: &Ipv4Addr, _: &Ipv4Addr)\n                          -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn leave_multicast_v6(&self, _: &Ipv6Addr, _: u32)\n                          -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn set_ttl(&self, _: u32) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn ttl(&self) -> io::Result<u32> {\n        match self.0 {}\n    }\n\n    pub fn take_error(&self) -> io::Result<Option<io::Error>> {\n        match self.0 {}\n    }\n\n    pub fn set_nonblocking(&self, _: bool) -> io::Result<()> {\n        match self.0 {}\n    }\n\n    pub fn recv(&self, _: &mut [u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn peek(&self, _: &mut [u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn send(&self, _: &[u8]) -> io::Result<usize> {\n        match self.0 {}\n    }\n\n    pub fn connect(&self, _: &SocketAddr) -> io::Result<()> {\n        match self.0 {}\n    }\n}\n\nimpl fmt::Debug for UdpSocket {\n    fn fmt(&self, _f: &mut fmt::Formatter) -> fmt::Result {\n        match self.0 {}\n    }\n}\n\npub struct LookupHost(Void);\n\nimpl Iterator for LookupHost {\n    type Item = SocketAddr;\n    fn next(&mut self) -> Option<SocketAddr> {\n        match self.0 {}\n    }\n}\n\npub fn lookup_host(_: &str) -> io::Result<LookupHost> {\n    unsupported()\n}\n\n#[allow(nonstandard_style)]\npub mod netc {\n    pub const AF_INET: u8 = 0;\n    pub const AF_INET6: u8 = 1;\n    pub type sa_family_t = u8;\n\n    #[derive(Copy, Clone)]\n    pub struct in_addr {\n        pub s_addr: u32,\n    }\n\n    #[derive(Copy, Clone)]\n    pub struct sockaddr_in {\n        pub sin_family: sa_family_t,\n        pub sin_port: u16,\n        pub sin_addr: in_addr,\n    }\n\n    #[derive(Copy, Clone)]\n    pub struct in6_addr {\n        pub s6_addr: [u8; 16],\n    }\n\n    #[derive(Copy, Clone)]\n    pub struct sockaddr_in6 {\n        pub sin6_family: sa_family_t,\n        pub sin6_port: u16,\n        pub sin6_addr: in6_addr,\n        pub sin6_flowinfo: u32,\n        pub sin6_scope_id: u32,\n    }\n\n    #[derive(Copy, Clone)]\n    pub struct sockaddr {\n    }\n\n    pub type socklen_t = usize;\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse sys::mutex::Mutex;\nuse time::Duration;\n\npub struct Condvar { }\n\nimpl Condvar {\n    pub const fn new() -> Condvar {\n        Condvar { }\n    }\n\n    #[inline]\n    pub unsafe fn init(&mut self) {}\n\n    #[inline]\n    pub unsafe fn notify_one(&self) {\n    }\n\n    #[inline]\n    pub unsafe fn notify_all(&self) {\n    }\n\n    pub unsafe fn wait(&self, _mutex: &Mutex) {\n        panic!(\"can't block with web assembly\")\n    }\n\n    pub unsafe fn wait_timeout(&self, _mutex: &Mutex, _dur: Duration) -> bool {\n        panic!(\"can't block with web assembly\");\n    }\n\n    #[inline]\n    pub unsafe fn destroy(&self) {\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse ffi::OsString;\nuse marker::PhantomData;\nuse vec;\nuse sys::ArgsSysCall;\n\npub unsafe fn init(_argc: isize, _argv: *const *const u8) {\n    // On wasm these should always be null, so there's nothing for us to do here\n}\n\npub unsafe fn cleanup() {\n}\n\npub fn args() -> Args {\n    let v = ArgsSysCall::perform();\n    Args {\n        iter: v.into_iter(),\n        _dont_send_or_sync_me: PhantomData,\n    }\n}\n\npub struct Args {\n    iter: vec::IntoIter<OsString>,\n    _dont_send_or_sync_me: PhantomData<*mut ()>,\n}\n\nimpl Args {\n    pub fn inner_debug(&self) -> &[OsString] {\n        self.iter.as_slice()\n    }\n}\n\nimpl Iterator for Args {\n    type Item = OsString;\n    fn next(&mut self) -> Option<OsString> {\n        self.iter.next()\n    }\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.iter.size_hint()\n    }\n}\n\nimpl ExactSizeIterator for Args {\n    fn len(&self) -> usize {\n        self.iter.len()\n    }\n}\n\nimpl DoubleEndedIterator for Args {\n    fn next_back(&mut self) -> Option<OsString> {\n        self.iter.next_back()\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse path::Prefix;\nuse ffi::OsStr;\n\n#[inline]\npub fn is_sep_byte(b: u8) -> bool {\n    b == b'/'\n}\n\n#[inline]\npub fn is_verbatim_sep(b: u8) -> bool {\n    b == b'/'\n}\n\npub fn parse_prefix(_: &OsStr) -> Option<Prefix> {\n    None\n}\n\npub const MAIN_SEP_STR: &'static str = \"/\";\npub const MAIN_SEP: char = '/';\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse boxed::Box;\nuse ptr;\n\npub type Key = usize;\n\nstruct Allocated {\n    value: *mut u8,\n    dtor: Option<unsafe extern fn(*mut u8)>,\n}\n\n#[inline]\npub unsafe fn create(dtor: Option<unsafe extern fn(*mut u8)>) -> Key {\n    Box::into_raw(Box::new(Allocated {\n        value: ptr::null_mut(),\n        dtor,\n    })) as usize\n}\n\n#[inline]\npub unsafe fn set(key: Key, value: *mut u8) {\n    (*(key as *mut Allocated)).value = value;\n}\n\n#[inline]\npub unsafe fn get(key: Key) -> *mut u8 {\n    (*(key as *mut Allocated)).value\n}\n\n#[inline]\npub unsafe fn destroy(key: Key) {\n    let key = Box::from_raw(key as *mut Allocated);\n    if let Some(f) = key.dtor {\n        f(key.value);\n    }\n}\n\n#[inline]\npub fn requires_synchronized_create() -> bool {\n    false\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Traits for working with Errors.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\n// A note about crates and the facade:\n//\n// Originally, the `Error` trait was defined in libcore, and the impls\n// were scattered about. However, coherence objected to this\n// arrangement, because to create the blanket impls for `Box` required\n// knowing that `&str: !Error`, and we have no means to deal with that\n// sort of conflict just now. Therefore, for the time being, we have\n// moved the `Error` trait into libstd. As we evolve a sol'n to the\n// coherence challenge (e.g., specialization, neg impls, etc) we can\n// reconsider what crate these items belong in.\n\nuse alloc::{AllocErr, LayoutErr, CannotReallocInPlace};\nuse any::TypeId;\nuse borrow::Cow;\nuse cell;\nuse char;\nuse core::array;\nuse fmt::{self, Debug, Display};\nuse mem::transmute;\nuse num;\nuse str;\nuse string;\n\n/// `Error` is a trait representing the basic expectations for error values,\n/// i.e. values of type `E` in [`Result<T, E>`]. Errors must describe\n/// themselves through the [`Display`] and [`Debug`] traits, and may provide\n/// cause chain information:\n///\n/// The [`cause`] method is generally used when errors cross \"abstraction\n/// boundaries\", i.e.  when a one module must report an error that is \"caused\"\n/// by an error from a lower-level module. This setup makes it possible for the\n/// high-level module to provide its own errors that do not commit to any\n/// particular implementation, but also reveal some of its implementation for\n/// debugging via [`cause`] chains.\n///\n/// [`Result<T, E>`]: ../result/enum.Result.html\n/// [`Display`]: ../fmt/trait.Display.html\n/// [`Debug`]: ../fmt/trait.Debug.html\n/// [`cause`]: trait.Error.html#method.cause\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Error: Debug + Display {\n    /// **This method is soft-deprecated.**\n    ///\n    /// Although using it won\u2019t cause compilation warning,\n    /// new code should use [`Display`] instead\n    /// and new `impl`s can omit it.\n    ///\n    /// To obtain error description as a string, use `to_string()`.\n    ///\n    /// [`Display`]: ../fmt/trait.Display.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// match \"xc\".parse::<u32>() {\n    ///     Err(e) => {\n    ///         // Print `e` itself, not `e.description()`.\n    ///         println!(\"Error: {}\", e);\n    ///     }\n    ///     _ => println!(\"No error\"),\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn description(&self) -> &str {\n        \"description() is deprecated; use Display\"\n    }\n\n    /// The lower-level cause of this error, if any.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::fmt;\n    ///\n    /// #[derive(Debug)]\n    /// struct SuperError {\n    ///     side: SuperErrorSideKick,\n    /// }\n    ///\n    /// impl fmt::Display for SuperError {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"SuperError is here!\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for SuperError {\n    ///     fn description(&self) -> &str {\n    ///         \"I'm the superhero of errors\"\n    ///     }\n    ///\n    ///     fn cause(&self) -> Option<&Error> {\n    ///         Some(&self.side)\n    ///     }\n    /// }\n    ///\n    /// #[derive(Debug)]\n    /// struct SuperErrorSideKick;\n    ///\n    /// impl fmt::Display for SuperErrorSideKick {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"SuperErrorSideKick is here!\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for SuperErrorSideKick {\n    ///     fn description(&self) -> &str {\n    ///         \"I'm SuperError side kick\"\n    ///     }\n    /// }\n    ///\n    /// fn get_super_error() -> Result<(), SuperError> {\n    ///     Err(SuperError { side: SuperErrorSideKick })\n    /// }\n    ///\n    /// fn main() {\n    ///     match get_super_error() {\n    ///         Err(e) => {\n    ///             println!(\"Error: {}\", e.description());\n    ///             println!(\"Caused by: {}\", e.cause().unwrap());\n    ///         }\n    ///         _ => println!(\"No error\"),\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.33.0\", reason = \"replaced by Error::source, which can support \\\n                                                   downcasting\")]\n    fn cause(&self) -> Option<&dyn Error> {\n        self.source()\n    }\n\n    /// The lower-level source of this error, if any.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::fmt;\n    ///\n    /// #[derive(Debug)]\n    /// struct SuperError {\n    ///     side: SuperErrorSideKick,\n    /// }\n    ///\n    /// impl fmt::Display for SuperError {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"SuperError is here!\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for SuperError {\n    ///     fn description(&self) -> &str {\n    ///         \"I'm the superhero of errors\"\n    ///     }\n    ///\n    ///     fn source(&self) -> Option<&(dyn Error + 'static)> {\n    ///         Some(&self.side)\n    ///     }\n    /// }\n    ///\n    /// #[derive(Debug)]\n    /// struct SuperErrorSideKick;\n    ///\n    /// impl fmt::Display for SuperErrorSideKick {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f, \"SuperErrorSideKick is here!\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for SuperErrorSideKick {\n    ///     fn description(&self) -> &str {\n    ///         \"I'm SuperError side kick\"\n    ///     }\n    /// }\n    ///\n    /// fn get_super_error() -> Result<(), SuperError> {\n    ///     Err(SuperError { side: SuperErrorSideKick })\n    /// }\n    ///\n    /// fn main() {\n    ///     match get_super_error() {\n    ///         Err(e) => {\n    ///             println!(\"Error: {}\", e.description());\n    ///             println!(\"Caused by: {}\", e.source().unwrap());\n    ///         }\n    ///         _ => println!(\"No error\"),\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"error_source\", since = \"1.30.0\")]\n    fn source(&self) -> Option<&(dyn Error + 'static)> { None }\n\n    /// Get the `TypeId` of `self`\n    #[doc(hidden)]\n    #[unstable(feature = \"error_type_id\",\n               reason = \"unclear whether to commit to this public implementation detail\",\n               issue = \"27745\")]\n    fn type_id(&self) -> TypeId where Self: 'static {\n        TypeId::of::<Self>()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, E: Error + 'a> From<E> for Box<dyn Error + 'a> {\n    /// Converts a type of [`Error`] into a box of dyn [`Error`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::fmt;\n    /// use std::mem;\n    ///\n    /// #[derive(Debug)]\n    /// struct AnError;\n    ///\n    /// impl fmt::Display for AnError {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f , \"An error\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for AnError {\n    ///     fn description(&self) -> &str {\n    ///         \"Description of an error\"\n    ///     }\n    /// }\n    ///\n    /// let an_error = AnError;\n    /// assert!(0 == mem::size_of_val(&an_error));\n    /// let a_boxed_error = Box::<Error>::from(an_error);\n    /// assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: E) -> Box<dyn Error + 'a> {\n        Box::new(err)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, E: Error + Send + Sync + 'a> From<E> for Box<dyn Error + Send + Sync + 'a> {\n    /// Converts a type of [`Error`] + [`Send`] + [`Sync`] into a box of dyn [`Error`] +\n    /// [`Send`] + [`Sync`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::fmt;\n    /// use std::mem;\n    ///\n    /// #[derive(Debug)]\n    /// struct AnError;\n    ///\n    /// impl fmt::Display for AnError {\n    ///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n    ///         write!(f , \"An error\")\n    ///     }\n    /// }\n    ///\n    /// impl Error for AnError {\n    ///     fn description(&self) -> &str {\n    ///         \"Description of an error\"\n    ///     }\n    /// }\n    ///\n    /// unsafe impl Send for AnError {}\n    ///\n    /// unsafe impl Sync for AnError {}\n    ///\n    /// let an_error = AnError;\n    /// assert!(0 == mem::size_of_val(&an_error));\n    /// let a_boxed_error = Box::<Error + Send + Sync>::from(an_error);\n    /// assert!(\n    ///     mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: E) -> Box<dyn Error + Send + Sync + 'a> {\n        Box::new(err)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl From<String> for Box<dyn Error + Send + Sync> {\n    /// Converts a [`String`] into a box of dyn [`Error`] + [`Send`] + [`Sync`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    ///\n    /// let a_string_error = \"a string error\".to_string();\n    /// let a_boxed_error = Box::<Error + Send + Sync>::from(a_string_error);\n    /// assert!(\n    ///     mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: String) -> Box<dyn Error + Send + Sync> {\n        #[derive(Debug)]\n        struct StringError(String);\n\n        impl Error for StringError {\n            fn description(&self) -> &str { &self.0 }\n        }\n\n        impl Display for StringError {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                Display::fmt(&self.0, f)\n            }\n        }\n\n        Box::new(StringError(err))\n    }\n}\n\n#[stable(feature = \"string_box_error\", since = \"1.6.0\")]\nimpl From<String> for Box<dyn Error> {\n    /// Converts a [`String`] into a box of dyn [`Error`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    ///\n    /// let a_string_error = \"a string error\".to_string();\n    /// let a_boxed_error = Box::<Error>::from(a_string_error);\n    /// assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(str_err: String) -> Box<dyn Error> {\n        let err1: Box<dyn Error + Send + Sync> = From::from(str_err);\n        let err2: Box<dyn Error> = err1;\n        err2\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, 'b> From<&'b str> for Box<dyn Error + Send + Sync + 'a> {\n    /// Converts a [`str`] into a box of dyn [`Error`] + [`Send`] + [`Sync`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    ///\n    /// let a_str_error = \"a str error\";\n    /// let a_boxed_error = Box::<Error + Send + Sync>::from(a_str_error);\n    /// assert!(\n    ///     mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: &'b str) -> Box<dyn Error + Send + Sync + 'a> {\n        From::from(String::from(err))\n    }\n}\n\n#[stable(feature = \"string_box_error\", since = \"1.6.0\")]\nimpl<'a> From<&'a str> for Box<dyn Error> {\n    /// Converts a [`str`] into a box of dyn [`Error`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    ///\n    /// let a_str_error = \"a str error\";\n    /// let a_boxed_error = Box::<Error>::from(a_str_error);\n    /// assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: &'a str) -> Box<dyn Error> {\n        From::from(String::from(err))\n    }\n}\n\n#[stable(feature = \"cow_box_error\", since = \"1.22.0\")]\nimpl<'a, 'b> From<Cow<'b, str>> for Box<dyn Error + Send + Sync + 'a> {\n    /// Converts a [`Cow`] into a box of dyn [`Error`] + [`Send`] + [`Sync`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    /// use std::borrow::Cow;\n    ///\n    /// let a_cow_str_error = Cow::from(\"a str error\");\n    /// let a_boxed_error = Box::<Error + Send + Sync>::from(a_cow_str_error);\n    /// assert!(\n    ///     mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: Cow<'b, str>) -> Box<dyn Error + Send + Sync + 'a> {\n        From::from(String::from(err))\n    }\n}\n\n#[stable(feature = \"cow_box_error\", since = \"1.22.0\")]\nimpl<'a> From<Cow<'a, str>> for Box<dyn Error> {\n    /// Converts a [`Cow`] into a box of dyn [`Error`].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::error::Error;\n    /// use std::mem;\n    /// use std::borrow::Cow;\n    ///\n    /// let a_cow_str_error = Cow::from(\"a str error\");\n    /// let a_boxed_error = Box::<Error>::from(a_cow_str_error);\n    /// assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))\n    /// ```\n    fn from(err: Cow<'a, str>) -> Box<dyn Error> {\n        From::from(String::from(err))\n    }\n}\n\n#[unstable(feature = \"never_type\", issue = \"35121\")]\nimpl Error for ! {\n    fn description(&self) -> &str { *self }\n}\n\n#[unstable(feature = \"allocator_api\",\n           reason = \"the precise API and guarantees it provides may be tweaked.\",\n           issue = \"32838\")]\nimpl Error for AllocErr {\n    fn description(&self) -> &str {\n        \"memory allocation failed\"\n    }\n}\n\n#[unstable(feature = \"allocator_api\",\n           reason = \"the precise API and guarantees it provides may be tweaked.\",\n           issue = \"32838\")]\nimpl Error for LayoutErr {\n    fn description(&self) -> &str {\n        \"invalid parameters to Layout::from_size_align\"\n    }\n}\n\n#[unstable(feature = \"allocator_api\",\n           reason = \"the precise API and guarantees it provides may be tweaked.\",\n           issue = \"32838\")]\nimpl Error for CannotReallocInPlace {\n    fn description(&self) -> &str {\n        CannotReallocInPlace::description(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for str::ParseBoolError {\n    fn description(&self) -> &str { \"failed to parse bool\" }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for str::Utf8Error {\n    fn description(&self) -> &str {\n        \"invalid utf-8: corrupt contents\"\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for num::ParseIntError {\n    fn description(&self) -> &str {\n        self.__description()\n    }\n}\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl Error for num::TryFromIntError {\n    fn description(&self) -> &str {\n        self.__description()\n    }\n}\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl Error for array::TryFromSliceError {\n    fn description(&self) -> &str {\n        self.__description()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for num::ParseFloatError {\n    fn description(&self) -> &str {\n        self.__description()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for string::FromUtf8Error {\n    fn description(&self) -> &str {\n        \"invalid utf-8\"\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for string::FromUtf16Error {\n    fn description(&self) -> &str {\n        \"invalid utf-16\"\n    }\n}\n\n#[stable(feature = \"str_parse_error2\", since = \"1.8.0\")]\nimpl Error for string::ParseError {\n    fn description(&self) -> &str {\n        match *self {}\n    }\n}\n\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\nimpl Error for char::DecodeUtf16Error {\n    fn description(&self) -> &str {\n        \"unpaired surrogate found\"\n    }\n}\n\n#[stable(feature = \"box_error\", since = \"1.8.0\")]\nimpl<T: Error> Error for Box<T> {\n    fn description(&self) -> &str {\n        Error::description(&**self)\n    }\n\n    fn cause(&self) -> Option<&dyn Error> {\n        Error::cause(&**self)\n    }\n}\n\n#[stable(feature = \"fmt_error\", since = \"1.11.0\")]\nimpl Error for fmt::Error {\n    fn description(&self) -> &str {\n        \"an error occurred when formatting an argument\"\n    }\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Error for cell::BorrowError {\n    fn description(&self) -> &str {\n        \"already mutably borrowed\"\n    }\n}\n\n#[stable(feature = \"try_borrow\", since = \"1.13.0\")]\nimpl Error for cell::BorrowMutError {\n    fn description(&self) -> &str {\n        \"already borrowed\"\n    }\n}\n\n#[unstable(feature = \"try_from\", issue = \"33417\")]\nimpl Error for char::CharTryFromError {\n    fn description(&self) -> &str {\n        \"converted integer out of range for `char`\"\n    }\n}\n\n#[stable(feature = \"char_from_str\", since = \"1.20.0\")]\nimpl Error for char::ParseCharError {\n    fn description(&self) -> &str {\n        self.__description()\n    }\n}\n\n// copied from any.rs\nimpl dyn Error + 'static {\n    /// Returns true if the boxed type is the same as `T`\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn is<T: Error + 'static>(&self) -> bool {\n        // Get TypeId of the type this function is instantiated with\n        let t = TypeId::of::<T>();\n\n        // Get TypeId of the type in the trait object\n        let boxed = self.type_id();\n\n        // Compare both TypeIds on equality\n        t == boxed\n    }\n\n    /// Returns some reference to the boxed value if it is of type `T`, or\n    /// `None` if it isn't.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {\n        if self.is::<T>() {\n            unsafe {\n                Some(&*(self as *const dyn Error as *const T))\n            }\n        } else {\n            None\n        }\n    }\n\n    /// Returns some mutable reference to the boxed value if it is of type `T`, or\n    /// `None` if it isn't.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {\n        if self.is::<T>() {\n            unsafe {\n                Some(&mut *(self as *mut dyn Error as *mut T))\n            }\n        } else {\n            None\n        }\n    }\n}\n\nimpl dyn Error + 'static + Send {\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn is<T: Error + 'static>(&self) -> bool {\n        <dyn Error + 'static>::is::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {\n        <dyn Error + 'static>::downcast_ref::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {\n        <dyn Error + 'static>::downcast_mut::<T>(self)\n    }\n}\n\nimpl dyn Error + 'static + Send + Sync {\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn is<T: Error + 'static>(&self) -> bool {\n        <dyn Error + 'static>::is::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_ref<T: Error + 'static>(&self) -> Option<&T> {\n        <dyn Error + 'static>::downcast_ref::<T>(self)\n    }\n\n    /// Forwards to the method defined on the type `Any`.\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    #[inline]\n    pub fn downcast_mut<T: Error + 'static>(&mut self) -> Option<&mut T> {\n        <dyn Error + 'static>::downcast_mut::<T>(self)\n    }\n}\n\nimpl dyn Error {\n    #[inline]\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    /// Attempt to downcast the box to a concrete type.\n    pub fn downcast<T: Error + 'static>(self: Box<Self>) -> Result<Box<T>, Box<dyn Error>> {\n        if self.is::<T>() {\n            unsafe {\n                let raw: *mut dyn Error = Box::into_raw(self);\n                Ok(Box::from_raw(raw as *mut T))\n            }\n        } else {\n            Err(self)\n        }\n    }\n}\n\nimpl dyn Error + Send {\n    #[inline]\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    /// Attempt to downcast the box to a concrete type.\n    pub fn downcast<T: Error + 'static>(self: Box<Self>)\n                                        -> Result<Box<T>, Box<dyn Error + Send>> {\n        let err: Box<dyn Error> = self;\n        <dyn Error>::downcast(err).map_err(|s| unsafe {\n            // reapply the Send marker\n            transmute::<Box<dyn Error>, Box<dyn Error + Send>>(s)\n        })\n    }\n}\n\nimpl dyn Error + Send + Sync {\n    #[inline]\n    #[stable(feature = \"error_downcast\", since = \"1.3.0\")]\n    /// Attempt to downcast the box to a concrete type.\n    pub fn downcast<T: Error + 'static>(self: Box<Self>)\n                                        -> Result<Box<T>, Box<Self>> {\n        let err: Box<dyn Error> = self;\n        <dyn Error>::downcast(err).map_err(|s| unsafe {\n            // reapply the Send+Sync marker\n            transmute::<Box<dyn Error>, Box<dyn Error + Send + Sync>>(s)\n        })\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::Error;\n    use fmt;\n\n    #[derive(Debug, PartialEq)]\n    struct A;\n    #[derive(Debug, PartialEq)]\n    struct B;\n\n    impl fmt::Display for A {\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            write!(f, \"A\")\n        }\n    }\n    impl fmt::Display for B {\n        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n            write!(f, \"B\")\n        }\n    }\n\n    impl Error for A {\n        fn description(&self) -> &str { \"A-desc\" }\n    }\n    impl Error for B {\n        fn description(&self) -> &str { \"A-desc\" }\n    }\n\n    #[test]\n    fn downcasting() {\n        let mut a = A;\n        let a = &mut a as &mut (dyn Error + 'static);\n        assert_eq!(a.downcast_ref::<A>(), Some(&A));\n        assert_eq!(a.downcast_ref::<B>(), None);\n        assert_eq!(a.downcast_mut::<A>(), Some(&mut A));\n        assert_eq!(a.downcast_mut::<B>(), None);\n\n        let a: Box<dyn Error> = Box::new(A);\n        match a.downcast::<B>() {\n            Ok(..) => panic!(\"expected error\"),\n            Err(e) => assert_eq!(*e.downcast::<A>().unwrap(), A),\n        }\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse marker;\nuse ops::Deref;\nuse sys_common::poison::{self, TryLockError, TryLockResult, LockResult};\nuse sys::mutex as sys;\nuse panic::{UnwindSafe, RefUnwindSafe};\n\n/// A re-entrant mutual exclusion\n///\n/// This mutex will block *other* threads waiting for the lock to become\n/// available. The thread which has already locked the mutex can lock it\n/// multiple times without blocking, preventing a common source of deadlocks.\npub struct ReentrantMutex<T> {\n    inner: Box<sys::ReentrantMutex>,\n    poison: poison::Flag,\n    data: T,\n}\n\nunsafe impl<T: Send> Send for ReentrantMutex<T> {}\nunsafe impl<T: Send> Sync for ReentrantMutex<T> {}\n\nimpl<T> UnwindSafe for ReentrantMutex<T> {}\nimpl<T> RefUnwindSafe for ReentrantMutex<T> {}\n\n\n/// An RAII implementation of a \"scoped lock\" of a mutex. When this structure is\n/// dropped (falls out of scope), the lock will be unlocked.\n///\n/// The data protected by the mutex can be accessed through this guard via its\n/// Deref implementation.\n///\n/// # Mutability\n///\n/// Unlike `MutexGuard`, `ReentrantMutexGuard` does not implement `DerefMut`,\n/// because implementation of the trait would violate Rust\u2019s reference aliasing\n/// rules. Use interior mutability (usually `RefCell`) in order to mutate the\n/// guarded data.\n#[must_use = \"if unused the ReentrantMutex will immediately unlock\"]\npub struct ReentrantMutexGuard<'a, T: 'a> {\n    // funny underscores due to how Deref currently works (it disregards field\n    // privacy).\n    __lock: &'a ReentrantMutex<T>,\n    __poison: poison::Guard,\n}\n\nimpl<'a, T> !marker::Send for ReentrantMutexGuard<'a, T> {}\n\n\nimpl<T> ReentrantMutex<T> {\n    /// Creates a new reentrant mutex in an unlocked state.\n    pub fn new(t: T) -> ReentrantMutex<T> {\n        unsafe {\n            let mut mutex = ReentrantMutex {\n                inner: box sys::ReentrantMutex::uninitialized(),\n                poison: poison::Flag::new(),\n                data: t,\n            };\n            mutex.inner.init();\n            mutex\n        }\n    }\n\n    /// Acquires a mutex, blocking the current thread until it is able to do so.\n    ///\n    /// This function will block the caller until it is available to acquire the mutex.\n    /// Upon returning, the thread is the only thread with the mutex held. When the thread\n    /// calling this method already holds the lock, the call shall succeed without\n    /// blocking.\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return failure if the mutex would otherwise be\n    /// acquired.\n    pub fn lock(&self) -> LockResult<ReentrantMutexGuard<T>> {\n        unsafe { self.inner.lock() }\n        ReentrantMutexGuard::new(&self)\n    }\n\n    /// Attempts to acquire this lock.\n    ///\n    /// If the lock could not be acquired at this time, then `Err` is returned.\n    /// Otherwise, an RAII guard is returned.\n    ///\n    /// This function does not block.\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return failure if the mutex would otherwise be\n    /// acquired.\n    pub fn try_lock(&self) -> TryLockResult<ReentrantMutexGuard<T>> {\n        if unsafe { self.inner.try_lock() } {\n            Ok(ReentrantMutexGuard::new(&self)?)\n        } else {\n            Err(TryLockError::WouldBlock)\n        }\n    }\n}\n\nimpl<T> Drop for ReentrantMutex<T> {\n    fn drop(&mut self) {\n        // This is actually safe b/c we know that there is no further usage of\n        // this mutex (it's up to the user to arrange for a mutex to get\n        // dropped, that's not our job)\n        unsafe { self.inner.destroy() }\n    }\n}\n\nimpl<T: fmt::Debug + 'static> fmt::Debug for ReentrantMutex<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match self.try_lock() {\n            Ok(guard) => f.debug_struct(\"ReentrantMutex\").field(\"data\", &*guard).finish(),\n            Err(TryLockError::Poisoned(err)) => {\n                f.debug_struct(\"ReentrantMutex\").field(\"data\", &**err.get_ref()).finish()\n            },\n            Err(TryLockError::WouldBlock) => {\n                struct LockedPlaceholder;\n                impl fmt::Debug for LockedPlaceholder {\n                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(\"<locked>\") }\n                }\n\n                f.debug_struct(\"ReentrantMutex\").field(\"data\", &LockedPlaceholder).finish()\n            }\n        }\n    }\n}\n\nimpl<'mutex, T> ReentrantMutexGuard<'mutex, T> {\n    fn new(lock: &'mutex ReentrantMutex<T>)\n            -> LockResult<ReentrantMutexGuard<'mutex, T>> {\n        poison::map_result(lock.poison.borrow(), |guard| {\n            ReentrantMutexGuard {\n                __lock: lock,\n                __poison: guard,\n            }\n        })\n    }\n}\n\nimpl<'mutex, T> Deref for ReentrantMutexGuard<'mutex, T> {\n    type Target = T;\n\n    fn deref(&self) -> &T {\n        &self.__lock.data\n    }\n}\n\nimpl<'a, T> Drop for ReentrantMutexGuard<'a, T> {\n    #[inline]\n    fn drop(&mut self) {\n        unsafe {\n            self.__lock.poison.done(&self.__poison);\n            self.__lock.inner.unlock();\n        }\n    }\n}\n\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};\n    use cell::RefCell;\n    use sync::Arc;\n    use thread;\n\n    #[test]\n    fn smoke() {\n        let m = ReentrantMutex::new(());\n        {\n            let a = m.lock().unwrap();\n            {\n                let b = m.lock().unwrap();\n                {\n                    let c = m.lock().unwrap();\n                    assert_eq!(*c, ());\n                }\n                assert_eq!(*b, ());\n            }\n            assert_eq!(*a, ());\n        }\n    }\n\n    #[test]\n    fn is_mutex() {\n        let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));\n        let m2 = m.clone();\n        let lock = m.lock().unwrap();\n        let child = thread::spawn(move || {\n            let lock = m2.lock().unwrap();\n            assert_eq!(*lock.borrow(), 4950);\n        });\n        for i in 0..100 {\n            let lock = m.lock().unwrap();\n            *lock.borrow_mut() += i;\n        }\n        drop(lock);\n        child.join().unwrap();\n    }\n\n    #[test]\n    fn trylock_works() {\n        let m = Arc::new(ReentrantMutex::new(()));\n        let m2 = m.clone();\n        let _lock = m.try_lock().unwrap();\n        let _lock2 = m.try_lock().unwrap();\n        thread::spawn(move || {\n            let lock = m2.try_lock();\n            assert!(lock.is_err());\n        }).join().unwrap();\n        let _lock3 = m.try_lock().unwrap();\n    }\n\n    pub struct Answer<'a>(pub ReentrantMutexGuard<'a, RefCell<u32>>);\n    impl<'a> Drop for Answer<'a> {\n        fn drop(&mut self) {\n            *self.0.borrow_mut() = 42;\n        }\n    }\n\n    #[test]\n    fn poison_works() {\n        let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));\n        let mc = m.clone();\n        let result = thread::spawn(move ||{\n            let lock = mc.lock().unwrap();\n            *lock.borrow_mut() = 1;\n            let lock2 = mc.lock().unwrap();\n            *lock.borrow_mut() = 2;\n            let _answer = Answer(lock2);\n            panic!(\"What the answer to my lifetimes dilemma is?\");\n        }).join();\n        assert!(result.is_err());\n        let r = m.lock().err().unwrap().into_inner();\n        assert_eq!(*r.borrow(), 42);\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse error::{Error};\nuse fmt;\nuse sync::atomic::{AtomicBool, Ordering};\nuse thread;\n\npub struct Flag { failed: AtomicBool }\n\n// Note that the Ordering uses to access the `failed` field of `Flag` below is\n// always `Relaxed`, and that's because this isn't actually protecting any data,\n// it's just a flag whether we've panicked or not.\n//\n// The actual location that this matters is when a mutex is **locked** which is\n// where we have external synchronization ensuring that we see memory\n// reads/writes to this flag.\n//\n// As a result, if it matters, we should see the correct value for `failed` in\n// all cases.\n\nimpl Flag {\n    pub const fn new() -> Flag {\n        Flag { failed: AtomicBool::new(false) }\n    }\n\n    #[inline]\n    pub fn borrow(&self) -> LockResult<Guard> {\n        let ret = Guard { panicking: thread::panicking() };\n        if self.get() {\n            Err(PoisonError::new(ret))\n        } else {\n            Ok(ret)\n        }\n    }\n\n    #[inline]\n    pub fn done(&self, guard: &Guard) {\n        if !guard.panicking && thread::panicking() {\n            self.failed.store(true, Ordering::Relaxed);\n        }\n    }\n\n    #[inline]\n    pub fn get(&self) -> bool {\n        self.failed.load(Ordering::Relaxed)\n    }\n}\n\npub struct Guard {\n    panicking: bool,\n}\n\n/// A type of error which can be returned whenever a lock is acquired.\n///\n/// Both [`Mutex`]es and [`RwLock`]s are poisoned whenever a thread fails while the lock\n/// is held. The precise semantics for when a lock is poisoned is documented on\n/// each lock, but once a lock is poisoned then all future acquisitions will\n/// return this error.\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::{Arc, Mutex};\n/// use std::thread;\n///\n/// let mutex = Arc::new(Mutex::new(1));\n///\n/// // poison the mutex\n/// let c_mutex = mutex.clone();\n/// let _ = thread::spawn(move || {\n///     let mut data = c_mutex.lock().unwrap();\n///     *data = 2;\n///     panic!();\n/// }).join();\n///\n/// match mutex.lock() {\n///     Ok(_) => unreachable!(),\n///     Err(p_err) => {\n///         let data = p_err.get_ref();\n///         println!(\"recovered: {}\", data);\n///     }\n/// };\n/// ```\n///\n/// [`Mutex`]: ../../std/sync/struct.Mutex.html\n/// [`RwLock`]: ../../std/sync/struct.RwLock.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct PoisonError<T> {\n    guard: T,\n}\n\n/// An enumeration of possible errors associated with a [`TryLockResult`] which\n/// can occur while trying to acquire a lock, from the [`try_lock`] method on a\n/// [`Mutex`] or the [`try_read`] and [`try_write`] methods on an [`RwLock`].\n///\n/// [`Mutex`]: struct.Mutex.html\n/// [`RwLock`]: struct.RwLock.html\n/// [`TryLockResult`]: type.TryLockResult.html\n/// [`try_lock`]: struct.Mutex.html#method.try_lock\n/// [`try_read`]: struct.RwLock.html#method.try_read\n/// [`try_write`]: struct.RwLock.html#method.try_write\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum TryLockError<T> {\n    /// The lock could not be acquired because another thread failed while holding\n    /// the lock.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Poisoned(#[stable(feature = \"rust1\", since = \"1.0.0\")] PoisonError<T>),\n    /// The lock could not be acquired at this time because the operation would\n    /// otherwise block.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    WouldBlock,\n}\n\n/// A type alias for the result of a lock method which can be poisoned.\n///\n/// The [`Ok`] variant of this result indicates that the primitive was not\n/// poisoned, and the `Guard` is contained within. The [`Err`] variant indicates\n/// that the primitive was poisoned. Note that the [`Err`] variant *also* carries\n/// the associated guard, and it can be acquired through the [`into_inner`]\n/// method.\n///\n/// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n/// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n/// [`into_inner`]: ../../std/sync/struct.PoisonError.html#method.into_inner\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub type LockResult<Guard> = Result<Guard, PoisonError<Guard>>;\n\n/// A type alias for the result of a nonblocking locking method.\n///\n/// For more information, see [`LockResult`]. A `TryLockResult` doesn't\n/// necessarily hold the associated guard in the [`Err`] type as the lock may not\n/// have been acquired for other reasons.\n///\n/// [`LockResult`]: ../../std/sync/type.LockResult.html\n/// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> fmt::Debug for PoisonError<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        \"PoisonError { inner: .. }\".fmt(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> fmt::Display for PoisonError<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        \"poisoned lock: another task failed inside\".fmt(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Error for PoisonError<T> {\n    fn description(&self) -> &str {\n        \"poisoned lock: another task failed inside\"\n    }\n}\n\nimpl<T> PoisonError<T> {\n    /// Creates a `PoisonError`.\n    ///\n    /// This is generally created by methods like [`Mutex::lock`] or [`RwLock::read`].\n    ///\n    /// [`Mutex::lock`]: ../../std/sync/struct.Mutex.html#method.lock\n    /// [`RwLock::read`]: ../../std/sync/struct.RwLock.html#method.read\n    #[stable(feature = \"sync_poison\", since = \"1.2.0\")]\n    pub fn new(guard: T) -> PoisonError<T> {\n        PoisonError { guard }\n    }\n\n    /// Consumes this error indicating that a lock is poisoned, returning the\n    /// underlying guard to allow access regardless.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashSet;\n    /// use std::sync::{Arc, Mutex};\n    /// use std::thread;\n    ///\n    /// let mutex = Arc::new(Mutex::new(HashSet::new()));\n    ///\n    /// // poison the mutex\n    /// let c_mutex = mutex.clone();\n    /// let _ = thread::spawn(move || {\n    ///     let mut data = c_mutex.lock().unwrap();\n    ///     data.insert(10);\n    ///     panic!();\n    /// }).join();\n    ///\n    /// let p_err = mutex.lock().unwrap_err();\n    /// let data = p_err.into_inner();\n    /// println!(\"recovered {} items\", data.len());\n    /// ```\n    #[stable(feature = \"sync_poison\", since = \"1.2.0\")]\n    pub fn into_inner(self) -> T { self.guard }\n\n    /// Reaches into this error indicating that a lock is poisoned, returning a\n    /// reference to the underlying guard to allow access regardless.\n    #[stable(feature = \"sync_poison\", since = \"1.2.0\")]\n    pub fn get_ref(&self) -> &T { &self.guard }\n\n    /// Reaches into this error indicating that a lock is poisoned, returning a\n    /// mutable reference to the underlying guard to allow access regardless.\n    #[stable(feature = \"sync_poison\", since = \"1.2.0\")]\n    pub fn get_mut(&mut self) -> &mut T { &mut self.guard }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> From<PoisonError<T>> for TryLockError<T> {\n    fn from(err: PoisonError<T>) -> TryLockError<T> {\n        TryLockError::Poisoned(err)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> fmt::Debug for TryLockError<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            TryLockError::Poisoned(..) => \"Poisoned(..)\".fmt(f),\n            TryLockError::WouldBlock => \"WouldBlock\".fmt(f)\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> fmt::Display for TryLockError<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            TryLockError::Poisoned(..) => \"poisoned lock: another task failed inside\",\n            TryLockError::WouldBlock => \"try_lock failed because the operation would block\"\n        }.fmt(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T> Error for TryLockError<T> {\n    fn description(&self) -> &str {\n        match *self {\n            TryLockError::Poisoned(ref p) => p.description(),\n            TryLockError::WouldBlock => \"try_lock failed because the operation would block\"\n        }\n    }\n\n    fn cause(&self) -> Option<&dyn Error> {\n        match *self {\n            TryLockError::Poisoned(ref p) => Some(p),\n            _ => None\n        }\n    }\n}\n\npub fn map_result<T, U, F>(result: LockResult<T>, f: F)\n                           -> LockResult<U>\n                           where F: FnOnce(T) -> U {\n    match result {\n        Ok(t) => Ok(f(t)),\n        Err(PoisonError { guard }) => Err(PoisonError::new(f(guard)))\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse sys::mutex as imp;\n\n/// An OS-based mutual exclusion lock.\n///\n/// This is the thinnest cross-platform wrapper around OS mutexes. All usage of\n/// this mutex is unsafe and it is recommended to instead use the safe wrapper\n/// at the top level of the crate instead of this type.\npub struct Mutex(imp::Mutex);\n\nunsafe impl Sync for Mutex {}\n\nimpl Mutex {\n    /// Creates a new mutex for use.\n    ///\n    /// Behavior is undefined if the mutex is moved after it is\n    /// first used with any of the functions below.\n    /// Also, until `init` is called, behavior is undefined if this\n    /// mutex is ever used reentrantly, i.e., `raw_lock` or `try_lock`\n    /// are called by the thread currently holding the lock.\n    pub const fn new() -> Mutex { Mutex(imp::Mutex::new()) }\n\n    /// Prepare the mutex for use.\n    ///\n    /// This should be called once the mutex is at a stable memory address.\n    /// If called, this must be the very first thing that happens to the mutex.\n    /// Calling it in parallel with or after any operation (including another\n    /// `init()`) is undefined behavior.\n    #[inline]\n    pub unsafe fn init(&mut self) { self.0.init() }\n\n    /// Locks the mutex blocking the current thread until it is available.\n    ///\n    /// Behavior is undefined if the mutex has been moved between this and any\n    /// previous function call.\n    #[inline]\n    pub unsafe fn raw_lock(&self) { self.0.lock() }\n\n    /// Calls raw_lock() and then returns an RAII guard to guarantee the mutex\n    /// will be unlocked.\n    #[inline]\n    pub unsafe fn lock(&self) -> MutexGuard {\n        self.raw_lock();\n        MutexGuard(&self.0)\n    }\n\n    /// Attempts to lock the mutex without blocking, returning whether it was\n    /// successfully acquired or not.\n    ///\n    /// Behavior is undefined if the mutex has been moved between this and any\n    /// previous function call.\n    #[inline]\n    pub unsafe fn try_lock(&self) -> bool { self.0.try_lock() }\n\n    /// Unlocks the mutex.\n    ///\n    /// Behavior is undefined if the current thread does not actually hold the\n    /// mutex.\n    ///\n    /// Consider switching from the pair of raw_lock() and raw_unlock() to\n    /// lock() whenever possible.\n    #[inline]\n    pub unsafe fn raw_unlock(&self) { self.0.unlock() }\n\n    /// Deallocates all resources associated with this mutex.\n    ///\n    /// Behavior is undefined if there are current or will be future users of\n    /// this mutex.\n    #[inline]\n    pub unsafe fn destroy(&self) { self.0.destroy() }\n}\n\n// not meant to be exported to the outside world, just the containing module\npub fn raw(mutex: &Mutex) -> &imp::Mutex { &mutex.0 }\n\n#[must_use]\n/// A simple RAII utility for the above Mutex without the poisoning semantics.\npub struct MutexGuard<'a>(&'a imp::Mutex);\n\nimpl<'a> Drop for MutexGuard<'a> {\n    #[inline]\n    fn drop(&mut self) {\n        unsafe { self.0.unlock(); }\n    }\n}\n","// Copyright 2013 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Implementation of running at_exit routines\n//!\n//! Documentation can be found on the `rt::at_exit` function.\n\nuse boxed::FnBox;\nuse ptr;\nuse mem;\nuse sys_common::mutex::Mutex;\n\ntype Queue = Vec<Box<dyn FnBox()>>;\n\n// NB these are specifically not types from `std::sync` as they currently rely\n// on poisoning and this module needs to operate at a lower level than requiring\n// the thread infrastructure to be in place (useful on the borders of\n// initialization/destruction).\n// We never call `LOCK.init()`, so it is UB to attempt to\n// acquire this mutex reentrantly!\nstatic LOCK: Mutex = Mutex::new();\nstatic mut QUEUE: *mut Queue = ptr::null_mut();\n\nconst DONE: *mut Queue = 1_usize as *mut _;\n\n// The maximum number of times the cleanup routines will be run. While running\n// the at_exit closures new ones may be registered, and this count is the number\n// of times the new closures will be allowed to register successfully. After\n// this number of iterations all new registrations will return `false`.\nconst ITERS: usize = 10;\n\nunsafe fn init() -> bool {\n    if QUEUE.is_null() {\n        let state: Box<Queue> = box Vec::new();\n        QUEUE = Box::into_raw(state);\n    } else if QUEUE == DONE {\n        // can't re-init after a cleanup\n        return false\n    }\n\n    true\n}\n\npub fn cleanup() {\n    for i in 1..=ITERS {\n        unsafe {\n            let queue = {\n                let _guard = LOCK.lock();\n                mem::replace(&mut QUEUE, if i == ITERS { DONE } else { ptr::null_mut() })\n            };\n\n            // make sure we're not recursively cleaning up\n            assert!(queue != DONE);\n\n            // If we never called init, not need to cleanup!\n            if !queue.is_null() {\n                let queue: Box<Queue> = Box::from_raw(queue);\n                for to_run in *queue {\n                    // We are not holding any lock, so reentrancy is fine.\n                    to_run();\n                }\n            }\n        }\n    }\n}\n\npub fn push(f: Box<dyn FnBox()>) -> bool {\n    unsafe {\n        let _guard = LOCK.lock();\n        if init() {\n            // We are just moving `f` around, not calling it.\n            // There is no possibility of reentrancy here.\n            (*QUEUE).push(f);\n            true\n        } else {\n            false\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// Common code for printing the backtrace in the same way across the different\n/// supported platforms.\n\nuse env;\nuse io::prelude::*;\nuse io;\nuse str;\nuse sync::atomic::{self, Ordering};\nuse path::{self, Path};\nuse sys::mutex::Mutex;\nuse ptr;\n\npub use sys::backtrace::{\n    unwind_backtrace,\n    resolve_symname,\n    foreach_symbol_fileline,\n    BacktraceContext\n};\n\n#[cfg(target_pointer_width = \"64\")]\npub const HEX_WIDTH: usize = 18;\n\n#[cfg(target_pointer_width = \"32\")]\npub const HEX_WIDTH: usize = 10;\n\n/// Represents an item in the backtrace list. See `unwind_backtrace` for how\n/// it is created.\n#[derive(Debug, Copy, Clone)]\npub struct Frame {\n    /// Exact address of the call that failed.\n    pub exact_position: *const u8,\n    /// Address of the enclosing function.\n    pub symbol_addr: *const u8,\n    /// Which inlined function is this frame referring to\n    pub inline_context: u32,\n}\n\n/// Max number of frames to print.\nconst MAX_NB_FRAMES: usize = 100;\n\n/// Prints the current backtrace.\npub fn print(w: &mut dyn Write, format: PrintFormat) -> io::Result<()> {\n    static LOCK: Mutex = Mutex::new();\n\n    // Use a lock to prevent mixed output in multithreading context.\n    // Some platforms also requires it, like `SymFromAddr` on Windows.\n    unsafe {\n        LOCK.lock();\n        let res = _print(w, format);\n        LOCK.unlock();\n        res\n    }\n}\n\nfn _print(w: &mut dyn Write, format: PrintFormat) -> io::Result<()> {\n    let mut frames = [Frame {\n        exact_position: ptr::null(),\n        symbol_addr: ptr::null(),\n        inline_context: 0,\n    }; MAX_NB_FRAMES];\n    let (nb_frames, context) = unwind_backtrace(&mut frames)?;\n    let (skipped_before, skipped_after) =\n        filter_frames(&frames[..nb_frames], format, &context);\n    if skipped_before + skipped_after > 0 {\n        writeln!(w, \"note: Some details are omitted, \\\n                     run with `RUST_BACKTRACE=full` for a verbose backtrace.\")?;\n    }\n    writeln!(w, \"stack backtrace:\")?;\n\n    let filtered_frames = &frames[..nb_frames - skipped_after];\n    for (index, frame) in filtered_frames.iter().skip(skipped_before).enumerate() {\n        resolve_symname(*frame, |symname| {\n            output(w, index, *frame, symname, format)\n        }, &context)?;\n        let has_more_filenames = foreach_symbol_fileline(*frame, |file, line| {\n            output_fileline(w, file, line, format)\n        }, &context)?;\n        if has_more_filenames {\n            w.write_all(b\" <... and possibly more>\")?;\n        }\n    }\n\n    Ok(())\n}\n\n/// Returns a number of frames to remove at the beginning and at the end of the\n/// backtrace, according to the backtrace format.\nfn filter_frames(frames: &[Frame],\n                 format: PrintFormat,\n                 context: &BacktraceContext) -> (usize, usize)\n{\n    if format == PrintFormat::Full {\n        return (0, 0);\n    }\n\n    let skipped_before = 0;\n\n    let skipped_after = frames.len() - frames.iter().position(|frame| {\n        let mut is_marker = false;\n        let _ = resolve_symname(*frame, |symname| {\n            if let Some(mangled_symbol_name) = symname {\n                // Use grep to find the concerned functions\n                if mangled_symbol_name.contains(\"__rust_begin_short_backtrace\") {\n                    is_marker = true;\n                }\n            }\n            Ok(())\n        }, context);\n        is_marker\n    }).unwrap_or(frames.len());\n\n    if skipped_before + skipped_after >= frames.len() {\n        // Avoid showing completely empty backtraces\n        return (0, 0);\n    }\n\n    (skipped_before, skipped_after)\n}\n\n\n/// Fixed frame used to clean the backtrace with `RUST_BACKTRACE=1`.\n#[inline(never)]\npub fn __rust_begin_short_backtrace<F, T>(f: F) -> T\n    where F: FnOnce() -> T, F: Send, T: Send\n{\n    f()\n}\n\n/// Controls how the backtrace should be formatted.\n#[derive(Debug, Copy, Clone, Eq, PartialEq)]\npub enum PrintFormat {\n    /// Show only relevant data from the backtrace.\n    Short = 2,\n    /// Show all the frames with absolute path for files.\n    Full = 3,\n}\n\n// For now logging is turned off by default, and this function checks to see\n// whether the magical environment variable is present to see if it's turned on.\npub fn log_enabled() -> Option<PrintFormat> {\n    static ENABLED: atomic::AtomicIsize = atomic::AtomicIsize::new(0);\n    match ENABLED.load(Ordering::SeqCst) {\n        0 => {}\n        1 => return None,\n        2 => return Some(PrintFormat::Short),\n        _ => return Some(PrintFormat::Full),\n    }\n\n    let val = env::var_os(\"RUST_BACKTRACE\").and_then(|x|\n        if &x == \"0\" {\n            None\n        } else if &x == \"full\" {\n            Some(PrintFormat::Full)\n        } else {\n            Some(PrintFormat::Short)\n        }\n    );\n    ENABLED.store(match val {\n        Some(v) => v as isize,\n        None => 1,\n    }, Ordering::SeqCst);\n    val\n}\n\n/// Print the symbol of the backtrace frame.\n///\n/// These output functions should now be used everywhere to ensure consistency.\n/// You may want to also use `output_fileline`.\nfn output(w: &mut dyn Write, idx: usize, frame: Frame,\n              s: Option<&str>, format: PrintFormat) -> io::Result<()> {\n    // Remove the `17: 0x0 - <unknown>` line.\n    if format == PrintFormat::Short && frame.exact_position == ptr::null() {\n        return Ok(());\n    }\n    match format {\n        PrintFormat::Full => write!(w,\n                                    \"  {:2}: {:2$?} - \",\n                                    idx,\n                                    frame.exact_position,\n                                    HEX_WIDTH)?,\n        PrintFormat::Short => write!(w, \"  {:2}: \", idx)?,\n    }\n    match s {\n        Some(string) => demangle(w, string, format)?,\n        None => w.write_all(b\"<unknown>\")?,\n    }\n    w.write_all(b\"\\n\")\n}\n\n/// Print the filename and line number of the backtrace frame.\n///\n/// See also `output`.\n#[allow(dead_code)]\nfn output_fileline(w: &mut dyn Write,\n                   file: &[u8],\n                   line: u32,\n                   format: PrintFormat) -> io::Result<()> {\n    // prior line: \"  ##: {:2$} - func\"\n    w.write_all(b\"\")?;\n    match format {\n        PrintFormat::Full => write!(w,\n                                    \"           {:1$}\",\n                                    \"\",\n                                    HEX_WIDTH)?,\n        PrintFormat::Short => write!(w, \"           \")?,\n    }\n\n    let file = str::from_utf8(file).unwrap_or(\"<unknown>\");\n    let file_path = Path::new(file);\n    let mut already_printed = false;\n    if format == PrintFormat::Short && file_path.is_absolute() {\n        if let Ok(cwd) = env::current_dir() {\n            if let Ok(stripped) = file_path.strip_prefix(&cwd) {\n                if let Some(s) = stripped.to_str() {\n                    write!(w, \"  at .{}{}:{}\", path::MAIN_SEPARATOR, s, line)?;\n                    already_printed = true;\n                }\n            }\n        }\n    }\n    if !already_printed {\n        write!(w, \"  at {}:{}\", file, line)?;\n    }\n\n    w.write_all(b\"\\n\")\n}\n\n\n// All rust symbols are in theory lists of \"::\"-separated identifiers. Some\n// assemblers, however, can't handle these characters in symbol names. To get\n// around this, we use C++-style mangling. The mangling method is:\n//\n// 1. Prefix the symbol with \"_ZN\"\n// 2. For each element of the path, emit the length plus the element\n// 3. End the path with \"E\"\n//\n// For example, \"_ZN4testE\" => \"test\" and \"_ZN3foo3barE\" => \"foo::bar\".\n//\n// We're the ones printing our backtraces, so we can't rely on anything else to\n// demangle our symbols. It's *much* nicer to look at demangled symbols, so\n// this function is implemented to give us nice pretty output.\n//\n// Note that this demangler isn't quite as fancy as it could be. We have lots\n// of other information in our symbols like hashes, version, type information,\n// etc. Additionally, this doesn't handle glue symbols at all.\npub fn demangle(writer: &mut dyn Write, mut s: &str, format: PrintFormat) -> io::Result<()> {\n    // During ThinLTO LLVM may import and rename internal symbols, so strip out\n    // those endings first as they're one of the last manglings applied to\n    // symbol names.\n    let llvm = \".llvm.\";\n    if let Some(i) = s.find(llvm) {\n        let candidate = &s[i + llvm.len()..];\n        let all_hex = candidate.chars().all(|c| {\n            match c {\n                'A' ..= 'F' | '0' ..= '9' => true,\n                _ => false,\n            }\n        });\n\n        if all_hex {\n            s = &s[..i];\n        }\n    }\n\n    // Validate the symbol. If it doesn't look like anything we're\n    // expecting, we just print it literally. Note that we must handle non-rust\n    // symbols because we could have any function in the backtrace.\n    let mut valid = true;\n    let mut inner = s;\n    if s.len() > 4 && s.starts_with(\"_ZN\") && s.ends_with(\"E\") {\n        inner = &s[3 .. s.len() - 1];\n    // On Windows, dbghelp strips leading underscores, so we accept \"ZN...E\" form too.\n    } else if s.len() > 3 && s.starts_with(\"ZN\") && s.ends_with(\"E\") {\n        inner = &s[2 .. s.len() - 1];\n    } else {\n        valid = false;\n    }\n\n    if valid {\n        let mut chars = inner.chars();\n        while valid {\n            let mut i = 0;\n            for c in chars.by_ref() {\n                if c.is_numeric() {\n                    i = i * 10 + c as usize - '0' as usize;\n                } else {\n                    break\n                }\n            }\n            if i == 0 {\n                valid = chars.next().is_none();\n                break\n            } else if chars.by_ref().take(i - 1).count() != i - 1 {\n                valid = false;\n            }\n        }\n    }\n\n    // Alright, let's do this.\n    if !valid {\n        writer.write_all(s.as_bytes())?;\n    } else {\n        // remove the `::hfc2edb670e5eda97` part at the end of the symbol.\n        if format == PrintFormat::Short {\n            // The symbol in still mangled.\n            let mut split = inner.rsplitn(2, \"17h\");\n            match (split.next(), split.next()) {\n                (Some(addr), rest) => {\n                    if addr.len() == 16 &&\n                       addr.chars().all(|c| c.is_digit(16))\n                    {\n                        inner = rest.unwrap_or(\"\");\n                    }\n                }\n                _ => (),\n            }\n        }\n\n        let mut first = true;\n        while !inner.is_empty() {\n            if !first {\n                writer.write_all(b\"::\")?;\n            } else {\n                first = false;\n            }\n            let mut rest = inner;\n            while rest.chars().next().unwrap().is_numeric() {\n                rest = &rest[1..];\n            }\n            let i: usize = inner[.. (inner.len() - rest.len())].parse().unwrap();\n            inner = &rest[i..];\n            rest = &rest[..i];\n            if rest.starts_with(\"_$\") {\n                rest = &rest[1..];\n            }\n            while !rest.is_empty() {\n                if rest.starts_with(\".\") {\n                    if let Some('.') = rest[1..].chars().next() {\n                        writer.write_all(b\"::\")?;\n                        rest = &rest[2..];\n                    } else {\n                        writer.write_all(b\".\")?;\n                        rest = &rest[1..];\n                    }\n                } else if rest.starts_with(\"$\") {\n                    macro_rules! demangle {\n                        ($($pat:expr => $demangled:expr),*) => ({\n                            $(if rest.starts_with($pat) {\n                                writer.write_all($demangled)?;\n                                rest = &rest[$pat.len()..];\n                              } else)*\n                            {\n                                writer.write_all(rest.as_bytes())?;\n                                break;\n                            }\n\n                        })\n                    }\n\n                    // see src/librustc/back/link.rs for these mappings\n                    demangle! (\n                        \"$SP$\" => b\"@\",\n                        \"$BP$\" => b\"*\",\n                        \"$RF$\" => b\"&\",\n                        \"$LT$\" => b\"<\",\n                        \"$GT$\" => b\">\",\n                        \"$LP$\" => b\"(\",\n                        \"$RP$\" => b\")\",\n                        \"$C$\" => b\",\",\n\n                        // in theory we can demangle any Unicode code point, but\n                        // for simplicity we just catch the common ones.\n                        \"$u7e$\" => b\"~\",\n                        \"$u20$\" => b\" \",\n                        \"$u27$\" => b\"'\",\n                        \"$u5b$\" => b\"[\",\n                        \"$u5d$\" => b\"]\",\n                        \"$u7b$\" => b\"{\",\n                        \"$u7d$\" => b\"}\",\n                        \"$u3b$\" => b\";\",\n                        \"$u2b$\" => b\"+\",\n                        \"$u22$\" => b\"\\\"\"\n                    )\n                } else {\n                    let idx = match rest.char_indices().find(|&(_, c)| c == '$' || c == '.') {\n                        None => rest.len(),\n                        Some((i, _)) => i,\n                    };\n                    writer.write_all(rest[..idx].as_bytes())?;\n                    rest = &rest[idx..];\n                }\n            }\n        }\n    }\n\n    Ok(())\n}\n\n#[cfg(test)]\nmod tests {\n    use sys_common;\n    macro_rules! t { ($a:expr, $b:expr) => ({\n        let mut m = Vec::new();\n        sys_common::backtrace::demangle(&mut m,\n                                        $a,\n                                        super::PrintFormat::Full).unwrap();\n        assert_eq!(String::from_utf8(m).unwrap(), $b);\n    }) }\n\n    #[test]\n    fn demangle() {\n        t!(\"test\", \"test\");\n        t!(\"_ZN4testE\", \"test\");\n        t!(\"_ZN4test\", \"_ZN4test\");\n        t!(\"_ZN4test1a2bcE\", \"test::a::bc\");\n    }\n\n    #[test]\n    fn demangle_dollars() {\n        t!(\"_ZN4$RP$E\", \")\");\n        t!(\"_ZN8$RF$testE\", \"&test\");\n        t!(\"_ZN8$BP$test4foobE\", \"*test::foob\");\n        t!(\"_ZN9$u20$test4foobE\", \" test::foob\");\n        t!(\"_ZN35Bar$LT$$u5b$u32$u3b$$u20$4$u5d$$GT$E\", \"Bar<[u32; 4]>\");\n    }\n\n    #[test]\n    fn demangle_many_dollars() {\n        t!(\"_ZN13test$u20$test4foobE\", \"test test::foob\");\n        t!(\"_ZN12test$BP$test4foobE\", \"test*test::foob\");\n    }\n\n    #[test]\n    fn demangle_windows() {\n        t!(\"ZN4testE\", \"test\");\n        t!(\"ZN13test$u20$test4foobE\", \"test test::foob\");\n        t!(\"ZN12test$RF$test4foobE\", \"test&test::foob\");\n    }\n\n    #[test]\n    fn demangle_elements_beginning_with_underscore() {\n        t!(\"_ZN13_$LT$test$GT$E\", \"<test>\");\n        t!(\"_ZN28_$u7b$$u7b$closure$u7d$$u7d$E\", \"{{closure}}\");\n        t!(\"_ZN15__STATIC_FMTSTRE\", \"__STATIC_FMTSTR\");\n    }\n\n    #[test]\n    fn demangle_trait_impls() {\n        t!(\"_ZN71_$LT$Test$u20$$u2b$$u20$$u27$static$u20$as$u20$foo..Bar$LT$Test$GT$$GT$3barE\",\n           \"<Test + 'static as foo::Bar<Test>>::bar\");\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse boxed::FnBox;\nuse env;\nuse sync::atomic::{self, Ordering};\nuse sys::stack_overflow;\nuse sys::thread as imp;\n\n#[allow(dead_code)]\npub unsafe fn start_thread(main: *mut u8) {\n    // Next, set up our stack overflow handler which may get triggered if we run\n    // out of stack.\n    let _handler = stack_overflow::Handler::new();\n\n    // Finally, let's run some code.\n    Box::from_raw(main as *mut Box<dyn FnBox()>)()\n}\n\npub fn min_stack() -> usize {\n    static MIN: atomic::AtomicUsize = atomic::AtomicUsize::new(0);\n    match MIN.load(Ordering::SeqCst) {\n        0 => {}\n        n => return n - 1,\n    }\n    let amt = env::var(\"RUST_MIN_STACK\").ok().and_then(|s| s.parse().ok());\n    let amt = amt.unwrap_or(imp::DEFAULT_MIN_STACK_SIZE);\n\n    // 0 is our sentinel value, so ensure that we'll never see 0 after\n    // initialization has run\n    MIN.store(amt + 1, Ordering::SeqCst);\n    amt\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! OS-based thread local storage\n//!\n//! This module provides an implementation of OS-based thread local storage,\n//! using the native OS-provided facilities (think `TlsAlloc` or\n//! `pthread_setspecific`). The interface of this differs from the other types\n//! of thread-local-storage provided in this crate in that OS-based TLS can only\n//! get/set pointers,\n//!\n//! This module also provides two flavors of TLS. One is intended for static\n//! initialization, and does not contain a `Drop` implementation to deallocate\n//! the OS-TLS key. The other is a type which does implement `Drop` and hence\n//! has a safe interface.\n//!\n//! # Usage\n//!\n//! This module should likely not be used directly unless other primitives are\n//! being built on. types such as `thread_local::spawn::Key` are likely much\n//! more useful in practice than this OS-based version which likely requires\n//! unsafe code to interoperate with.\n//!\n//! # Examples\n//!\n//! Using a dynamically allocated TLS key. Note that this key can be shared\n//! among many threads via an `Arc`.\n//!\n//! ```ignore (cannot-doctest-private-modules)\n//! let key = Key::new(None);\n//! assert!(key.get().is_null());\n//! key.set(1 as *mut u8);\n//! assert!(!key.get().is_null());\n//!\n//! drop(key); // deallocate this TLS slot.\n//! ```\n//!\n//! Sometimes a statically allocated key is either required or easier to work\n//! with, however.\n//!\n//! ```ignore (cannot-doctest-private-modules)\n//! static KEY: StaticKey = INIT;\n//!\n//! unsafe {\n//!     assert!(KEY.get().is_null());\n//!     KEY.set(1 as *mut u8);\n//! }\n//! ```\n\n#![allow(non_camel_case_types)]\n#![unstable(feature = \"thread_local_internals\", issue = \"0\")]\n#![allow(dead_code)] // sys isn't exported yet\n\nuse ptr;\nuse sync::atomic::{self, AtomicUsize, Ordering};\nuse sys::thread_local as imp;\nuse sys_common::mutex::Mutex;\n\n/// A type for TLS keys that are statically allocated.\n///\n/// This type is entirely `unsafe` to use as it does not protect against\n/// use-after-deallocation or use-during-deallocation.\n///\n/// The actual OS-TLS key is lazily allocated when this is used for the first\n/// time. The key is also deallocated when the Rust runtime exits or `destroy`\n/// is called, whichever comes first.\n///\n/// # Examples\n///\n/// ```ignore (cannot-doctest-private-modules)\n/// use tls::os::{StaticKey, INIT};\n///\n/// static KEY: StaticKey = INIT;\n///\n/// unsafe {\n///     assert!(KEY.get().is_null());\n///     KEY.set(1 as *mut u8);\n/// }\n/// ```\npub struct StaticKey {\n    /// Inner static TLS key (internals).\n    key: AtomicUsize,\n    /// Destructor for the TLS value.\n    ///\n    /// See `Key::new` for information about when the destructor runs and how\n    /// it runs.\n    dtor: Option<unsafe extern fn(*mut u8)>,\n}\n\n/// A type for a safely managed OS-based TLS slot.\n///\n/// This type allocates an OS TLS key when it is initialized and will deallocate\n/// the key when it falls out of scope. When compared with `StaticKey`, this\n/// type is entirely safe to use.\n///\n/// Implementations will likely, however, contain unsafe code as this type only\n/// operates on `*mut u8`, a raw pointer.\n///\n/// # Examples\n///\n/// ```ignore (cannot-doctest-private-modules)\n/// use tls::os::Key;\n///\n/// let key = Key::new(None);\n/// assert!(key.get().is_null());\n/// key.set(1 as *mut u8);\n/// assert!(!key.get().is_null());\n///\n/// drop(key); // deallocate this TLS slot.\n/// ```\npub struct Key {\n    key: imp::Key,\n}\n\n/// Constant initialization value for static TLS keys.\n///\n/// This value specifies no destructor by default.\npub const INIT: StaticKey = StaticKey::new(None);\n\nimpl StaticKey {\n    pub const fn new(dtor: Option<unsafe extern fn(*mut u8)>) -> StaticKey {\n        StaticKey {\n            key: atomic::AtomicUsize::new(0),\n            dtor,\n        }\n    }\n\n    /// Gets the value associated with this TLS key\n    ///\n    /// This will lazily allocate a TLS key from the OS if one has not already\n    /// been allocated.\n    #[inline]\n    pub unsafe fn get(&self) -> *mut u8 { imp::get(self.key()) }\n\n    /// Sets this TLS key to a new value.\n    ///\n    /// This will lazily allocate a TLS key from the OS if one has not already\n    /// been allocated.\n    #[inline]\n    pub unsafe fn set(&self, val: *mut u8) { imp::set(self.key(), val) }\n\n    #[inline]\n    unsafe fn key(&self) -> imp::Key {\n        match self.key.load(Ordering::Relaxed) {\n            0 => self.lazy_init() as imp::Key,\n            n => n as imp::Key\n        }\n    }\n\n    unsafe fn lazy_init(&self) -> usize {\n        // Currently the Windows implementation of TLS is pretty hairy, and\n        // it greatly simplifies creation if we just synchronize everything.\n        //\n        // Additionally a 0-index of a tls key hasn't been seen on windows, so\n        // we just simplify the whole branch.\n        if imp::requires_synchronized_create() {\n            // We never call `INIT_LOCK.init()`, so it is UB to attempt to\n            // acquire this mutex reentrantly!\n            static INIT_LOCK: Mutex = Mutex::new();\n            let _guard = INIT_LOCK.lock();\n            let mut key = self.key.load(Ordering::SeqCst);\n            if key == 0 {\n                key = imp::create(self.dtor) as usize;\n                self.key.store(key, Ordering::SeqCst);\n            }\n            rtassert!(key != 0);\n            return key\n        }\n\n        // POSIX allows the key created here to be 0, but the compare_and_swap\n        // below relies on using 0 as a sentinel value to check who won the\n        // race to set the shared TLS key. As far as I know, there is no\n        // guaranteed value that cannot be returned as a posix_key_create key,\n        // so there is no value we can initialize the inner key with to\n        // prove that it has not yet been set. As such, we'll continue using a\n        // value of 0, but with some gyrations to make sure we have a non-0\n        // value returned from the creation routine.\n        // FIXME: this is clearly a hack, and should be cleaned up.\n        let key1 = imp::create(self.dtor);\n        let key = if key1 != 0 {\n            key1\n        } else {\n            let key2 = imp::create(self.dtor);\n            imp::destroy(key1);\n            key2\n        };\n        rtassert!(key != 0);\n        match self.key.compare_and_swap(0, key as usize, Ordering::SeqCst) {\n            // The CAS succeeded, so we've created the actual key\n            0 => key as usize,\n            // If someone beat us to the punch, use their key instead\n            n => { imp::destroy(key); n }\n        }\n    }\n}\n\nimpl Key {\n    /// Creates a new managed OS TLS key.\n    ///\n    /// This key will be deallocated when the key falls out of scope.\n    ///\n    /// The argument provided is an optionally-specified destructor for the\n    /// value of this TLS key. When a thread exits and the value for this key\n    /// is non-null the destructor will be invoked. The TLS value will be reset\n    /// to null before the destructor is invoked.\n    ///\n    /// Note that the destructor will not be run when the `Key` goes out of\n    /// scope.\n    #[inline]\n    pub fn new(dtor: Option<unsafe extern fn(*mut u8)>) -> Key {\n        Key { key: unsafe { imp::create(dtor) } }\n    }\n\n    /// See StaticKey::get\n    #[inline]\n    pub fn get(&self) -> *mut u8 {\n        unsafe { imp::get(self.key) }\n    }\n\n    /// See StaticKey::set\n    #[inline]\n    pub fn set(&self, val: *mut u8) {\n        unsafe { imp::set(self.key, val) }\n    }\n}\n\nimpl Drop for Key {\n    fn drop(&mut self) {\n        // Right now Windows doesn't support TLS key destruction, but this also\n        // isn't used anywhere other than tests, so just leak the TLS key.\n        // unsafe { imp::destroy(self.key) }\n    }\n}\n\npub unsafe fn register_dtor_fallback(t: *mut u8,\n                                     dtor: unsafe extern fn(*mut u8)) {\n    // The fallback implementation uses a vanilla OS-based TLS key to track\n    // the list of destructors that need to be run for this thread. The key\n    // then has its own destructor which runs all the other destructors.\n    //\n    // The destructor for DTORS is a little special in that it has a `while`\n    // loop to continuously drain the list of registered destructors. It\n    // *should* be the case that this loop always terminates because we\n    // provide the guarantee that a TLS key cannot be set after it is\n    // flagged for destruction.\n\n    static DTORS: StaticKey = StaticKey::new(Some(run_dtors));\n    type List = Vec<(*mut u8, unsafe extern fn(*mut u8))>;\n    if DTORS.get().is_null() {\n        let v: Box<List> = box Vec::new();\n        DTORS.set(Box::into_raw(v) as *mut u8);\n    }\n    let list: &mut List = &mut *(DTORS.get() as *mut List);\n    list.push((t, dtor));\n\n    unsafe extern fn run_dtors(mut ptr: *mut u8) {\n        while !ptr.is_null() {\n            let list: Box<List> = Box::from_raw(ptr as *mut List);\n            for (ptr, dtor) in list.into_iter() {\n                dtor(ptr);\n            }\n            ptr = DTORS.get();\n            DTORS.set(ptr::null_mut());\n        }\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::{Key, StaticKey};\n\n    fn assert_sync<T: Sync>() {}\n    fn assert_send<T: Send>() {}\n\n    #[test]\n    fn smoke() {\n        assert_sync::<Key>();\n        assert_send::<Key>();\n\n        let k1 = Key::new(None);\n        let k2 = Key::new(None);\n        assert!(k1.get().is_null());\n        assert!(k2.get().is_null());\n        k1.set(1 as *mut _);\n        k2.set(2 as *mut _);\n        assert_eq!(k1.get() as usize, 1);\n        assert_eq!(k2.get() as usize, 2);\n    }\n\n    #[test]\n    fn statik() {\n        static K1: StaticKey = StaticKey::new(None);\n        static K2: StaticKey = StaticKey::new(None);\n\n        unsafe {\n            assert!(K1.get().is_null());\n            assert!(K2.get().is_null());\n            K1.set(1 as *mut _);\n            K2.set(2 as *mut _);\n            assert_eq!(K1.get() as usize, 1);\n            assert_eq!(K2.get() as usize, 2);\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Platform-independent platform abstraction\n//!\n//! This is the platform-independent portion of the standard library's\n//! platform abstraction layer, whereas `std::sys` is the\n//! platform-specific portion.\n//!\n//! The relationship between `std::sys_common`, `std::sys` and the\n//! rest of `std` is complex, with dependencies going in all\n//! directions: `std` depending on `sys_common`, `sys_common`\n//! depending on `sys`, and `sys` depending on `sys_common` and `std`.\n//! Ideally `sys_common` would be split into two and the dependencies\n//! between them all would form a dag, facilitating the extraction of\n//! `std::sys` from the standard library.\n\n#![allow(missing_docs)]\n#![allow(missing_debug_implementations)]\n\nuse sync::Once;\nuse sys;\n\nmacro_rules! rtabort {\n    ($($t:tt)*) => (::sys_common::util::abort(format_args!($($t)*)))\n}\n\nmacro_rules! rtassert {\n    ($e:expr) => (if !$e {\n        rtabort!(concat!(\"assertion failed: \", stringify!($e)));\n    })\n}\n\npub mod at_exit_imp;\n#[cfg(feature = \"backtrace\")]\npub mod backtrace;\npub mod condvar;\npub mod io;\npub mod mutex;\npub mod poison;\npub mod remutex;\npub mod rwlock;\npub mod thread;\npub mod thread_info;\npub mod thread_local;\npub mod util;\npub mod wtf8;\npub mod bytestring;\npub mod process;\n\ncfg_if! {\n    if #[cfg(any(target_os = \"cloudabi\", target_os = \"l4re\", target_os = \"redox\"))] {\n        pub use sys::net;\n    } else if #[cfg(all(target_arch = \"wasm32\", not(target_os = \"emscripten\")))] {\n        pub use sys::net;\n    } else {\n        pub mod net;\n    }\n}\n\n#[cfg(feature = \"backtrace\")]\n#[cfg(any(all(unix, not(target_os = \"emscripten\")),\n          all(windows, target_env = \"gnu\"),\n          target_os = \"redox\"))]\npub mod gnu;\n\n// common error constructors\n\n/// A trait for viewing representations from std types\n#[doc(hidden)]\npub trait AsInner<Inner: ?Sized> {\n    fn as_inner(&self) -> &Inner;\n}\n\n/// A trait for viewing representations from std types\n#[doc(hidden)]\npub trait AsInnerMut<Inner: ?Sized> {\n    fn as_inner_mut(&mut self) -> &mut Inner;\n}\n\n/// A trait for extracting representations from std types\n#[doc(hidden)]\npub trait IntoInner<Inner> {\n    fn into_inner(self) -> Inner;\n}\n\n/// A trait for creating std types from internal representations\n#[doc(hidden)]\npub trait FromInner<Inner> {\n    fn from_inner(inner: Inner) -> Self;\n}\n\n/// Enqueues a procedure to run when the main thread exits.\n///\n/// Currently these closures are only run once the main *Rust* thread exits.\n/// Once the `at_exit` handlers begin running, more may be enqueued, but not\n/// infinitely so. Eventually a handler registration will be forced to fail.\n///\n/// Returns `Ok` if the handler was successfully registered, meaning that the\n/// closure will be run once the main thread exits. Returns `Err` to indicate\n/// that the closure could not be registered, meaning that it is not scheduled\n/// to be run.\npub fn at_exit<F: FnOnce() + Send + 'static>(f: F) -> Result<(), ()> {\n    if at_exit_imp::push(Box::new(f)) {Ok(())} else {Err(())}\n}\n\n/// One-time runtime cleanup.\npub fn cleanup() {\n    static CLEANUP: Once = Once::new();\n    CLEANUP.call_once(|| unsafe {\n        sys::args::cleanup();\n        sys::stack_overflow::cleanup();\n        at_exit_imp::cleanup();\n    });\n}\n\n// Computes (value*numer)/denom without overflow, as long as both\n// (numer*denom) and the overall result fit into i64 (which is the case\n// for our time conversions).\n#[allow(dead_code)] // not used on all platforms\npub fn mul_div_u64(value: u64, numer: u64, denom: u64) -> u64 {\n    let q = value / denom;\n    let r = value % denom;\n    // Decompose value as (value/denom*denom + value%denom),\n    // substitute into (value*numer)/denom and simplify.\n    // r < denom, so (denom*numer) is the upper bound of (r*numer)\n    q * numer + r * numer / denom\n}\n\n#[test]\nfn test_muldiv() {\n    assert_eq!(mul_div_u64( 1_000_000_000_001, 1_000_000_000, 1_000_000),\n               1_000_000_000_001_000);\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse sys::rwlock as imp;\n\n/// An OS-based reader-writer lock.\n///\n/// This structure is entirely unsafe and serves as the lowest layer of a\n/// cross-platform binding of system rwlocks. It is recommended to use the\n/// safer types at the top level of this crate instead of this type.\npub struct RWLock(imp::RWLock);\n\nimpl RWLock {\n    /// Creates a new reader-writer lock for use.\n    ///\n    /// Behavior is undefined if the reader-writer lock is moved after it is\n    /// first used with any of the functions below.\n    pub const fn new() -> RWLock { RWLock(imp::RWLock::new()) }\n\n    /// Acquires shared access to the underlying lock, blocking the current\n    /// thread to do so.\n    ///\n    /// Behavior is undefined if the rwlock has been moved between this and any\n    /// previous method call.\n    #[inline]\n    pub unsafe fn read(&self) { self.0.read() }\n\n    /// Attempts to acquire shared access to this lock, returning whether it\n    /// succeeded or not.\n    ///\n    /// This function does not block the current thread.\n    ///\n    /// Behavior is undefined if the rwlock has been moved between this and any\n    /// previous method call.\n    #[inline]\n    pub unsafe fn try_read(&self) -> bool { self.0.try_read() }\n\n    /// Acquires write access to the underlying lock, blocking the current thread\n    /// to do so.\n    ///\n    /// Behavior is undefined if the rwlock has been moved between this and any\n    /// previous method call.\n    #[inline]\n    pub unsafe fn write(&self) { self.0.write() }\n\n    /// Attempts to acquire exclusive access to this lock, returning whether it\n    /// succeeded or not.\n    ///\n    /// This function does not block the current thread.\n    ///\n    /// Behavior is undefined if the rwlock has been moved between this and any\n    /// previous method call.\n    #[inline]\n    pub unsafe fn try_write(&self) -> bool { self.0.try_write() }\n\n    /// Unlocks previously acquired shared access to this lock.\n    ///\n    /// Behavior is undefined if the current thread does not have shared access.\n    #[inline]\n    pub unsafe fn read_unlock(&self) { self.0.read_unlock() }\n\n    /// Unlocks previously acquired exclusive access to this lock.\n    ///\n    /// Behavior is undefined if the current thread does not currently have\n    /// exclusive access.\n    #[inline]\n    pub unsafe fn write_unlock(&self) { self.0.write_unlock() }\n\n    /// Destroys OS-related resources with this RWLock.\n    ///\n    /// Behavior is undefined if there are any currently active users of this\n    /// lock.\n    #[inline]\n    pub unsafe fn destroy(&self) { self.0.destroy() }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![allow(dead_code)] // stack_guard isn't used right now on all platforms\n\nuse cell::RefCell;\nuse sys::thread::guard::Guard;\nuse thread::Thread;\n\nstruct ThreadInfo {\n    stack_guard: Option<Guard>,\n    thread: Thread,\n}\n\nthread_local! { static THREAD_INFO: RefCell<Option<ThreadInfo>> = RefCell::new(None) }\n\nimpl ThreadInfo {\n    fn with<R, F>(f: F) -> Option<R> where F: FnOnce(&mut ThreadInfo) -> R {\n        THREAD_INFO.try_with(move |c| {\n            if c.borrow().is_none() {\n                *c.borrow_mut() = Some(ThreadInfo {\n                    stack_guard: None,\n                    thread: Thread::new(None),\n                })\n            }\n            f(c.borrow_mut().as_mut().unwrap())\n        }).ok()\n    }\n}\n\npub fn current_thread() -> Option<Thread> {\n    ThreadInfo::with(|info| info.thread.clone())\n}\n\npub fn stack_guard() -> Option<Guard> {\n    ThreadInfo::with(|info| info.stack_guard.clone()).and_then(|o| o)\n}\n\npub fn set(stack_guard: Option<Guard>, thread: Thread) {\n    THREAD_INFO.with(|c| assert!(c.borrow().is_none()));\n    THREAD_INFO.with(move |c| *c.borrow_mut() = Some(ThreadInfo{\n        stack_guard,\n        thread,\n    }));\n}\n\npub fn reset_guard(stack_guard: Option<Guard>) {\n    THREAD_INFO.with(move |c| c.borrow_mut().as_mut().unwrap().stack_guard = stack_guard);\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse time::Duration;\nuse sys_common::mutex::{self, Mutex};\nuse sys::condvar as imp;\n\n/// An OS-based condition variable.\n///\n/// This structure is the lowest layer possible on top of the OS-provided\n/// condition variables. It is consequently entirely unsafe to use. It is\n/// recommended to use the safer types at the top level of this crate instead of\n/// this type.\npub struct Condvar(imp::Condvar);\n\nimpl Condvar {\n    /// Creates a new condition variable for use.\n    ///\n    /// Behavior is undefined if the condition variable is moved after it is\n    /// first used with any of the functions below.\n    pub const fn new() -> Condvar { Condvar(imp::Condvar::new()) }\n\n    /// Prepares the condition variable for use.\n    ///\n    /// This should be called once the condition variable is at a stable memory\n    /// address.\n    #[inline]\n    pub unsafe fn init(&mut self) { self.0.init() }\n\n    /// Signals one waiter on this condition variable to wake up.\n    #[inline]\n    pub unsafe fn notify_one(&self) { self.0.notify_one() }\n\n    /// Awakens all current waiters on this condition variable.\n    #[inline]\n    pub unsafe fn notify_all(&self) { self.0.notify_all() }\n\n    /// Waits for a signal on the specified mutex.\n    ///\n    /// Behavior is undefined if the mutex is not locked by the current thread.\n    /// Behavior is also undefined if more than one mutex is used concurrently\n    /// on this condition variable.\n    #[inline]\n    pub unsafe fn wait(&self, mutex: &Mutex) { self.0.wait(mutex::raw(mutex)) }\n\n    /// Waits for a signal on the specified mutex with a timeout duration\n    /// specified by `dur` (a relative time into the future).\n    ///\n    /// Behavior is undefined if the mutex is not locked by the current thread.\n    /// Behavior is also undefined if more than one mutex is used concurrently\n    /// on this condition variable.\n    #[inline]\n    pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool {\n        self.0.wait_timeout(mutex::raw(mutex), dur)\n    }\n\n    /// Deallocates all resources associated with this condition variable.\n    ///\n    /// Behavior is undefined if there are current or will be future users of\n    /// this condition variable.\n    #[inline]\n    pub unsafe fn destroy(&self) { self.0.destroy() }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![allow(dead_code)]\n#![unstable(feature = \"process_internals\", issue = \"0\")]\n\nuse ffi::{OsStr, OsString};\nuse env;\nuse collections::BTreeMap;\nuse borrow::Borrow;\n\npub trait EnvKey:\n    From<OsString> + Into<OsString> +\n    Borrow<OsStr> + Borrow<Self> + AsRef<OsStr> +\n    Ord + Clone {}\n\n// Implement a case-sensitive environment variable key\n#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd)]\npub struct DefaultEnvKey(OsString);\n\nimpl From<OsString> for DefaultEnvKey {\n    fn from(k: OsString) -> Self { DefaultEnvKey(k) }\n}\n\nimpl From<DefaultEnvKey> for OsString {\n    fn from(k: DefaultEnvKey) -> Self { k.0 }\n}\n\nimpl Borrow<OsStr> for DefaultEnvKey {\n    fn borrow(&self) -> &OsStr { &self.0 }\n}\n\nimpl AsRef<OsStr> for DefaultEnvKey {\n    fn as_ref(&self) -> &OsStr { &self.0 }\n}\n\nimpl EnvKey for DefaultEnvKey {}\n\n// Stores a set of changes to an environment\n#[derive(Clone, Debug)]\npub struct CommandEnv<K> {\n    clear: bool,\n    saw_path: bool,\n    vars: BTreeMap<K, Option<OsString>>\n}\n\nimpl<K: EnvKey> Default for CommandEnv<K> {\n    fn default() -> Self {\n        CommandEnv {\n            clear: false,\n            saw_path: false,\n            vars: Default::default()\n        }\n    }\n}\n\nimpl<K: EnvKey> CommandEnv<K> {\n    // Capture the current environment with these changes applied\n    pub fn capture(&self) -> BTreeMap<K, OsString> {\n        let mut result = BTreeMap::<K, OsString>::new();\n        if !self.clear {\n            for (k, v) in env::vars_os() {\n                result.insert(k.into(), v);\n            }\n        }\n        for (k, maybe_v) in &self.vars {\n            if let &Some(ref v) = maybe_v {\n                result.insert(k.clone(), v.clone());\n            } else {\n                result.remove(k);\n            }\n        }\n        result\n    }\n\n    // Apply these changes directly to the current environment\n    pub fn apply(&self) {\n        if self.clear {\n            for (k, _) in env::vars_os() {\n                env::remove_var(k);\n            }\n        }\n        for (key, maybe_val) in self.vars.iter() {\n            if let &Some(ref val) = maybe_val {\n                env::set_var(key, val);\n            } else {\n                env::remove_var(key);\n            }\n        }\n    }\n\n    pub fn is_unchanged(&self) -> bool {\n        !self.clear && self.vars.is_empty()\n    }\n\n    pub fn capture_if_changed(&self) -> Option<BTreeMap<K, OsString>> {\n        if self.is_unchanged() {\n            None\n        } else {\n            Some(self.capture())\n        }\n    }\n\n    // The following functions build up changes\n    pub fn set(&mut self, key: &OsStr, value: &OsStr) {\n        self.maybe_saw_path(&key);\n        self.vars.insert(key.to_owned().into(), Some(value.to_owned()));\n    }\n    pub fn remove(&mut self, key: &OsStr) {\n        self.maybe_saw_path(&key);\n        if self.clear {\n            self.vars.remove(key);\n        } else {\n            self.vars.insert(key.to_owned().into(), None);\n        }\n    }\n    pub fn clear(&mut self) {\n        self.clear = true;\n        self.vars.clear();\n    }\n    pub fn have_changed_path(&self) -> bool {\n        self.saw_path || self.clear\n    }\n    fn maybe_saw_path(&mut self, key: &OsStr) {\n        if !self.saw_path && key == \"PATH\" {\n            self.saw_path = true;\n        }\n    }\n}\n","// Copyright 2013 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse io::prelude::*;\nuse sys::stdio::{Stderr, stderr_prints_nothing};\nuse thread;\n\npub fn dumb_print(args: fmt::Arguments) {\n    if stderr_prints_nothing() {\n        return\n    }\n    let _ = Stderr::new().map(|mut stderr| stderr.write_fmt(args));\n}\n\n// Other platforms should use the appropriate platform-specific mechanism for\n// aborting the process.  If no platform-specific mechanism is available,\n// ::intrinsics::abort() may be used instead.  The above implementations cover\n// all targets currently supported by libstd.\n\npub fn abort(args: fmt::Arguments) -> ! {\n    dumb_print(format_args!(\"fatal runtime error: {}\\n\", args));\n    unsafe { ::sys::abort_internal(); }\n}\n\n#[allow(dead_code)] // stack overflow detection not enabled on all platforms\npub unsafe fn report_overflow() {\n    dumb_print(format_args!(\"\\nthread '{}' has overflowed its stack\\n\",\n                            thread::current().name().unwrap_or(\"<unknown>\")));\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Implementation of [the WTF-8 encoding](https://simonsapin.github.io/wtf-8/).\n//!\n//! This library uses Rust\u2019s type system to maintain\n//! [well-formedness](https://simonsapin.github.io/wtf-8/#well-formed),\n//! like the `String` and `&str` types do for UTF-8.\n//!\n//! Since [WTF-8 must not be used\n//! for interchange](https://simonsapin.github.io/wtf-8/#intended-audience),\n//! this library deliberately does not provide access to the underlying bytes\n//! of WTF-8 strings,\n//! nor can it decode WTF-8 from arbitrary bytes.\n//! WTF-8 strings can be obtained from UTF-8, UTF-16, or code points.\n\n// this module is imported from @SimonSapin's repo and has tons of dead code on\n// unix (it's mostly used on windows), so don't worry about dead code here.\n#![allow(dead_code)]\n\nuse core::str::next_code_point;\n\nuse borrow::Cow;\nuse char;\nuse fmt;\nuse hash::{Hash, Hasher};\nuse iter::FromIterator;\nuse mem;\nuse ops;\nuse rc::Rc;\nuse slice;\nuse str;\nuse sync::Arc;\nuse sys_common::AsInner;\n\nconst UTF8_REPLACEMENT_CHARACTER: &'static str = \"\\u{FFFD}\";\n\n/// A Unicode code point: from U+0000 to U+10FFFF.\n///\n/// Compare with the `char` type,\n/// which represents a Unicode scalar value:\n/// a code point that is not a surrogate (U+D800 to U+DFFF).\n#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy)]\npub struct CodePoint {\n    value: u32\n}\n\n/// Format the code point as `U+` followed by four to six hexadecimal digits.\n/// Example: `U+1F4A9`\nimpl fmt::Debug for CodePoint {\n    #[inline]\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        write!(formatter, \"U+{:04X}\", self.value)\n    }\n}\n\nimpl CodePoint {\n    /// Unsafely creates a new `CodePoint` without checking the value.\n    ///\n    /// Only use when `value` is known to be less than or equal to 0x10FFFF.\n    #[inline]\n    pub unsafe fn from_u32_unchecked(value: u32) -> CodePoint {\n        CodePoint { value }\n    }\n\n    /// Creates a new `CodePoint` if the value is a valid code point.\n    ///\n    /// Returns `None` if `value` is above 0x10FFFF.\n    #[inline]\n    pub fn from_u32(value: u32) -> Option<CodePoint> {\n        match value {\n            0 ..= 0x10FFFF => Some(CodePoint { value }),\n            _ => None\n        }\n    }\n\n    /// Creates a new `CodePoint` from a `char`.\n    ///\n    /// Since all Unicode scalar values are code points, this always succeeds.\n    #[inline]\n    pub fn from_char(value: char) -> CodePoint {\n        CodePoint { value: value as u32 }\n    }\n\n    /// Returns the numeric value of the code point.\n    #[inline]\n    pub fn to_u32(&self) -> u32 {\n        self.value\n    }\n\n    /// Optionally returns a Unicode scalar value for the code point.\n    ///\n    /// Returns `None` if the code point is a surrogate (from U+D800 to U+DFFF).\n    #[inline]\n    pub fn to_char(&self) -> Option<char> {\n        match self.value {\n            0xD800 ..= 0xDFFF => None,\n            _ => Some(unsafe { char::from_u32_unchecked(self.value) })\n        }\n    }\n\n    /// Returns a Unicode scalar value for the code point.\n    ///\n    /// Returns `'\\u{FFFD}'` (the replacement character \u201c\ufffd\u201d)\n    /// if the code point is a surrogate (from U+D800 to U+DFFF).\n    #[inline]\n    pub fn to_char_lossy(&self) -> char {\n        self.to_char().unwrap_or('\\u{FFFD}')\n    }\n}\n\n/// An owned, growable string of well-formed WTF-8 data.\n///\n/// Similar to `String`, but can additionally contain surrogate code points\n/// if they\u2019re not in a surrogate pair.\n#[derive(Eq, PartialEq, Ord, PartialOrd, Clone)]\npub struct Wtf8Buf {\n    bytes: Vec<u8>\n}\n\nimpl ops::Deref for Wtf8Buf {\n    type Target = Wtf8;\n\n    fn deref(&self) -> &Wtf8 {\n        self.as_slice()\n    }\n}\n\nimpl ops::DerefMut for Wtf8Buf {\n    fn deref_mut(&mut self) -> &mut Wtf8 {\n        self.as_mut_slice()\n    }\n}\n\n/// Format the string with double quotes,\n/// and surrogates as `\\u` followed by four hexadecimal digits.\n/// Example: `\"a\\u{D800}\"` for a string with code points [U+0061, U+D800]\nimpl fmt::Debug for Wtf8Buf {\n    #[inline]\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, formatter)\n    }\n}\n\nimpl Wtf8Buf {\n    /// Creates a new, empty WTF-8 string.\n    #[inline]\n    pub fn new() -> Wtf8Buf {\n        Wtf8Buf { bytes: Vec::new() }\n    }\n\n    /// Creates a new, empty WTF-8 string with pre-allocated capacity for `n` bytes.\n    #[inline]\n    pub fn with_capacity(n: usize) -> Wtf8Buf {\n        Wtf8Buf { bytes: Vec::with_capacity(n) }\n    }\n\n    /// Creates a WTF-8 string from a UTF-8 `String`.\n    ///\n    /// This takes ownership of the `String` and does not copy.\n    ///\n    /// Since WTF-8 is a superset of UTF-8, this always succeeds.\n    #[inline]\n    pub fn from_string(string: String) -> Wtf8Buf {\n        Wtf8Buf { bytes: string.into_bytes() }\n    }\n\n    /// Creates a WTF-8 string from a UTF-8 `&str` slice.\n    ///\n    /// This copies the content of the slice.\n    ///\n    /// Since WTF-8 is a superset of UTF-8, this always succeeds.\n    #[inline]\n    pub fn from_str(str: &str) -> Wtf8Buf {\n        Wtf8Buf { bytes: <[_]>::to_vec(str.as_bytes()) }\n    }\n\n    pub fn clear(&mut self) {\n        self.bytes.clear()\n    }\n\n    /// Creates a WTF-8 string from a potentially ill-formed UTF-16 slice of 16-bit code units.\n    ///\n    /// This is lossless: calling `.encode_wide()` on the resulting string\n    /// will always return the original code units.\n    pub fn from_wide(v: &[u16]) -> Wtf8Buf {\n        let mut string = Wtf8Buf::with_capacity(v.len());\n        for item in char::decode_utf16(v.iter().cloned()) {\n            match item {\n                Ok(ch) => string.push_char(ch),\n                Err(surrogate) => {\n                    let surrogate = surrogate.unpaired_surrogate();\n                    // Surrogates are known to be in the code point range.\n                    let code_point = unsafe {\n                        CodePoint::from_u32_unchecked(surrogate as u32)\n                    };\n                    // Skip the WTF-8 concatenation check,\n                    // surrogate pairs are already decoded by decode_utf16\n                    string.push_code_point_unchecked(code_point)\n                }\n            }\n        }\n        string\n    }\n\n    /// Copied from String::push\n    /// This does **not** include the WTF-8 concatenation check.\n    fn push_code_point_unchecked(&mut self, code_point: CodePoint) {\n        let c = unsafe {\n            char::from_u32_unchecked(code_point.value)\n        };\n        let mut bytes = [0; 4];\n        let bytes = c.encode_utf8(&mut bytes).as_bytes();\n        self.bytes.extend_from_slice(bytes)\n    }\n\n    #[inline]\n    pub fn as_slice(&self) -> &Wtf8 {\n        unsafe { Wtf8::from_bytes_unchecked(&self.bytes) }\n    }\n\n    #[inline]\n    pub fn as_mut_slice(&mut self) -> &mut Wtf8 {\n        unsafe { Wtf8::from_mut_bytes_unchecked(&mut self.bytes) }\n    }\n\n    /// Reserves capacity for at least `additional` more bytes to be inserted\n    /// in the given `Wtf8Buf`.\n    /// The collection may reserve more space to avoid frequent reallocations.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new capacity overflows `usize`.\n    #[inline]\n    pub fn reserve(&mut self, additional: usize) {\n        self.bytes.reserve(additional)\n    }\n\n    #[inline]\n    pub fn reserve_exact(&mut self, additional: usize) {\n        self.bytes.reserve_exact(additional)\n    }\n\n    #[inline]\n    pub fn shrink_to_fit(&mut self) {\n        self.bytes.shrink_to_fit()\n    }\n\n    #[inline]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        self.bytes.shrink_to(min_capacity)\n    }\n\n    /// Returns the number of bytes that this string buffer can hold without reallocating.\n    #[inline]\n    pub fn capacity(&self) -> usize {\n        self.bytes.capacity()\n    }\n\n    /// Append a UTF-8 slice at the end of the string.\n    #[inline]\n    pub fn push_str(&mut self, other: &str) {\n        self.bytes.extend_from_slice(other.as_bytes())\n    }\n\n    /// Append a WTF-8 slice at the end of the string.\n    ///\n    /// This replaces newly paired surrogates at the boundary\n    /// with a supplementary code point,\n    /// like concatenating ill-formed UTF-16 strings effectively would.\n    #[inline]\n    pub fn push_wtf8(&mut self, other: &Wtf8) {\n        match ((&*self).final_lead_surrogate(), other.initial_trail_surrogate()) {\n            // Replace newly paired surrogates by a supplementary code point.\n            (Some(lead), Some(trail)) => {\n                let len_without_lead_surrogate = self.len() - 3;\n                self.bytes.truncate(len_without_lead_surrogate);\n                let other_without_trail_surrogate = &other.bytes[3..];\n                // 4 bytes for the supplementary code point\n                self.bytes.reserve(4 + other_without_trail_surrogate.len());\n                self.push_char(decode_surrogate_pair(lead, trail));\n                self.bytes.extend_from_slice(other_without_trail_surrogate);\n            }\n            _ => self.bytes.extend_from_slice(&other.bytes)\n        }\n    }\n\n    /// Append a Unicode scalar value at the end of the string.\n    #[inline]\n    pub fn push_char(&mut self, c: char) {\n        self.push_code_point_unchecked(CodePoint::from_char(c))\n    }\n\n    /// Append a code point at the end of the string.\n    ///\n    /// This replaces newly paired surrogates at the boundary\n    /// with a supplementary code point,\n    /// like concatenating ill-formed UTF-16 strings effectively would.\n    #[inline]\n    pub fn push(&mut self, code_point: CodePoint) {\n        if let trail @ 0xDC00..=0xDFFF = code_point.to_u32() {\n            if let Some(lead) = (&*self).final_lead_surrogate() {\n                let len_without_lead_surrogate = self.len() - 3;\n                self.bytes.truncate(len_without_lead_surrogate);\n                self.push_char(decode_surrogate_pair(lead, trail as u16));\n                return\n            }\n        }\n\n        // No newly paired surrogates at the boundary.\n        self.push_code_point_unchecked(code_point)\n    }\n\n    /// Shortens a string to the specified length.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `new_len` > current length,\n    /// or if `new_len` is not a code point boundary.\n    #[inline]\n    pub fn truncate(&mut self, new_len: usize) {\n        assert!(is_code_point_boundary(self, new_len));\n        self.bytes.truncate(new_len)\n    }\n\n    /// Consumes the WTF-8 string and tries to convert it to UTF-8.\n    ///\n    /// This does not copy the data.\n    ///\n    /// If the contents are not well-formed UTF-8\n    /// (that is, if the string contains surrogates),\n    /// the original WTF-8 string is returned instead.\n    pub fn into_string(self) -> Result<String, Wtf8Buf> {\n        match self.next_surrogate(0) {\n            None => Ok(unsafe { String::from_utf8_unchecked(self.bytes) }),\n            Some(_) => Err(self),\n        }\n    }\n\n    /// Consumes the WTF-8 string and converts it lossily to UTF-8.\n    ///\n    /// This does not copy the data (but may overwrite parts of it in place).\n    ///\n    /// Surrogates are replaced with `\"\\u{FFFD}\"` (the replacement character \u201c\ufffd\u201d)\n    pub fn into_string_lossy(mut self) -> String {\n        let mut pos = 0;\n        loop {\n            match self.next_surrogate(pos) {\n                Some((surrogate_pos, _)) => {\n                    pos = surrogate_pos + 3;\n                    self.bytes[surrogate_pos..pos]\n                        .copy_from_slice(UTF8_REPLACEMENT_CHARACTER.as_bytes());\n                },\n                None => return unsafe { String::from_utf8_unchecked(self.bytes) }\n            }\n        }\n    }\n\n    /// Converts this `Wtf8Buf` into a boxed `Wtf8`.\n    #[inline]\n    pub fn into_box(self) -> Box<Wtf8> {\n        unsafe { mem::transmute(self.bytes.into_boxed_slice()) }\n    }\n\n    /// Converts a `Box<Wtf8>` into a `Wtf8Buf`.\n    pub fn from_box(boxed: Box<Wtf8>) -> Wtf8Buf {\n        let bytes: Box<[u8]> = unsafe { mem::transmute(boxed) };\n        Wtf8Buf { bytes: bytes.into_vec() }\n    }\n}\n\n/// Create a new WTF-8 string from an iterator of code points.\n///\n/// This replaces surrogate code point pairs with supplementary code points,\n/// like concatenating ill-formed UTF-16 strings effectively would.\nimpl FromIterator<CodePoint> for Wtf8Buf {\n    fn from_iter<T: IntoIterator<Item=CodePoint>>(iter: T) -> Wtf8Buf {\n        let mut string = Wtf8Buf::new();\n        string.extend(iter);\n        string\n    }\n}\n\n/// Append code points from an iterator to the string.\n///\n/// This replaces surrogate code point pairs with supplementary code points,\n/// like concatenating ill-formed UTF-16 strings effectively would.\nimpl Extend<CodePoint> for Wtf8Buf {\n    fn extend<T: IntoIterator<Item=CodePoint>>(&mut self, iter: T) {\n        let iterator = iter.into_iter();\n        let (low, _high) = iterator.size_hint();\n        // Lower bound of one byte per code point (ASCII only)\n        self.bytes.reserve(low);\n        for code_point in iterator {\n            self.push(code_point);\n        }\n    }\n}\n\n/// A borrowed slice of well-formed WTF-8 data.\n///\n/// Similar to `&str`, but can additionally contain surrogate code points\n/// if they\u2019re not in a surrogate pair.\n#[derive(Eq, Ord, PartialEq, PartialOrd)]\npub struct Wtf8 {\n    bytes: [u8]\n}\n\nimpl AsInner<[u8]> for Wtf8 {\n    fn as_inner(&self) -> &[u8] { &self.bytes }\n}\n\n/// Format the slice with double quotes,\n/// and surrogates as `\\u` followed by four hexadecimal digits.\n/// Example: `\"a\\u{D800}\"` for a slice with code points [U+0061, U+D800]\nimpl fmt::Debug for Wtf8 {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fn write_str_escaped(f: &mut fmt::Formatter, s: &str) -> fmt::Result {\n            use fmt::Write;\n            for c in s.chars().flat_map(|c| c.escape_debug()) {\n                f.write_char(c)?\n            }\n            Ok(())\n        }\n\n        formatter.write_str(\"\\\"\")?;\n        let mut pos = 0;\n        while let Some((surrogate_pos, surrogate)) = self.next_surrogate(pos) {\n            write_str_escaped(\n                formatter,\n                unsafe { str::from_utf8_unchecked(\n                    &self.bytes[pos .. surrogate_pos]\n                )},\n            )?;\n            write!(formatter, \"\\\\u{{{:x}}}\", surrogate)?;\n            pos = surrogate_pos + 3;\n        }\n        write_str_escaped(\n            formatter,\n            unsafe { str::from_utf8_unchecked(&self.bytes[pos..]) },\n        )?;\n        formatter.write_str(\"\\\"\")\n    }\n}\n\nimpl fmt::Display for Wtf8 {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        let wtf8_bytes = &self.bytes;\n        let mut pos = 0;\n        loop {\n            match self.next_surrogate(pos) {\n                Some((surrogate_pos, _)) => {\n                    formatter.write_str(unsafe {\n                        str::from_utf8_unchecked(&wtf8_bytes[pos .. surrogate_pos])\n                    })?;\n                    formatter.write_str(UTF8_REPLACEMENT_CHARACTER)?;\n                    pos = surrogate_pos + 3;\n                },\n                None => {\n                    let s = unsafe {\n                        str::from_utf8_unchecked(&wtf8_bytes[pos..])\n                    };\n                    if pos == 0 {\n                        return s.fmt(formatter)\n                    } else {\n                        return formatter.write_str(s)\n                    }\n                }\n            }\n        }\n    }\n}\n\nimpl Wtf8 {\n    /// Creates a WTF-8 slice from a UTF-8 `&str` slice.\n    ///\n    /// Since WTF-8 is a superset of UTF-8, this always succeeds.\n    #[inline]\n    pub fn from_str(value: &str) -> &Wtf8 {\n        unsafe { Wtf8::from_bytes_unchecked(value.as_bytes()) }\n    }\n\n    /// Creates a WTF-8 slice from a WTF-8 byte slice.\n    ///\n    /// Since the byte slice is not checked for valid WTF-8, this functions is\n    /// marked unsafe.\n    #[inline]\n    unsafe fn from_bytes_unchecked(value: &[u8]) -> &Wtf8 {\n        mem::transmute(value)\n    }\n\n    /// Creates a mutable WTF-8 slice from a mutable WTF-8 byte slice.\n    ///\n    /// Since the byte slice is not checked for valid WTF-8, this functions is\n    /// marked unsafe.\n    #[inline]\n    unsafe fn from_mut_bytes_unchecked(value: &mut [u8]) -> &mut Wtf8 {\n        mem::transmute(value)\n    }\n\n    /// Returns the length, in WTF-8 bytes.\n    #[inline]\n    pub fn len(&self) -> usize {\n        self.bytes.len()\n    }\n\n    #[inline]\n    pub fn is_empty(&self) -> bool {\n        self.bytes.is_empty()\n    }\n\n    /// Returns the code point at `position` if it is in the ASCII range,\n    /// or `b'\\xFF' otherwise.\n    ///\n    /// # Panics\n    ///\n    /// Panics if `position` is beyond the end of the string.\n    #[inline]\n    pub fn ascii_byte_at(&self, position: usize) -> u8 {\n        match self.bytes[position] {\n            ascii_byte @ 0x00 ..= 0x7F => ascii_byte,\n            _ => 0xFF\n        }\n    }\n\n    /// Returns an iterator for the string\u2019s code points.\n    #[inline]\n    pub fn code_points(&self) -> Wtf8CodePoints {\n        Wtf8CodePoints { bytes: self.bytes.iter() }\n    }\n\n    /// Tries to convert the string to UTF-8 and return a `&str` slice.\n    ///\n    /// Returns `None` if the string contains surrogates.\n    ///\n    /// This does not copy the data.\n    #[inline]\n    pub fn as_str(&self) -> Option<&str> {\n        // Well-formed WTF-8 is also well-formed UTF-8\n        // if and only if it contains no surrogate.\n        match self.next_surrogate(0) {\n            None => Some(unsafe { str::from_utf8_unchecked(&self.bytes) }),\n            Some(_) => None,\n        }\n    }\n\n    /// Lossily converts the string to UTF-8.\n    /// Returns a UTF-8 `&str` slice if the contents are well-formed in UTF-8.\n    ///\n    /// Surrogates are replaced with `\"\\u{FFFD}\"` (the replacement character \u201c\ufffd\u201d).\n    ///\n    /// This only copies the data if necessary (if it contains any surrogate).\n    pub fn to_string_lossy(&self) -> Cow<str> {\n        let surrogate_pos = match self.next_surrogate(0) {\n            None => return Cow::Borrowed(unsafe { str::from_utf8_unchecked(&self.bytes) }),\n            Some((pos, _)) => pos,\n        };\n        let wtf8_bytes = &self.bytes;\n        let mut utf8_bytes = Vec::with_capacity(self.len());\n        utf8_bytes.extend_from_slice(&wtf8_bytes[..surrogate_pos]);\n        utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER.as_bytes());\n        let mut pos = surrogate_pos + 3;\n        loop {\n            match self.next_surrogate(pos) {\n                Some((surrogate_pos, _)) => {\n                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos .. surrogate_pos]);\n                    utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER.as_bytes());\n                    pos = surrogate_pos + 3;\n                },\n                None => {\n                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos..]);\n                    return Cow::Owned(unsafe { String::from_utf8_unchecked(utf8_bytes) })\n                }\n            }\n        }\n    }\n\n    /// Converts the WTF-8 string to potentially ill-formed UTF-16\n    /// and return an iterator of 16-bit code units.\n    ///\n    /// This is lossless:\n    /// calling `Wtf8Buf::from_ill_formed_utf16` on the resulting code units\n    /// would always return the original WTF-8 string.\n    #[inline]\n    pub fn encode_wide(&self) -> EncodeWide {\n        EncodeWide { code_points: self.code_points(), extra: 0 }\n    }\n\n    #[inline]\n    fn next_surrogate(&self, mut pos: usize) -> Option<(usize, u16)> {\n        let mut iter = self.bytes[pos..].iter();\n        loop {\n            let b = *iter.next()?;\n            if b < 0x80 {\n                pos += 1;\n            } else if b < 0xE0 {\n                iter.next();\n                pos += 2;\n            } else if b == 0xED {\n                match (iter.next(), iter.next()) {\n                    (Some(&b2), Some(&b3)) if b2 >= 0xA0 => {\n                        return Some((pos, decode_surrogate(b2, b3)))\n                    }\n                    _ => pos += 3\n                }\n            } else if b < 0xF0 {\n                iter.next();\n                iter.next();\n                pos += 3;\n            } else {\n                iter.next();\n                iter.next();\n                iter.next();\n                pos += 4;\n            }\n        }\n    }\n\n    #[inline]\n    fn final_lead_surrogate(&self) -> Option<u16> {\n        let len = self.len();\n        if len < 3 {\n            return None\n        }\n        match &self.bytes[(len - 3)..] {\n            &[0xED, b2 @ 0xA0..=0xAF, b3] => Some(decode_surrogate(b2, b3)),\n            _ => None\n        }\n    }\n\n    #[inline]\n    fn initial_trail_surrogate(&self) -> Option<u16> {\n        let len = self.len();\n        if len < 3 {\n            return None\n        }\n        match &self.bytes[..3] {\n            &[0xED, b2 @ 0xB0..=0xBF, b3] => Some(decode_surrogate(b2, b3)),\n            _ => None\n        }\n    }\n\n    /// Boxes this `Wtf8`.\n    #[inline]\n    pub fn into_box(&self) -> Box<Wtf8> {\n        let boxed: Box<[u8]> = self.bytes.into();\n        unsafe { mem::transmute(boxed) }\n    }\n\n    /// Creates a boxed, empty `Wtf8`.\n    pub fn empty_box() -> Box<Wtf8> {\n        let boxed: Box<[u8]> = Default::default();\n        unsafe { mem::transmute(boxed) }\n    }\n\n    #[inline]\n    pub fn into_arc(&self) -> Arc<Wtf8> {\n        let arc: Arc<[u8]> = Arc::from(&self.bytes);\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Wtf8) }\n    }\n\n    #[inline]\n    pub fn into_rc(&self) -> Rc<Wtf8> {\n        let rc: Rc<[u8]> = Rc::from(&self.bytes);\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Wtf8) }\n    }\n}\n\n\n/// Return a slice of the given string for the byte range [`begin`..`end`).\n///\n/// # Panics\n///\n/// Panics when `begin` and `end` do not point to code point boundaries,\n/// or point beyond the end of the string.\nimpl ops::Index<ops::Range<usize>> for Wtf8 {\n    type Output = Wtf8;\n\n    #[inline]\n    fn index(&self, range: ops::Range<usize>) -> &Wtf8 {\n        // is_code_point_boundary checks that the index is in [0, .len()]\n        if range.start <= range.end &&\n           is_code_point_boundary(self, range.start) &&\n           is_code_point_boundary(self, range.end) {\n            unsafe { slice_unchecked(self, range.start, range.end) }\n        } else {\n            slice_error_fail(self, range.start, range.end)\n        }\n    }\n}\n\n/// Return a slice of the given string from byte `begin` to its end.\n///\n/// # Panics\n///\n/// Panics when `begin` is not at a code point boundary,\n/// or is beyond the end of the string.\nimpl ops::Index<ops::RangeFrom<usize>> for Wtf8 {\n    type Output = Wtf8;\n\n    #[inline]\n    fn index(&self, range: ops::RangeFrom<usize>) -> &Wtf8 {\n        // is_code_point_boundary checks that the index is in [0, .len()]\n        if is_code_point_boundary(self, range.start) {\n            unsafe { slice_unchecked(self, range.start, self.len()) }\n        } else {\n            slice_error_fail(self, range.start, self.len())\n        }\n    }\n}\n\n/// Return a slice of the given string from its beginning to byte `end`.\n///\n/// # Panics\n///\n/// Panics when `end` is not at a code point boundary,\n/// or is beyond the end of the string.\nimpl ops::Index<ops::RangeTo<usize>> for Wtf8 {\n    type Output = Wtf8;\n\n    #[inline]\n    fn index(&self, range: ops::RangeTo<usize>) -> &Wtf8 {\n        // is_code_point_boundary checks that the index is in [0, .len()]\n        if is_code_point_boundary(self, range.end) {\n            unsafe { slice_unchecked(self, 0, range.end) }\n        } else {\n            slice_error_fail(self, 0, range.end)\n        }\n    }\n}\n\nimpl ops::Index<ops::RangeFull> for Wtf8 {\n    type Output = Wtf8;\n\n    #[inline]\n    fn index(&self, _range: ops::RangeFull) -> &Wtf8 {\n        self\n    }\n}\n\n#[inline]\nfn decode_surrogate(second_byte: u8, third_byte: u8) -> u16 {\n    // The first byte is assumed to be 0xED\n    0xD800 | (second_byte as u16 & 0x3F) << 6 | third_byte as u16 & 0x3F\n}\n\n#[inline]\nfn decode_surrogate_pair(lead: u16, trail: u16) -> char {\n    let code_point = 0x10000 + ((((lead - 0xD800) as u32) << 10) | (trail - 0xDC00) as u32);\n    unsafe { char::from_u32_unchecked(code_point) }\n}\n\n/// Copied from core::str::StrPrelude::is_char_boundary\n#[inline]\npub fn is_code_point_boundary(slice: &Wtf8, index: usize) -> bool {\n    if index == slice.len() { return true; }\n    match slice.bytes.get(index) {\n        None => false,\n        Some(&b) => b < 128 || b >= 192,\n    }\n}\n\n/// Copied from core::str::raw::slice_unchecked\n#[inline]\npub unsafe fn slice_unchecked(s: &Wtf8, begin: usize, end: usize) -> &Wtf8 {\n    // memory layout of an &[u8] and &Wtf8 are the same\n    Wtf8::from_bytes_unchecked(slice::from_raw_parts(\n        s.bytes.as_ptr().add(begin),\n        end - begin\n    ))\n}\n\n/// Copied from core::str::raw::slice_error_fail\n#[inline(never)]\npub fn slice_error_fail(s: &Wtf8, begin: usize, end: usize) -> ! {\n    assert!(begin <= end);\n    panic!(\"index {} and/or {} in `{:?}` do not lie on character boundary\",\n          begin, end, s);\n}\n\n/// Iterator for the code points of a WTF-8 string.\n///\n/// Created with the method `.code_points()`.\n#[derive(Clone)]\npub struct Wtf8CodePoints<'a> {\n    bytes: slice::Iter<'a, u8>\n}\n\nimpl<'a> Iterator for Wtf8CodePoints<'a> {\n    type Item = CodePoint;\n\n    #[inline]\n    fn next(&mut self) -> Option<CodePoint> {\n        next_code_point(&mut self.bytes).map(|c| CodePoint { value: c })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let len = self.bytes.len();\n        (len.saturating_add(3) / 4, Some(len))\n    }\n}\n\n/// Generates a wide character sequence for potentially ill-formed UTF-16.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct EncodeWide<'a> {\n    code_points: Wtf8CodePoints<'a>,\n    extra: u16\n}\n\n// Copied from libunicode/u_str.rs\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for EncodeWide<'a> {\n    type Item = u16;\n\n    #[inline]\n    fn next(&mut self) -> Option<u16> {\n        if self.extra != 0 {\n            let tmp = self.extra;\n            self.extra = 0;\n            return Some(tmp);\n        }\n\n        let mut buf = [0; 2];\n        self.code_points.next().map(|code_point| {\n            let c = unsafe {\n                char::from_u32_unchecked(code_point.value)\n            };\n            let n = c.encode_utf16(&mut buf).len();\n            if n == 2 {\n                self.extra = buf[1];\n            }\n            buf[0]\n        })\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (low, high) = self.code_points.size_hint();\n        // every code point gets either one u16 or two u16,\n        // so this iterator is between 1 or 2 times as\n        // long as the underlying iterator.\n        (low, high.and_then(|n| n.checked_mul(2)))\n    }\n}\n\nimpl Hash for CodePoint {\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        self.value.hash(state)\n    }\n}\n\nimpl Hash for Wtf8Buf {\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        state.write(&self.bytes);\n        0xfeu8.hash(state)\n    }\n}\n\nimpl Hash for Wtf8 {\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        state.write(&self.bytes);\n        0xfeu8.hash(state)\n    }\n}\n\nimpl Wtf8 {\n    pub fn make_ascii_uppercase(&mut self) { self.bytes.make_ascii_uppercase() }\n}\n\n#[cfg(test)]\nmod tests {\n    use borrow::Cow;\n    use super::*;\n\n    #[test]\n    fn code_point_from_u32() {\n        assert!(CodePoint::from_u32(0).is_some());\n        assert!(CodePoint::from_u32(0xD800).is_some());\n        assert!(CodePoint::from_u32(0x10FFFF).is_some());\n        assert!(CodePoint::from_u32(0x110000).is_none());\n    }\n\n    #[test]\n    fn code_point_to_u32() {\n        fn c(value: u32) -> CodePoint { CodePoint::from_u32(value).unwrap() }\n        assert_eq!(c(0).to_u32(), 0);\n        assert_eq!(c(0xD800).to_u32(), 0xD800);\n        assert_eq!(c(0x10FFFF).to_u32(), 0x10FFFF);\n    }\n\n    #[test]\n    fn code_point_from_char() {\n        assert_eq!(CodePoint::from_char('a').to_u32(), 0x61);\n        assert_eq!(CodePoint::from_char('\ud83d\udca9').to_u32(), 0x1F4A9);\n    }\n\n    #[test]\n    fn code_point_to_string() {\n        assert_eq!(format!(\"{:?}\", CodePoint::from_char('a')), \"U+0061\");\n        assert_eq!(format!(\"{:?}\", CodePoint::from_char('\ud83d\udca9')), \"U+1F4A9\");\n    }\n\n    #[test]\n    fn code_point_to_char() {\n        fn c(value: u32) -> CodePoint { CodePoint::from_u32(value).unwrap() }\n        assert_eq!(c(0x61).to_char(), Some('a'));\n        assert_eq!(c(0x1F4A9).to_char(), Some('\ud83d\udca9'));\n        assert_eq!(c(0xD800).to_char(), None);\n    }\n\n    #[test]\n    fn code_point_to_char_lossy() {\n        fn c(value: u32) -> CodePoint { CodePoint::from_u32(value).unwrap() }\n        assert_eq!(c(0x61).to_char_lossy(), 'a');\n        assert_eq!(c(0x1F4A9).to_char_lossy(), '\ud83d\udca9');\n        assert_eq!(c(0xD800).to_char_lossy(), '\\u{FFFD}');\n    }\n\n    #[test]\n    fn wtf8buf_new() {\n        assert_eq!(Wtf8Buf::new().bytes, b\"\");\n    }\n\n    #[test]\n    fn wtf8buf_from_str() {\n        assert_eq!(Wtf8Buf::from_str(\"\").bytes, b\"\");\n        assert_eq!(Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\").bytes,\n                   b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8buf_from_string() {\n        assert_eq!(Wtf8Buf::from_string(String::from(\"\")).bytes, b\"\");\n        assert_eq!(Wtf8Buf::from_string(String::from(\"a\u00e9 \ud83d\udca9\")).bytes,\n                   b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8buf_from_wide() {\n        assert_eq!(Wtf8Buf::from_wide(&[]).bytes, b\"\");\n        assert_eq!(Wtf8Buf::from_wide(\n                      &[0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]).bytes,\n                   b\"a\\xC3\\xA9 \\xED\\xA0\\xBD\\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8buf_push_str() {\n        let mut string = Wtf8Buf::new();\n        assert_eq!(string.bytes, b\"\");\n        string.push_str(\"a\u00e9 \ud83d\udca9\");\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8buf_push_char() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \");\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \");\n        string.push_char('\ud83d\udca9');\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8buf_push() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \");\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \");\n        string.push(CodePoint::from_char('\ud83d\udca9'));\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n\n        fn c(value: u32) -> CodePoint { CodePoint::from_u32(value).unwrap() }\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xD83D));  // lead\n        string.push(c(0xDCA9));  // trail\n        assert_eq!(string.bytes, b\"\\xF0\\x9F\\x92\\xA9\");  // Magic!\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xD83D));  // lead\n        string.push(c(0x20));  // not surrogate\n        string.push(c(0xDCA9));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\xBD \\xED\\xB2\\xA9\");\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xD800));  // lead\n        string.push(c(0xDBFF));  // lead\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\x80\\xED\\xAF\\xBF\");\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xD800));  // lead\n        string.push(c(0xE000));  // not surrogate\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\x80\\xEE\\x80\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xD7FF));  // not surrogate\n        string.push(c(0xDC00));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\x9F\\xBF\\xED\\xB0\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0x61));  // not surrogate, < 3 bytes\n        string.push(c(0xDC00));  // trail\n        assert_eq!(string.bytes, b\"\\x61\\xED\\xB0\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push(c(0xDC00));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\xB0\\x80\");\n    }\n\n    #[test]\n    fn wtf8buf_push_wtf8() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9\");\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9\");\n        string.push_wtf8(Wtf8::from_str(\" \ud83d\udca9\"));\n        assert_eq!(string.bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n\n        fn w(v: &[u8]) -> &Wtf8 { unsafe { Wtf8::from_bytes_unchecked(v) } }\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\xA0\\xBD\"));  // lead\n        string.push_wtf8(w(b\"\\xED\\xB2\\xA9\"));  // trail\n        assert_eq!(string.bytes, b\"\\xF0\\x9F\\x92\\xA9\");  // Magic!\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\xA0\\xBD\"));  // lead\n        string.push_wtf8(w(b\" \"));  // not surrogate\n        string.push_wtf8(w(b\"\\xED\\xB2\\xA9\"));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\xBD \\xED\\xB2\\xA9\");\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\xA0\\x80\"));  // lead\n        string.push_wtf8(w(b\"\\xED\\xAF\\xBF\"));  // lead\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\x80\\xED\\xAF\\xBF\");\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\xA0\\x80\"));  // lead\n        string.push_wtf8(w(b\"\\xEE\\x80\\x80\"));  // not surrogate\n        assert_eq!(string.bytes, b\"\\xED\\xA0\\x80\\xEE\\x80\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\x9F\\xBF\"));  // not surrogate\n        string.push_wtf8(w(b\"\\xED\\xB0\\x80\"));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\x9F\\xBF\\xED\\xB0\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"a\"));  // not surrogate, < 3 bytes\n        string.push_wtf8(w(b\"\\xED\\xB0\\x80\"));  // trail\n        assert_eq!(string.bytes, b\"\\x61\\xED\\xB0\\x80\");\n\n        let mut string = Wtf8Buf::new();\n        string.push_wtf8(w(b\"\\xED\\xB0\\x80\"));  // trail\n        assert_eq!(string.bytes, b\"\\xED\\xB0\\x80\");\n    }\n\n    #[test]\n    fn wtf8buf_truncate() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9\");\n        string.truncate(1);\n        assert_eq!(string.bytes, b\"a\");\n    }\n\n    #[test]\n    #[should_panic]\n    fn wtf8buf_truncate_fail_code_point_boundary() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9\");\n        string.truncate(2);\n    }\n\n    #[test]\n    #[should_panic]\n    fn wtf8buf_truncate_fail_longer() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9\");\n        string.truncate(4);\n    }\n\n    #[test]\n    fn wtf8buf_into_string() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\");\n        assert_eq!(string.clone().into_string(), Ok(String::from(\"a\u00e9 \ud83d\udca9\")));\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        assert_eq!(string.clone().into_string(), Err(string));\n    }\n\n    #[test]\n    fn wtf8buf_into_string_lossy() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\");\n        assert_eq!(string.clone().into_string_lossy(), String::from(\"a\u00e9 \ud83d\udca9\"));\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        assert_eq!(string.clone().into_string_lossy(), String::from(\"a\u00e9 \ud83d\udca9\ufffd\"));\n    }\n\n    #[test]\n    fn wtf8buf_from_iterator() {\n        fn f(values: &[u32]) -> Wtf8Buf {\n            values.iter().map(|&c| CodePoint::from_u32(c).unwrap()).collect::<Wtf8Buf>()\n        }\n        assert_eq!(f(&[0x61, 0xE9, 0x20, 0x1F4A9]).bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n\n        assert_eq!(f(&[0xD83D, 0xDCA9]).bytes, b\"\\xF0\\x9F\\x92\\xA9\");  // Magic!\n        assert_eq!(f(&[0xD83D, 0x20, 0xDCA9]).bytes, b\"\\xED\\xA0\\xBD \\xED\\xB2\\xA9\");\n        assert_eq!(f(&[0xD800, 0xDBFF]).bytes, b\"\\xED\\xA0\\x80\\xED\\xAF\\xBF\");\n        assert_eq!(f(&[0xD800, 0xE000]).bytes, b\"\\xED\\xA0\\x80\\xEE\\x80\\x80\");\n        assert_eq!(f(&[0xD7FF, 0xDC00]).bytes, b\"\\xED\\x9F\\xBF\\xED\\xB0\\x80\");\n        assert_eq!(f(&[0x61, 0xDC00]).bytes, b\"\\x61\\xED\\xB0\\x80\");\n        assert_eq!(f(&[0xDC00]).bytes, b\"\\xED\\xB0\\x80\");\n    }\n\n    #[test]\n    fn wtf8buf_extend() {\n        fn e(initial: &[u32], extended: &[u32]) -> Wtf8Buf {\n            fn c(value: &u32) -> CodePoint { CodePoint::from_u32(*value).unwrap() }\n            let mut string = initial.iter().map(c).collect::<Wtf8Buf>();\n            string.extend(extended.iter().map(c));\n            string\n        }\n\n        assert_eq!(e(&[0x61, 0xE9], &[0x20, 0x1F4A9]).bytes,\n                   b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n\n        assert_eq!(e(&[0xD83D], &[0xDCA9]).bytes, b\"\\xF0\\x9F\\x92\\xA9\");  // Magic!\n        assert_eq!(e(&[0xD83D, 0x20], &[0xDCA9]).bytes, b\"\\xED\\xA0\\xBD \\xED\\xB2\\xA9\");\n        assert_eq!(e(&[0xD800], &[0xDBFF]).bytes, b\"\\xED\\xA0\\x80\\xED\\xAF\\xBF\");\n        assert_eq!(e(&[0xD800], &[0xE000]).bytes, b\"\\xED\\xA0\\x80\\xEE\\x80\\x80\");\n        assert_eq!(e(&[0xD7FF], &[0xDC00]).bytes, b\"\\xED\\x9F\\xBF\\xED\\xB0\\x80\");\n        assert_eq!(e(&[0x61], &[0xDC00]).bytes, b\"\\x61\\xED\\xB0\\x80\");\n        assert_eq!(e(&[], &[0xDC00]).bytes, b\"\\xED\\xB0\\x80\");\n    }\n\n    #[test]\n    fn wtf8buf_show() {\n        let mut string = Wtf8Buf::from_str(\"a\\t\u00e9 \\u{7f}\ud83d\udca9\\r\");\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        assert_eq!(format!(\"{:?}\", string), \"\\\"a\\\\t\u00e9 \\\\u{7f}\\u{1f4a9}\\\\r\\\\u{d800}\\\"\");\n    }\n\n    #[test]\n    fn wtf8buf_as_slice() {\n        assert_eq!(Wtf8Buf::from_str(\"a\u00e9\").as_slice(), Wtf8::from_str(\"a\u00e9\"));\n    }\n\n    #[test]\n    fn wtf8buf_show_str() {\n        let text = \"a\\t\u00e9 \ud83d\udca9\\r\";\n        let string = Wtf8Buf::from_str(text);\n        assert_eq!(format!(\"{:?}\", text), format!(\"{:?}\", string));\n    }\n\n    #[test]\n    fn wtf8_from_str() {\n        assert_eq!(&Wtf8::from_str(\"\").bytes, b\"\");\n        assert_eq!(&Wtf8::from_str(\"a\u00e9 \ud83d\udca9\").bytes, b\"a\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    fn wtf8_len() {\n        assert_eq!(Wtf8::from_str(\"\").len(), 0);\n        assert_eq!(Wtf8::from_str(\"a\u00e9 \ud83d\udca9\").len(), 8);\n    }\n\n    #[test]\n    fn wtf8_slice() {\n        assert_eq!(&Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[1.. 4].bytes, b\"\\xC3\\xA9 \");\n    }\n\n    #[test]\n    #[should_panic]\n    fn wtf8_slice_not_code_point_boundary() {\n        &Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[2.. 4];\n    }\n\n    #[test]\n    fn wtf8_slice_from() {\n        assert_eq!(&Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[1..].bytes, b\"\\xC3\\xA9 \\xF0\\x9F\\x92\\xA9\");\n    }\n\n    #[test]\n    #[should_panic]\n    fn wtf8_slice_from_not_code_point_boundary() {\n        &Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[2..];\n    }\n\n    #[test]\n    fn wtf8_slice_to() {\n        assert_eq!(&Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[..4].bytes, b\"a\\xC3\\xA9 \");\n    }\n\n    #[test]\n    #[should_panic]\n    fn wtf8_slice_to_not_code_point_boundary() {\n        &Wtf8::from_str(\"a\u00e9 \ud83d\udca9\")[5..];\n    }\n\n    #[test]\n    fn wtf8_ascii_byte_at() {\n        let slice = Wtf8::from_str(\"a\u00e9 \ud83d\udca9\");\n        assert_eq!(slice.ascii_byte_at(0), b'a');\n        assert_eq!(slice.ascii_byte_at(1), b'\\xFF');\n        assert_eq!(slice.ascii_byte_at(2), b'\\xFF');\n        assert_eq!(slice.ascii_byte_at(3), b' ');\n        assert_eq!(slice.ascii_byte_at(4), b'\\xFF');\n    }\n\n    #[test]\n    fn wtf8_code_points() {\n        fn c(value: u32) -> CodePoint { CodePoint::from_u32(value).unwrap() }\n        fn cp(string: &Wtf8Buf) -> Vec<Option<char>> {\n            string.code_points().map(|c| c.to_char()).collect::<Vec<_>>()\n        }\n        let mut string = Wtf8Buf::from_str(\"\u00e9 \");\n        assert_eq!(cp(&string), [Some('\u00e9'), Some(' ')]);\n        string.push(c(0xD83D));\n        assert_eq!(cp(&string), [Some('\u00e9'), Some(' '), None]);\n        string.push(c(0xDCA9));\n        assert_eq!(cp(&string), [Some('\u00e9'), Some(' '), Some('\ud83d\udca9')]);\n    }\n\n    #[test]\n    fn wtf8_as_str() {\n        assert_eq!(Wtf8::from_str(\"\").as_str(), Some(\"\"));\n        assert_eq!(Wtf8::from_str(\"a\u00e9 \ud83d\udca9\").as_str(), Some(\"a\u00e9 \ud83d\udca9\"));\n        let mut string = Wtf8Buf::new();\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        assert_eq!(string.as_str(), None);\n    }\n\n    #[test]\n    fn wtf8_to_string_lossy() {\n        assert_eq!(Wtf8::from_str(\"\").to_string_lossy(), Cow::Borrowed(\"\"));\n        assert_eq!(Wtf8::from_str(\"a\u00e9 \ud83d\udca9\").to_string_lossy(), Cow::Borrowed(\"a\u00e9 \ud83d\udca9\"));\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\");\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        let expected: Cow<str> = Cow::Owned(String::from(\"a\u00e9 \ud83d\udca9\ufffd\"));\n        assert_eq!(string.to_string_lossy(), expected);\n    }\n\n    #[test]\n    fn wtf8_display() {\n        fn d(b: &[u8]) -> String {\n            (&unsafe { Wtf8::from_bytes_unchecked(b) }).to_string()\n        }\n\n        assert_eq!(\"\", d(\"\".as_bytes()));\n        assert_eq!(\"a\u00e9 \ud83d\udca9\", d(\"a\u00e9 \ud83d\udca9\".as_bytes()));\n\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \ud83d\udca9\");\n        string.push(CodePoint::from_u32(0xD800).unwrap());\n        assert_eq!(\"a\u00e9 \ud83d\udca9\ufffd\", d(string.as_inner()));\n    }\n\n    #[test]\n    fn wtf8_encode_wide() {\n        let mut string = Wtf8Buf::from_str(\"a\u00e9 \");\n        string.push(CodePoint::from_u32(0xD83D).unwrap());\n        string.push_char('\ud83d\udca9');\n        assert_eq!(string.encode_wide().collect::<Vec<_>>(),\n                   vec![0x61, 0xE9, 0x20, 0xD83D, 0xD83D, 0xDCA9]);\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![allow(dead_code)]\n\nuse fmt::{Formatter, Result, Write};\nuse core::str::lossy::{Utf8Lossy, Utf8LossyChunk};\n\npub fn debug_fmt_bytestring(slice: &[u8], f: &mut Formatter) -> Result {\n    // Writes out a valid unicode string with the correct escape sequences\n    fn write_str_escaped(f: &mut Formatter, s: &str) -> Result {\n        for c in s.chars().flat_map(|c| c.escape_debug()) {\n            f.write_char(c)?\n        }\n        Ok(())\n    }\n\n    f.write_str(\"\\\"\")?;\n    for Utf8LossyChunk { valid, broken } in Utf8Lossy::from_bytes(slice).chunks() {\n        write_str_escaped(f, valid)?;\n        for b in broken {\n            write!(f, \"\\\\x{:02X}\", b)?;\n        }\n    }\n    f.write_str(\"\\\"\")\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use fmt::{Formatter, Result, Debug};\n\n    #[test]\n    fn smoke() {\n        struct Helper<'a>(&'a [u8]);\n\n        impl<'a> Debug for Helper<'a> {\n            fn fmt(&self, f: &mut Formatter) -> Result {\n                debug_fmt_bytestring(self.0, f)\n            }\n        }\n\n        let input =      b\"\\xF0hello,\\tworld\";\n        let expected = r#\"\"\\xF0hello,\\tworld\"\"#;\n        let output = format!(\"{:?}\", Helper(input));\n\n        assert!(output == expected);\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse borrow::{Borrow, Cow};\nuse fmt;\nuse ops;\nuse cmp;\nuse hash::{Hash, Hasher};\nuse rc::Rc;\nuse sync::Arc;\n\nuse sys::os_str::{Buf, Slice};\nuse sys_common::{AsInner, IntoInner, FromInner};\n\n/// A type that can represent owned, mutable platform-native strings, but is\n/// cheaply inter-convertible with Rust strings.\n///\n/// The need for this type arises from the fact that:\n///\n/// * On Unix systems, strings are often arbitrary sequences of non-zero\n///   bytes, in many cases interpreted as UTF-8.\n///\n/// * On Windows, strings are often arbitrary sequences of non-zero 16-bit\n///   values, interpreted as UTF-16 when it is valid to do so.\n///\n/// * In Rust, strings are always valid UTF-8, which may contain zeros.\n///\n/// `OsString` and [`OsStr`] bridge this gap by simultaneously representing Rust\n/// and platform-native string values, and in particular allowing a Rust string\n/// to be converted into an \"OS\" string with no cost if possible.  A consequence\n/// of this is that `OsString` instances are *not* `NUL` terminated; in order\n/// to pass to e.g. Unix system call, you should create a [`CStr`].\n///\n/// `OsString` is to [`&OsStr`] as [`String`] is to [`&str`]: the former\n/// in each pair are owned strings; the latter are borrowed\n/// references.\n///\n/// # Creating an `OsString`\n///\n/// **From a Rust string**: `OsString` implements\n/// [`From`]`<`[`String`]`>`, so you can use `my_string.from` to\n/// create an `OsString` from a normal Rust string.\n///\n/// **From slices:** Just like you can start with an empty Rust\n/// [`String`] and then [`push_str`][String.push_str] `&str`\n/// sub-string slices into it, you can create an empty `OsString` with\n/// the [`new`] method and then push string slices into it with the\n/// [`push`] method.\n///\n/// # Extracting a borrowed reference to the whole OS string\n///\n/// You can use the [`as_os_str`] method to get an `&`[`OsStr`] from\n/// an `OsString`; this is effectively a borrowed reference to the\n/// whole string.\n///\n/// # Conversions\n///\n/// See the [module's toplevel documentation about conversions][conversions] for a discussion on\n/// the traits which `OsString` implements for [conversions] from/to native representations.\n///\n/// [`OsStr`]: struct.OsStr.html\n/// [`&OsStr`]: struct.OsStr.html\n/// [`CStr`]: struct.CStr.html\n/// [`From`]: ../convert/trait.From.html\n/// [`String`]: ../string/struct.String.html\n/// [`&str`]: ../primitive.str.html\n/// [`u8`]: ../primitive.u8.html\n/// [`u16`]: ../primitive.u16.html\n/// [String.push_str]: ../string/struct.String.html#method.push_str\n/// [`new`]: #method.new\n/// [`push`]: #method.push\n/// [`as_os_str`]: #method.as_os_str\n/// [conversions]: index.html#conversions\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct OsString {\n    inner: Buf\n}\n\n/// Borrowed reference to an OS string (see [`OsString`]).\n///\n/// This type represents a borrowed reference to a string in the operating system's preferred\n/// representation.\n///\n/// `&OsStr` is to [`OsString`] as [`&str`] is to [`String`]: the former in each pair are borrowed\n/// references; the latter are owned strings.\n///\n/// See the [module's toplevel documentation about conversions][conversions] for a discussion on\n/// the traits which `OsStr` implements for [conversions] from/to native representations.\n///\n/// [`OsString`]: struct.OsString.html\n/// [`&str`]: ../primitive.str.html\n/// [`String`]: ../string/struct.String.html\n/// [conversions]: index.html#conversions\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct OsStr {\n    inner: Slice\n}\n\nimpl OsString {\n    /// Constructs a new empty `OsString`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let os_string = OsString::new();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> OsString {\n        OsString { inner: Buf::from_string(String::new()) }\n    }\n\n    /// Converts to an [`OsStr`] slice.\n    ///\n    /// [`OsStr`]: struct.OsStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{OsString, OsStr};\n    ///\n    /// let os_string = OsString::from(\"foo\");\n    /// let os_str = OsStr::new(\"foo\");\n    /// assert_eq!(os_string.as_os_str(), os_str);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_os_str(&self) -> &OsStr {\n        self\n    }\n\n    /// Converts the `OsString` into a [`String`] if it contains valid Unicode data.\n    ///\n    /// On failure, ownership of the original `OsString` is returned.\n    ///\n    /// [`String`]: ../../std/string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let os_string = OsString::from(\"foo\");\n    /// let string = os_string.into_string();\n    /// assert_eq!(string, Ok(String::from(\"foo\")));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_string(self) -> Result<String, OsString> {\n        self.inner.into_string().map_err(|buf| OsString { inner: buf} )\n    }\n\n    /// Extends the string with the given [`&OsStr`] slice.\n    ///\n    /// [`&OsStr`]: struct.OsStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut os_string = OsString::from(\"foo\");\n    /// os_string.push(\"bar\");\n    /// assert_eq!(&os_string, \"foobar\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn push<T: AsRef<OsStr>>(&mut self, s: T) {\n        self.inner.push_slice(&s.as_ref().inner)\n    }\n\n    /// Creates a new `OsString` with the given capacity.\n    ///\n    /// The string will be able to hold exactly `capacity` length units of other\n    /// OS strings without reallocating. If `capacity` is 0, the string will not\n    /// allocate.\n    ///\n    /// See main `OsString` documentation information about encoding.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut os_string = OsString::with_capacity(10);\n    /// let capacity = os_string.capacity();\n    ///\n    /// // This push is done without reallocating\n    /// os_string.push(\"foo\");\n    ///\n    /// assert_eq!(capacity, os_string.capacity());\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn with_capacity(capacity: usize) -> OsString {\n        OsString {\n            inner: Buf::with_capacity(capacity)\n        }\n    }\n\n    /// Truncates the `OsString` to zero length.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut os_string = OsString::from(\"foo\");\n    /// assert_eq!(&os_string, \"foo\");\n    ///\n    /// os_string.clear();\n    /// assert_eq!(&os_string, \"\");\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn clear(&mut self) {\n        self.inner.clear()\n    }\n\n    /// Returns the capacity this `OsString` can hold without reallocating.\n    ///\n    /// See `OsString` introduction for information about encoding.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut os_string = OsString::with_capacity(10);\n    /// assert!(os_string.capacity() >= 10);\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn capacity(&self) -> usize {\n        self.inner.capacity()\n    }\n\n    /// Reserves capacity for at least `additional` more capacity to be inserted\n    /// in the given `OsString`.\n    ///\n    /// The collection may reserve more space to avoid frequent reallocations.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut s = OsString::new();\n    /// s.reserve(10);\n    /// assert!(s.capacity() >= 10);\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn reserve(&mut self, additional: usize) {\n        self.inner.reserve(additional)\n    }\n\n    /// Reserves the minimum capacity for exactly `additional` more capacity to\n    /// be inserted in the given `OsString`. Does nothing if the capacity is\n    /// already sufficient.\n    ///\n    /// Note that the allocator may give the collection more space than it\n    /// requests. Therefore capacity can not be relied upon to be precisely\n    /// minimal. Prefer reserve if future insertions are expected.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut s = OsString::new();\n    /// s.reserve_exact(10);\n    /// assert!(s.capacity() >= 10);\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn reserve_exact(&mut self, additional: usize) {\n        self.inner.reserve_exact(additional)\n    }\n\n    /// Shrinks the capacity of the `OsString` to match its length.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsString;\n    ///\n    /// let mut s = OsString::from(\"foo\");\n    ///\n    /// s.reserve(100);\n    /// assert!(s.capacity() >= 100);\n    ///\n    /// s.shrink_to_fit();\n    /// assert_eq!(3, s.capacity());\n    /// ```\n    #[stable(feature = \"osstring_shrink_to_fit\", since = \"1.19.0\")]\n    pub fn shrink_to_fit(&mut self) {\n        self.inner.shrink_to_fit()\n    }\n\n    /// Shrinks the capacity of the `OsString` with a lower bound.\n    ///\n    /// The capacity will remain at least as large as both the length\n    /// and the supplied value.\n    ///\n    /// Panics if the current capacity is smaller than the supplied\n    /// minimum capacity.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(shrink_to)]\n    /// use std::ffi::OsString;\n    ///\n    /// let mut s = OsString::from(\"foo\");\n    ///\n    /// s.reserve(100);\n    /// assert!(s.capacity() >= 100);\n    ///\n    /// s.shrink_to(10);\n    /// assert!(s.capacity() >= 10);\n    /// s.shrink_to(0);\n    /// assert!(s.capacity() >= 3);\n    /// ```\n    #[inline]\n    #[unstable(feature = \"shrink_to\", reason = \"new API\", issue=\"0\")]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        self.inner.shrink_to(min_capacity)\n    }\n\n    /// Converts this `OsString` into a boxed [`OsStr`].\n    ///\n    /// [`OsStr`]: struct.OsStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{OsString, OsStr};\n    ///\n    /// let s = OsString::from(\"hello\");\n    ///\n    /// let b: Box<OsStr> = s.into_boxed_os_str();\n    /// ```\n    #[stable(feature = \"into_boxed_os_str\", since = \"1.20.0\")]\n    pub fn into_boxed_os_str(self) -> Box<OsStr> {\n        let rw = Box::into_raw(self.inner.into_box()) as *mut OsStr;\n        unsafe { Box::from_raw(rw) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl From<String> for OsString {\n    /// Converts a [`String`] into a [`OsString`].\n    ///\n    /// The conversion copies the data, and includes an allocation on the heap.\n    fn from(s: String) -> OsString {\n        OsString { inner: Buf::from_string(s) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for OsString {\n    fn from(s: &'a T) -> OsString {\n        s.as_ref().to_os_string()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Index<ops::RangeFull> for OsString {\n    type Output = OsStr;\n\n    #[inline]\n    fn index(&self, _index: ops::RangeFull) -> &OsStr {\n        OsStr::from_inner(self.inner.as_slice())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Deref for OsString {\n    type Target = OsStr;\n\n    #[inline]\n    fn deref(&self) -> &OsStr {\n        &self[..]\n    }\n}\n\n#[stable(feature = \"osstring_default\", since = \"1.9.0\")]\nimpl Default for OsString {\n    /// Constructs an empty `OsString`.\n    #[inline]\n    fn default() -> OsString {\n        OsString::new()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for OsString {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, formatter)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for OsString {\n    fn eq(&self, other: &OsString) -> bool {\n        &**self == &**other\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq<str> for OsString {\n    fn eq(&self, other: &str) -> bool {\n        &**self == other\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq<OsString> for str {\n    fn eq(&self, other: &OsString) -> bool {\n        &**other == self\n    }\n}\n\n#[stable(feature = \"os_str_str_ref_eq\", since = \"1.29.0\")]\nimpl<'a> PartialEq<&'a str> for OsString {\n    fn eq(&self, other: &&'a str) -> bool {\n        **self == **other\n    }\n}\n\n#[stable(feature = \"os_str_str_ref_eq\", since = \"1.29.0\")]\nimpl<'a> PartialEq<OsString> for &'a str {\n    fn eq(&self, other: &OsString) -> bool {\n        **other == **self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for OsString {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for OsString {\n    #[inline]\n    fn partial_cmp(&self, other: &OsString) -> Option<cmp::Ordering> {\n        (&**self).partial_cmp(&**other)\n    }\n    #[inline]\n    fn lt(&self, other: &OsString) -> bool { &**self < &**other }\n    #[inline]\n    fn le(&self, other: &OsString) -> bool { &**self <= &**other }\n    #[inline]\n    fn gt(&self, other: &OsString) -> bool { &**self > &**other }\n    #[inline]\n    fn ge(&self, other: &OsString) -> bool { &**self >= &**other }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd<str> for OsString {\n    #[inline]\n    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {\n        (&**self).partial_cmp(other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for OsString {\n    #[inline]\n    fn cmp(&self, other: &OsString) -> cmp::Ordering {\n        (&**self).cmp(&**other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Hash for OsString {\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        (&**self).hash(state)\n    }\n}\n\nimpl OsStr {\n    /// Coerces into an `OsStr` slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsStr;\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {\n        s.as_ref()\n    }\n\n    fn from_inner(inner: &Slice) -> &OsStr {\n        unsafe { &*(inner as *const Slice as *const OsStr) }\n    }\n\n    /// Yields a [`&str`] slice if the `OsStr` is valid Unicode.\n    ///\n    /// This conversion may entail doing a check for UTF-8 validity.\n    ///\n    /// [`&str`]: ../../std/primitive.str.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsStr;\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// assert_eq!(os_str.to_str(), Some(\"foo\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_str(&self) -> Option<&str> {\n        self.inner.to_str()\n    }\n\n    /// Converts an `OsStr` to a [`Cow`]`<`[`str`]`>`.\n    ///\n    /// Any non-Unicode sequences are replaced with\n    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].\n    ///\n    /// [`Cow`]: ../../std/borrow/enum.Cow.html\n    /// [`str`]: ../../std/primitive.str.html\n    /// [U+FFFD]: ../../std/char/constant.REPLACEMENT_CHARACTER.html\n    ///\n    /// # Examples\n    ///\n    /// Calling `to_string_lossy` on an `OsStr` with valid unicode:\n    ///\n    /// ```\n    /// use std::ffi::OsStr;\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// assert_eq!(os_str.to_string_lossy(), \"foo\");\n    /// ```\n    ///\n    /// Had `os_str` contained invalid unicode, the `to_string_lossy` call might\n    /// have returned `\"fo\ufffd\"`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_string_lossy(&self) -> Cow<str> {\n        self.inner.to_string_lossy()\n    }\n\n    /// Copies the slice into an owned [`OsString`].\n    ///\n    /// [`OsString`]: struct.OsString.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{OsStr, OsString};\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// let os_string = os_str.to_os_string();\n    /// assert_eq!(os_string, OsString::from(\"foo\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_os_string(&self) -> OsString {\n        OsString { inner: self.inner.to_owned() }\n    }\n\n    /// Checks whether the `OsStr` is empty.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsStr;\n    ///\n    /// let os_str = OsStr::new(\"\");\n    /// assert!(os_str.is_empty());\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// assert!(!os_str.is_empty());\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn is_empty(&self) -> bool {\n        self.inner.inner.is_empty()\n    }\n\n    /// Returns the length of this `OsStr`.\n    ///\n    /// Note that this does **not** return the number of bytes in this string\n    /// as, for example, OS strings on Windows are encoded as a list of [`u16`]\n    /// rather than a list of bytes. This number is simply useful for passing to\n    /// other methods like [`OsString::with_capacity`] to avoid reallocations.\n    ///\n    /// See `OsStr` introduction for more information about encoding.\n    ///\n    /// [`u16`]: ../primitive.u16.html\n    /// [`OsString::with_capacity`]: struct.OsString.html#method.with_capacity\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::OsStr;\n    ///\n    /// let os_str = OsStr::new(\"\");\n    /// assert_eq!(os_str.len(), 0);\n    ///\n    /// let os_str = OsStr::new(\"foo\");\n    /// assert_eq!(os_str.len(), 3);\n    /// ```\n    #[stable(feature = \"osstring_simple_functions\", since = \"1.9.0\")]\n    pub fn len(&self) -> usize {\n        self.inner.inner.len()\n    }\n\n    /// Converts a [`Box`]`<OsStr>` into an [`OsString`] without copying or allocating.\n    ///\n    /// [`Box`]: ../boxed/struct.Box.html\n    /// [`OsString`]: struct.OsString.html\n    #[stable(feature = \"into_boxed_os_str\", since = \"1.20.0\")]\n    pub fn into_os_string(self: Box<OsStr>) -> OsString {\n        let boxed = unsafe { Box::from_raw(Box::into_raw(self) as *mut Slice) };\n        OsString { inner: Buf::from_box(boxed) }\n    }\n\n    /// Gets the underlying byte representation.\n    ///\n    /// Note: it is *crucial* that this API is private, to avoid\n    /// revealing the internal, platform-specific encodings.\n    fn bytes(&self) -> &[u8] {\n        unsafe { &*(&self.inner as *const _ as *const [u8]) }\n    }\n}\n\n#[stable(feature = \"box_from_os_str\", since = \"1.17.0\")]\nimpl<'a> From<&'a OsStr> for Box<OsStr> {\n    fn from(s: &'a OsStr) -> Box<OsStr> {\n        let rw = Box::into_raw(s.inner.into_box()) as *mut OsStr;\n        unsafe { Box::from_raw(rw) }\n    }\n}\n\n#[stable(feature = \"os_string_from_box\", since = \"1.18.0\")]\nimpl From<Box<OsStr>> for OsString {\n    /// Converts a `Box<OsStr>` into a `OsString` without copying or allocating.\n    ///\n    /// [`Box`]: ../boxed/struct.Box.html\n    /// [`OsString`]: ../ffi/struct.OsString.html\n    fn from(boxed: Box<OsStr>) -> OsString {\n        boxed.into_os_string()\n    }\n}\n\n#[stable(feature = \"box_from_os_string\", since = \"1.20.0\")]\nimpl From<OsString> for Box<OsStr> {\n    /// Converts a [`OsString`] into a [`Box`]`<OsStr>` without copying or allocating.\n    ///\n    /// [`Box`]: ../boxed/struct.Box.html\n    /// [`OsString`]: ../ffi/struct.OsString.html\n    fn from(s: OsString) -> Box<OsStr> {\n        s.into_boxed_os_str()\n    }\n}\n\n#[stable(feature = \"more_box_slice_clone\", since = \"1.29.0\")]\nimpl Clone for Box<OsStr> {\n    #[inline]\n    fn clone(&self) -> Self {\n        self.to_os_string().into_boxed_os_str()\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<OsString> for Arc<OsStr> {\n    /// Converts a [`OsString`] into a [`Arc`]`<OsStr>` without copying or allocating.\n    ///\n    /// [`Arc`]: ../sync/struct.Arc.html\n    /// [`OsString`]: ../ffi/struct.OsString.html\n    #[inline]\n    fn from(s: OsString) -> Arc<OsStr> {\n        let arc = s.inner.into_arc();\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const OsStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a OsStr> for Arc<OsStr> {\n    #[inline]\n    fn from(s: &OsStr) -> Arc<OsStr> {\n        let arc = s.inner.into_arc();\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const OsStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<OsString> for Rc<OsStr> {\n    /// Converts a [`OsString`] into a [`Rc`]`<OsStr>` without copying or allocating.\n    ///\n    /// [`Rc`]: ../rc/struct.Rc.html\n    /// [`OsString`]: ../ffi/struct.OsString.html\n    #[inline]\n    fn from(s: OsString) -> Rc<OsStr> {\n        let rc = s.inner.into_rc();\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const OsStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a OsStr> for Rc<OsStr> {\n    #[inline]\n    fn from(s: &OsStr) -> Rc<OsStr> {\n        let rc = s.inner.into_rc();\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const OsStr) }\n    }\n}\n\n#[stable(feature = \"cow_from_osstr\", since = \"1.28.0\")]\nimpl<'a> From<OsString> for Cow<'a, OsStr> {\n    #[inline]\n    fn from(s: OsString) -> Cow<'a, OsStr> {\n        Cow::Owned(s)\n    }\n}\n\n#[stable(feature = \"cow_from_osstr\", since = \"1.28.0\")]\nimpl<'a> From<&'a OsStr> for Cow<'a, OsStr> {\n    #[inline]\n    fn from(s: &'a OsStr) -> Cow<'a, OsStr> {\n        Cow::Borrowed(s)\n    }\n}\n\n#[stable(feature = \"cow_from_osstr\", since = \"1.28.0\")]\nimpl<'a> From<&'a OsString> for Cow<'a, OsStr> {\n    #[inline]\n    fn from(s: &'a OsString) -> Cow<'a, OsStr> {\n        Cow::Borrowed(s.as_os_str())\n    }\n}\n\n#[stable(feature = \"osstring_from_cow_osstr\", since = \"1.28.0\")]\nimpl<'a> From<Cow<'a, OsStr>> for OsString {\n    #[inline]\n    fn from(s: Cow<'a, OsStr>) -> Self {\n        s.into_owned()\n    }\n}\n\n#[stable(feature = \"box_default_extra\", since = \"1.17.0\")]\nimpl Default for Box<OsStr> {\n    fn default() -> Box<OsStr> {\n        let rw = Box::into_raw(Slice::empty_box()) as *mut OsStr;\n        unsafe { Box::from_raw(rw) }\n    }\n}\n\n#[stable(feature = \"osstring_default\", since = \"1.9.0\")]\nimpl<'a> Default for &'a OsStr {\n    /// Creates an empty `OsStr`.\n    #[inline]\n    fn default() -> &'a OsStr {\n        OsStr::new(\"\")\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for OsStr {\n    fn eq(&self, other: &OsStr) -> bool {\n        self.bytes().eq(other.bytes())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq<str> for OsStr {\n    fn eq(&self, other: &str) -> bool {\n        *self == *OsStr::new(other)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq<OsStr> for str {\n    fn eq(&self, other: &OsStr) -> bool {\n        *other == *OsStr::new(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for OsStr {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for OsStr {\n    #[inline]\n    fn partial_cmp(&self, other: &OsStr) -> Option<cmp::Ordering> {\n        self.bytes().partial_cmp(other.bytes())\n    }\n    #[inline]\n    fn lt(&self, other: &OsStr) -> bool { self.bytes().lt(other.bytes()) }\n    #[inline]\n    fn le(&self, other: &OsStr) -> bool { self.bytes().le(other.bytes()) }\n    #[inline]\n    fn gt(&self, other: &OsStr) -> bool { self.bytes().gt(other.bytes()) }\n    #[inline]\n    fn ge(&self, other: &OsStr) -> bool { self.bytes().ge(other.bytes()) }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd<str> for OsStr {\n    #[inline]\n    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {\n        self.partial_cmp(OsStr::new(other))\n    }\n}\n\n// FIXME (#19470): cannot provide PartialOrd<OsStr> for str until we\n// have more flexible coherence rules.\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for OsStr {\n    #[inline]\n    fn cmp(&self, other: &OsStr) -> cmp::Ordering { self.bytes().cmp(other.bytes()) }\n}\n\nmacro_rules! impl_cmp {\n    ($lhs:ty, $rhs: ty) => {\n        #[stable(feature = \"cmp_os_str\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialEq<$rhs> for $lhs {\n            #[inline]\n            fn eq(&self, other: &$rhs) -> bool { <OsStr as PartialEq>::eq(self, other) }\n        }\n\n        #[stable(feature = \"cmp_os_str\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialEq<$lhs> for $rhs {\n            #[inline]\n            fn eq(&self, other: &$lhs) -> bool { <OsStr as PartialEq>::eq(self, other) }\n        }\n\n        #[stable(feature = \"cmp_os_str\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$rhs> for $lhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {\n                <OsStr as PartialOrd>::partial_cmp(self, other)\n            }\n        }\n\n        #[stable(feature = \"cmp_os_str\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$lhs> for $rhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {\n                <OsStr as PartialOrd>::partial_cmp(self, other)\n            }\n        }\n    }\n}\n\nimpl_cmp!(OsString, OsStr);\nimpl_cmp!(OsString, &'a OsStr);\nimpl_cmp!(Cow<'a, OsStr>, OsStr);\nimpl_cmp!(Cow<'a, OsStr>, &'b OsStr);\nimpl_cmp!(Cow<'a, OsStr>, OsString);\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Hash for OsStr {\n    #[inline]\n    fn hash<H: Hasher>(&self, state: &mut H) {\n        self.bytes().hash(state)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for OsStr {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.inner, formatter)\n    }\n}\n\nimpl OsStr {\n    pub(crate) fn display(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(&self.inner, formatter)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Borrow<OsStr> for OsString {\n    fn borrow(&self) -> &OsStr { &self[..] }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToOwned for OsStr {\n    type Owned = OsString;\n    fn to_owned(&self) -> OsString {\n        self.to_os_string()\n    }\n    fn clone_into(&self, target: &mut OsString) {\n        target.clear();\n        target.push(self);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for OsStr {\n    fn as_ref(&self) -> &OsStr {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for OsString {\n    fn as_ref(&self) -> &OsStr {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for str {\n    fn as_ref(&self) -> &OsStr {\n        OsStr::from_inner(Slice::from_str(self))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for String {\n    fn as_ref(&self) -> &OsStr {\n        (&**self).as_ref()\n    }\n}\n\nimpl FromInner<Buf> for OsString {\n    fn from_inner(buf: Buf) -> OsString {\n        OsString { inner: buf }\n    }\n}\n\nimpl IntoInner<Buf> for OsString {\n    fn into_inner(self) -> Buf {\n        self.inner\n    }\n}\n\nimpl AsInner<Slice> for OsStr {\n    fn as_inner(&self) -> &Slice {\n        &self.inner\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use sys_common::{AsInner, IntoInner};\n\n    use rc::Rc;\n    use sync::Arc;\n\n    #[test]\n    fn test_os_string_with_capacity() {\n        let os_string = OsString::with_capacity(0);\n        assert_eq!(0, os_string.inner.into_inner().capacity());\n\n        let os_string = OsString::with_capacity(10);\n        assert_eq!(10, os_string.inner.into_inner().capacity());\n\n        let mut os_string = OsString::with_capacity(0);\n        os_string.push(\"abc\");\n        assert!(os_string.inner.into_inner().capacity() >= 3);\n    }\n\n    #[test]\n    fn test_os_string_clear() {\n        let mut os_string = OsString::from(\"abc\");\n        assert_eq!(3, os_string.inner.as_inner().len());\n\n        os_string.clear();\n        assert_eq!(&os_string, \"\");\n        assert_eq!(0, os_string.inner.as_inner().len());\n    }\n\n    #[test]\n    fn test_os_string_capacity() {\n        let os_string = OsString::with_capacity(0);\n        assert_eq!(0, os_string.capacity());\n\n        let os_string = OsString::with_capacity(10);\n        assert_eq!(10, os_string.capacity());\n\n        let mut os_string = OsString::with_capacity(0);\n        os_string.push(\"abc\");\n        assert!(os_string.capacity() >= 3);\n    }\n\n    #[test]\n    fn test_os_string_reserve() {\n        let mut os_string = OsString::new();\n        assert_eq!(os_string.capacity(), 0);\n\n        os_string.reserve(2);\n        assert!(os_string.capacity() >= 2);\n\n        for _ in 0..16 {\n            os_string.push(\"a\");\n        }\n\n        assert!(os_string.capacity() >= 16);\n        os_string.reserve(16);\n        assert!(os_string.capacity() >= 32);\n\n        os_string.push(\"a\");\n\n        os_string.reserve(16);\n        assert!(os_string.capacity() >= 33)\n    }\n\n    #[test]\n    fn test_os_string_reserve_exact() {\n        let mut os_string = OsString::new();\n        assert_eq!(os_string.capacity(), 0);\n\n        os_string.reserve_exact(2);\n        assert!(os_string.capacity() >= 2);\n\n        for _ in 0..16 {\n            os_string.push(\"a\");\n        }\n\n        assert!(os_string.capacity() >= 16);\n        os_string.reserve_exact(16);\n        assert!(os_string.capacity() >= 32);\n\n        os_string.push(\"a\");\n\n        os_string.reserve_exact(16);\n        assert!(os_string.capacity() >= 33)\n    }\n\n    #[test]\n    fn test_os_string_default() {\n        let os_string: OsString = Default::default();\n        assert_eq!(\"\", &os_string);\n    }\n\n    #[test]\n    fn test_os_str_is_empty() {\n        let mut os_string = OsString::new();\n        assert!(os_string.is_empty());\n\n        os_string.push(\"abc\");\n        assert!(!os_string.is_empty());\n\n        os_string.clear();\n        assert!(os_string.is_empty());\n    }\n\n    #[test]\n    fn test_os_str_len() {\n        let mut os_string = OsString::new();\n        assert_eq!(0, os_string.len());\n\n        os_string.push(\"abc\");\n        assert_eq!(3, os_string.len());\n\n        os_string.clear();\n        assert_eq!(0, os_string.len());\n    }\n\n    #[test]\n    fn test_os_str_default() {\n        let os_str: &OsStr = Default::default();\n        assert_eq!(\"\", os_str);\n    }\n\n    #[test]\n    fn into_boxed() {\n        let orig = \"Hello, world!\";\n        let os_str = OsStr::new(orig);\n        let boxed: Box<OsStr> = Box::from(os_str);\n        let os_string = os_str.to_owned().into_boxed_os_str().into_os_string();\n        assert_eq!(os_str, &*boxed);\n        assert_eq!(&*boxed, &*os_string);\n        assert_eq!(&*os_string, os_str);\n    }\n\n    #[test]\n    fn boxed_default() {\n        let boxed = <Box<OsStr>>::default();\n        assert!(boxed.is_empty());\n    }\n\n    #[test]\n    fn test_os_str_clone_into() {\n        let mut os_string = OsString::with_capacity(123);\n        os_string.push(\"hello\");\n        let os_str = OsStr::new(\"bonjour\");\n        os_str.clone_into(&mut os_string);\n        assert_eq!(os_str, os_string);\n        assert!(os_string.capacity() >= 123);\n    }\n\n    #[test]\n    fn into_rc() {\n        let orig = \"Hello, world!\";\n        let os_str = OsStr::new(orig);\n        let rc: Rc<OsStr> = Rc::from(os_str);\n        let arc: Arc<OsStr> = Arc::from(os_str);\n\n        assert_eq!(&*rc, os_str);\n        assert_eq!(&*arc, os_str);\n\n        let rc2: Rc<OsStr> = Rc::from(os_str.to_owned());\n        let arc2: Arc<OsStr> = Arc::from(os_str.to_owned());\n\n        assert_eq!(&*rc2, os_str);\n        assert_eq!(&*arc2, os_str);\n    }\n}\n","// Copyright 2012 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse ascii;\nuse borrow::{Cow, Borrow};\nuse cmp::Ordering;\nuse error::Error;\nuse fmt::{self, Write};\nuse io;\nuse mem;\nuse memchr;\nuse ops;\nuse os::raw::c_char;\nuse ptr;\nuse rc::Rc;\nuse slice;\nuse str::{self, Utf8Error};\nuse sync::Arc;\nuse sys;\n\n/// A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the\n/// middle.\n///\n/// This type serves the purpose of being able to safely generate a\n/// C-compatible string from a Rust byte slice or vector. An instance of this\n/// type is a static guarantee that the underlying bytes contain no interior 0\n/// bytes (\"nul characters\") and that the final byte is 0 (\"nul terminator\").\n///\n/// `CString` is to [`&CStr`] as [`String`] is to [`&str`]: the former\n/// in each pair are owned strings; the latter are borrowed\n/// references.\n///\n/// # Creating a `CString`\n///\n/// A `CString` is created from either a byte slice or a byte vector,\n/// or anything that implements [`Into`]`<`[`Vec`]`<`[`u8`]`>>` (for\n/// example, you can build a `CString` straight out of a [`String`] or\n/// a [`&str`], since both implement that trait).\n///\n/// The [`new`] method will actually check that the provided `&[u8]`\n/// does not have 0 bytes in the middle, and return an error if it\n/// finds one.\n///\n/// # Extracting a raw pointer to the whole C string\n///\n/// `CString` implements a [`as_ptr`] method through the [`Deref`]\n/// trait. This method will give you a `*const c_char` which you can\n/// feed directly to extern functions that expect a nul-terminated\n/// string, like C's `strdup()`.\n///\n/// # Extracting a slice of the whole C string\n///\n/// Alternatively, you can obtain a `&[`[`u8`]`]` slice from a\n/// `CString` with the [`as_bytes`] method. Slices produced in this\n/// way do *not* contain the trailing nul terminator. This is useful\n/// when you will be calling an extern function that takes a `*const\n/// u8` argument which is not necessarily nul-terminated, plus another\n/// argument with the length of the string \u2014 like C's `strndup()`.\n/// You can of course get the slice's length with its\n/// [`len`][slice.len] method.\n///\n/// If you need a `&[`[`u8`]`]` slice *with* the nul terminator, you\n/// can use [`as_bytes_with_nul`] instead.\n///\n/// Once you have the kind of slice you need (with or without a nul\n/// terminator), you can call the slice's own\n/// [`as_ptr`][slice.as_ptr] method to get a raw pointer to pass to\n/// extern functions. See the documentation for that function for a\n/// discussion on ensuring the lifetime of the raw pointer.\n///\n/// [`Into`]: ../convert/trait.Into.html\n/// [`Vec`]: ../vec/struct.Vec.html\n/// [`String`]: ../string/struct.String.html\n/// [`&str`]: ../primitive.str.html\n/// [`u8`]: ../primitive.u8.html\n/// [`new`]: #method.new\n/// [`as_bytes`]: #method.as_bytes\n/// [`as_bytes_with_nul`]: #method.as_bytes_with_nul\n/// [`as_ptr`]: #method.as_ptr\n/// [slice.as_ptr]: ../primitive.slice.html#method.as_ptr\n/// [slice.len]: ../primitive.slice.html#method.len\n/// [`Deref`]: ../ops/trait.Deref.html\n/// [`CStr`]: struct.CStr.html\n/// [`&CStr`]: struct.CStr.html\n///\n/// # Examples\n///\n/// ```ignore (extern-declaration)\n/// # fn main() {\n/// use std::ffi::CString;\n/// use std::os::raw::c_char;\n///\n/// extern {\n///     fn my_printer(s: *const c_char);\n/// }\n///\n/// // We are certain that our string doesn't have 0 bytes in the middle,\n/// // so we can .expect()\n/// let c_to_print = CString::new(\"Hello, world!\").expect(\"CString::new failed\");\n/// unsafe {\n///     my_printer(c_to_print.as_ptr());\n/// }\n/// # }\n/// ```\n///\n/// # Safety\n///\n/// `CString` is intended for working with traditional C-style strings\n/// (a sequence of non-nul bytes terminated by a single nul byte); the\n/// primary use case for these kinds of strings is interoperating with C-like\n/// code. Often you will need to transfer ownership to/from that external\n/// code. It is strongly recommended that you thoroughly read through the\n/// documentation of `CString` before use, as improper ownership management\n/// of `CString` instances can lead to invalid memory accesses, memory leaks,\n/// and other memory errors.\n\n#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct CString {\n    // Invariant 1: the slice ends with a zero byte and has a length of at least one.\n    // Invariant 2: the slice contains only one zero byte.\n    // Improper usage of unsafe function can break Invariant 2, but not Invariant 1.\n    inner: Box<[u8]>,\n}\n\n/// Representation of a borrowed C string.\n///\n/// This type represents a borrowed reference to a nul-terminated\n/// array of bytes. It can be constructed safely from a `&[`[`u8`]`]`\n/// slice, or unsafely from a raw `*const c_char`. It can then be\n/// converted to a Rust [`&str`] by performing UTF-8 validation, or\n/// into an owned [`CString`].\n///\n/// `&CStr` is to [`CString`] as [`&str`] is to [`String`]: the former\n/// in each pair are borrowed references; the latter are owned\n/// strings.\n///\n/// Note that this structure is **not** `repr(C)` and is not recommended to be\n/// placed in the signatures of FFI functions. Instead, safe wrappers of FFI\n/// functions may leverage the unsafe [`from_ptr`] constructor to provide a safe\n/// interface to other consumers.\n///\n/// # Examples\n///\n/// Inspecting a foreign C string:\n///\n/// ```ignore (extern-declaration)\n/// use std::ffi::CStr;\n/// use std::os::raw::c_char;\n///\n/// extern { fn my_string() -> *const c_char; }\n///\n/// unsafe {\n///     let slice = CStr::from_ptr(my_string());\n///     println!(\"string buffer size without nul terminator: {}\", slice.to_bytes().len());\n/// }\n/// ```\n///\n/// Passing a Rust-originating C string:\n///\n/// ```ignore (extern-declaration)\n/// use std::ffi::{CString, CStr};\n/// use std::os::raw::c_char;\n///\n/// fn work(data: &CStr) {\n///     extern { fn work_with(data: *const c_char); }\n///\n///     unsafe { work_with(data.as_ptr()) }\n/// }\n///\n/// let s = CString::new(\"data data data data\").expect(\"CString::new failed\");\n/// work(&s);\n/// ```\n///\n/// Converting a foreign C string into a Rust [`String`]:\n///\n/// ```ignore (extern-declaration)\n/// use std::ffi::CStr;\n/// use std::os::raw::c_char;\n///\n/// extern { fn my_string() -> *const c_char; }\n///\n/// fn my_string_safe() -> String {\n///     unsafe {\n///         CStr::from_ptr(my_string()).to_string_lossy().into_owned()\n///     }\n/// }\n///\n/// println!(\"string: {}\", my_string_safe());\n/// ```\n///\n/// [`u8`]: ../primitive.u8.html\n/// [`&str`]: ../primitive.str.html\n/// [`String`]: ../string/struct.String.html\n/// [`CString`]: struct.CString.html\n/// [`from_ptr`]: #method.from_ptr\n#[derive(Hash)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct CStr {\n    // FIXME: this should not be represented with a DST slice but rather with\n    //        just a raw `c_char` along with some form of marker to make\n    //        this an unsized type. Essentially `sizeof(&CStr)` should be the\n    //        same as `sizeof(&c_char)` but `CStr` should be an unsized type.\n    inner: [c_char]\n}\n\n/// An error indicating that an interior nul byte was found.\n///\n/// While Rust strings may contain nul bytes in the middle, C strings\n/// can't, as that byte would effectively truncate the string.\n///\n/// This error is created by the [`new`][`CString::new`] method on\n/// [`CString`]. See its documentation for more.\n///\n/// [`CString`]: struct.CString.html\n/// [`CString::new`]: struct.CString.html#method.new\n///\n/// # Examples\n///\n/// ```\n/// use std::ffi::{CString, NulError};\n///\n/// let _: NulError = CString::new(b\"f\\0oo\".to_vec()).unwrap_err();\n/// ```\n#[derive(Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct NulError(usize, Vec<u8>);\n\n/// An error indicating that a nul byte was not in the expected position.\n///\n/// The slice used to create a [`CStr`] must have one and only one nul\n/// byte at the end of the slice.\n///\n/// This error is created by the\n/// [`from_bytes_with_nul`][`CStr::from_bytes_with_nul`] method on\n/// [`CStr`]. See its documentation for more.\n///\n/// [`CStr`]: struct.CStr.html\n/// [`CStr::from_bytes_with_nul`]: struct.CStr.html#method.from_bytes_with_nul\n///\n/// # Examples\n///\n/// ```\n/// use std::ffi::{CStr, FromBytesWithNulError};\n///\n/// let _: FromBytesWithNulError = CStr::from_bytes_with_nul(b\"f\\0oo\").unwrap_err();\n/// ```\n#[derive(Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"cstr_from_bytes\", since = \"1.10.0\")]\npub struct FromBytesWithNulError {\n    kind: FromBytesWithNulErrorKind,\n}\n\n#[derive(Clone, PartialEq, Eq, Debug)]\nenum FromBytesWithNulErrorKind {\n    InteriorNul(usize),\n    NotNulTerminated,\n}\n\nimpl FromBytesWithNulError {\n    fn interior_nul(pos: usize) -> FromBytesWithNulError {\n        FromBytesWithNulError {\n            kind: FromBytesWithNulErrorKind::InteriorNul(pos),\n        }\n    }\n    fn not_nul_terminated() -> FromBytesWithNulError {\n        FromBytesWithNulError {\n            kind: FromBytesWithNulErrorKind::NotNulTerminated,\n        }\n    }\n}\n\n/// An error indicating invalid UTF-8 when converting a [`CString`] into a [`String`].\n///\n/// `CString` is just a wrapper over a buffer of bytes with a nul\n/// terminator; [`into_string`][`CString::into_string`] performs UTF-8\n/// validation on those bytes and may return this error.\n///\n/// This `struct` is created by the\n/// [`into_string`][`CString::into_string`] method on [`CString`]. See\n/// its documentation for more.\n///\n/// [`String`]: ../string/struct.String.html\n/// [`CString`]: struct.CString.html\n/// [`CString::into_string`]: struct.CString.html#method.into_string\n#[derive(Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"cstring_into\", since = \"1.7.0\")]\npub struct IntoStringError {\n    inner: CString,\n    error: Utf8Error,\n}\n\nimpl CString {\n    /// Creates a new C-compatible string from a container of bytes.\n    ///\n    /// This function will consume the provided data and use the\n    /// underlying bytes to construct a new string, ensuring that\n    /// there is a trailing 0 byte. This trailing 0 byte will be\n    /// appended by this function; the provided data should *not*\n    /// contain any 0 bytes in it.\n    ///\n    /// # Examples\n    ///\n    /// ```ignore (extern-declaration)\n    /// use std::ffi::CString;\n    /// use std::os::raw::c_char;\n    ///\n    /// extern { fn puts(s: *const c_char); }\n    ///\n    /// let to_print = CString::new(\"Hello!\").expect(\"CString::new failed\");\n    /// unsafe {\n    ///     puts(to_print.as_ptr());\n    /// }\n    /// ```\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if the supplied bytes contain an\n    /// internal 0 byte. The [`NulError`] returned will contain the bytes as well as\n    /// the position of the nul byte.\n    ///\n    /// [`NulError`]: struct.NulError.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError> {\n        Self::_new(t.into())\n    }\n\n    fn _new(bytes: Vec<u8>) -> Result<CString, NulError> {\n        match memchr::memchr(0, &bytes) {\n            Some(i) => Err(NulError(i, bytes)),\n            None => Ok(unsafe { CString::from_vec_unchecked(bytes) }),\n        }\n    }\n\n    /// Creates a C-compatible string by consuming a byte vector,\n    /// without checking for interior 0 bytes.\n    ///\n    /// This method is equivalent to [`new`] except that no runtime assertion\n    /// is made that `v` contains no 0 bytes, and it requires an actual\n    /// byte vector, not anything that can be converted to one with Into.\n    ///\n    /// [`new`]: #method.new\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let raw = b\"foo\".to_vec();\n    /// unsafe {\n    ///     let c_string = CString::from_vec_unchecked(raw);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn from_vec_unchecked(mut v: Vec<u8>) -> CString {\n        v.reserve_exact(1);\n        v.push(0);\n        CString { inner: v.into_boxed_slice() }\n    }\n\n    /// Retakes ownership of a `CString` that was transferred to C via [`into_raw`].\n    ///\n    /// Additionally, the length of the string will be recalculated from the pointer.\n    ///\n    /// # Safety\n    ///\n    /// This should only ever be called with a pointer that was earlier\n    /// obtained by calling [`into_raw`] on a `CString`. Other usage (e.g. trying to take\n    /// ownership of a string that was allocated by foreign code) is likely to lead\n    /// to undefined behavior or allocator corruption.\n    ///\n    /// > **Note:** If you need to borrow a string that was allocated by\n    /// > foreign code, use [`CStr`]. If you need to take ownership of\n    /// > a string that was allocated by foreign code, you will need to\n    /// > make your own provisions for freeing it appropriately, likely\n    /// > with the foreign code's API to do that.\n    ///\n    /// [`into_raw`]: #method.into_raw\n    /// [`CStr`]: struct.CStr.html\n    ///\n    /// # Examples\n    ///\n    /// Create a `CString`, pass ownership to an `extern` function (via raw pointer), then retake\n    /// ownership with `from_raw`:\n    ///\n    /// ```ignore (extern-declaration)\n    /// use std::ffi::CString;\n    /// use std::os::raw::c_char;\n    ///\n    /// extern {\n    ///     fn some_extern_function(s: *mut c_char);\n    /// }\n    ///\n    /// let c_string = CString::new(\"Hello!\").expect(\"CString::new failed\");\n    /// let raw = c_string.into_raw();\n    /// unsafe {\n    ///     some_extern_function(raw);\n    ///     let c_string = CString::from_raw(raw);\n    /// }\n    /// ```\n    #[stable(feature = \"cstr_memory\", since = \"1.4.0\")]\n    pub unsafe fn from_raw(ptr: *mut c_char) -> CString {\n        let len = sys::strlen(ptr) + 1; // Including the NUL byte\n        let slice = slice::from_raw_parts_mut(ptr, len as usize);\n        CString { inner: Box::from_raw(slice as *mut [c_char] as *mut [u8]) }\n    }\n\n    /// Consumes the `CString` and transfers ownership of the string to a C caller.\n    ///\n    /// The pointer which this function returns must be returned to Rust and reconstituted using\n    /// [`from_raw`] to be properly deallocated. Specifically, one\n    /// should *not* use the standard C `free()` function to deallocate\n    /// this string.\n    ///\n    /// Failure to call [`from_raw`] will lead to a memory leak.\n    ///\n    /// [`from_raw`]: #method.from_raw\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(\"foo\").expect(\"CString::new failed\");\n    ///\n    /// let ptr = c_string.into_raw();\n    ///\n    /// unsafe {\n    ///     assert_eq!(b'f', *ptr as u8);\n    ///     assert_eq!(b'o', *ptr.offset(1) as u8);\n    ///     assert_eq!(b'o', *ptr.offset(2) as u8);\n    ///     assert_eq!(b'\\0', *ptr.offset(3) as u8);\n    ///\n    ///     // retake pointer to free memory\n    ///     let _ = CString::from_raw(ptr);\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"cstr_memory\", since = \"1.4.0\")]\n    pub fn into_raw(self) -> *mut c_char {\n        Box::into_raw(self.into_inner()) as *mut c_char\n    }\n\n    /// Converts the `CString` into a [`String`] if it contains valid UTF-8 data.\n    ///\n    /// On failure, ownership of the original `CString` is returned.\n    ///\n    /// [`String`]: ../string/struct.String.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let valid_utf8 = vec![b'f', b'o', b'o'];\n    /// let cstring = CString::new(valid_utf8).expect(\"CString::new failed\");\n    /// assert_eq!(cstring.into_string().expect(\"into_string() call failed\"), \"foo\");\n    ///\n    /// let invalid_utf8 = vec![b'f', 0xff, b'o', b'o'];\n    /// let cstring = CString::new(invalid_utf8).expect(\"CString::new failed\");\n    /// let err = cstring.into_string().err().expect(\"into_string().err() failed\");\n    /// assert_eq!(err.utf8_error().valid_up_to(), 1);\n    /// ```\n\n    #[stable(feature = \"cstring_into\", since = \"1.7.0\")]\n    pub fn into_string(self) -> Result<String, IntoStringError> {\n        String::from_utf8(self.into_bytes())\n            .map_err(|e| IntoStringError {\n                error: e.utf8_error(),\n                inner: unsafe { CString::from_vec_unchecked(e.into_bytes()) },\n            })\n    }\n\n    /// Consumes the `CString` and returns the underlying byte buffer.\n    ///\n    /// The returned buffer does **not** contain the trailing nul\n    /// terminator, and it is guaranteed to not have any interior nul\n    /// bytes.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(\"foo\").expect(\"CString::new failed\");\n    /// let bytes = c_string.into_bytes();\n    /// assert_eq!(bytes, vec![b'f', b'o', b'o']);\n    /// ```\n    #[stable(feature = \"cstring_into\", since = \"1.7.0\")]\n    pub fn into_bytes(self) -> Vec<u8> {\n        let mut vec = self.into_inner().into_vec();\n        let _nul = vec.pop();\n        debug_assert_eq!(_nul, Some(0u8));\n        vec\n    }\n\n    /// Equivalent to the [`into_bytes`] function except that the returned vector\n    /// includes the trailing nul terminator.\n    ///\n    /// [`into_bytes`]: #method.into_bytes\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(\"foo\").expect(\"CString::new failed\");\n    /// let bytes = c_string.into_bytes_with_nul();\n    /// assert_eq!(bytes, vec![b'f', b'o', b'o', b'\\0']);\n    /// ```\n    #[stable(feature = \"cstring_into\", since = \"1.7.0\")]\n    pub fn into_bytes_with_nul(self) -> Vec<u8> {\n        self.into_inner().into_vec()\n    }\n\n    /// Returns the contents of this `CString` as a slice of bytes.\n    ///\n    /// The returned slice does **not** contain the trailing nul\n    /// terminator, and it is guaranteed to not have any interior nul\n    /// bytes. If you need the nul terminator, use\n    /// [`as_bytes_with_nul`] instead.\n    ///\n    /// [`as_bytes_with_nul`]: #method.as_bytes_with_nul\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(\"foo\").expect(\"CString::new failed\");\n    /// let bytes = c_string.as_bytes();\n    /// assert_eq!(bytes, &[b'f', b'o', b'o']);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_bytes(&self) -> &[u8] {\n        &self.inner[..self.inner.len() - 1]\n    }\n\n    /// Equivalent to the [`as_bytes`] function except that the returned slice\n    /// includes the trailing nul terminator.\n    ///\n    /// [`as_bytes`]: #method.as_bytes\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(\"foo\").expect(\"CString::new failed\");\n    /// let bytes = c_string.as_bytes_with_nul();\n    /// assert_eq!(bytes, &[b'f', b'o', b'o', b'\\0']);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_bytes_with_nul(&self) -> &[u8] {\n        &self.inner\n    }\n\n    /// Extracts a [`CStr`] slice containing the entire string.\n    ///\n    /// [`CStr`]: struct.CStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{CString, CStr};\n    ///\n    /// let c_string = CString::new(b\"foo\".to_vec()).expect(\"CString::new failed\");\n    /// let c_str = c_string.as_c_str();\n    /// assert_eq!(c_str,\n    ///            CStr::from_bytes_with_nul(b\"foo\\0\").expect(\"CStr::from_bytes_with_nul failed\"));\n    /// ```\n    #[inline]\n    #[stable(feature = \"as_c_str\", since = \"1.20.0\")]\n    pub fn as_c_str(&self) -> &CStr {\n        &*self\n    }\n\n    /// Converts this `CString` into a boxed [`CStr`].\n    ///\n    /// [`CStr`]: struct.CStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{CString, CStr};\n    ///\n    /// let c_string = CString::new(b\"foo\".to_vec()).expect(\"CString::new failed\");\n    /// let boxed = c_string.into_boxed_c_str();\n    /// assert_eq!(&*boxed,\n    ///            CStr::from_bytes_with_nul(b\"foo\\0\").expect(\"CStr::from_bytes_with_nul failed\"));\n    /// ```\n    #[stable(feature = \"into_boxed_c_str\", since = \"1.20.0\")]\n    pub fn into_boxed_c_str(self) -> Box<CStr> {\n        unsafe { Box::from_raw(Box::into_raw(self.into_inner()) as *mut CStr) }\n    }\n\n    /// Bypass \"move out of struct which implements [`Drop`] trait\" restriction.\n    ///\n    /// [`Drop`]: ../ops/trait.Drop.html\n    fn into_inner(self) -> Box<[u8]> {\n        unsafe {\n            let result = ptr::read(&self.inner);\n            mem::forget(self);\n            result\n        }\n    }\n}\n\n// Turns this `CString` into an empty string to prevent\n// memory unsafe code from working by accident. Inline\n// to prevent LLVM from optimizing it away in debug builds.\n#[stable(feature = \"cstring_drop\", since = \"1.13.0\")]\nimpl Drop for CString {\n    #[inline]\n    fn drop(&mut self) {\n        unsafe { *self.inner.get_unchecked_mut(0) = 0; }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Deref for CString {\n    type Target = CStr;\n\n    #[inline]\n    fn deref(&self) -> &CStr {\n        unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for CString {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, f)\n    }\n}\n\n#[stable(feature = \"cstring_into\", since = \"1.7.0\")]\nimpl From<CString> for Vec<u8> {\n    /// Converts a [`CString`] into a [`Vec`]`<u8>`.\n    ///\n    /// The conversion consumes the [`CString`], and removes the terminating NUL byte.\n    ///\n    /// [`Vec`]: ../vec/struct.Vec.html\n    /// [`CString`]: ../ffi/struct.CString.html\n    #[inline]\n    fn from(s: CString) -> Vec<u8> {\n        s.into_bytes()\n    }\n}\n\n#[stable(feature = \"cstr_debug\", since = \"1.3.0\")]\nimpl fmt::Debug for CStr {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"\\\"\")?;\n        for byte in self.to_bytes().iter().flat_map(|&b| ascii::escape_default(b)) {\n            f.write_char(byte as char)?;\n        }\n        write!(f, \"\\\"\")\n    }\n}\n\n#[stable(feature = \"cstr_default\", since = \"1.10.0\")]\nimpl<'a> Default for &'a CStr {\n    fn default() -> &'a CStr {\n        const SLICE: &'static [c_char] = &[0];\n        unsafe { CStr::from_ptr(SLICE.as_ptr()) }\n    }\n}\n\n#[stable(feature = \"cstr_default\", since = \"1.10.0\")]\nimpl Default for CString {\n    /// Creates an empty `CString`.\n    fn default() -> CString {\n        let a: &CStr = Default::default();\n        a.to_owned()\n    }\n}\n\n#[stable(feature = \"cstr_borrow\", since = \"1.3.0\")]\nimpl Borrow<CStr> for CString {\n    #[inline]\n    fn borrow(&self) -> &CStr { self }\n}\n\n#[stable(feature = \"cstring_from_cow_cstr\", since = \"1.28.0\")]\nimpl<'a> From<Cow<'a, CStr>> for CString {\n    #[inline]\n    fn from(s: Cow<'a, CStr>) -> Self {\n        s.into_owned()\n    }\n}\n\n#[stable(feature = \"box_from_c_str\", since = \"1.17.0\")]\nimpl<'a> From<&'a CStr> for Box<CStr> {\n    fn from(s: &'a CStr) -> Box<CStr> {\n        let boxed: Box<[u8]> = Box::from(s.to_bytes_with_nul());\n        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }\n    }\n}\n\n#[stable(feature = \"c_string_from_box\", since = \"1.18.0\")]\nimpl From<Box<CStr>> for CString {\n    /// Converts a [`Box`]`<CStr>` into a [`CString`] without copying or allocating.\n    ///\n    /// [`Box`]: ../boxed/struct.Box.html\n    /// [`CString`]: ../ffi/struct.CString.html\n    #[inline]\n    fn from(s: Box<CStr>) -> CString {\n        s.into_c_string()\n    }\n}\n\n#[stable(feature = \"more_box_slice_clone\", since = \"1.29.0\")]\nimpl Clone for Box<CStr> {\n    #[inline]\n    fn clone(&self) -> Self {\n        (**self).into()\n    }\n}\n\n#[stable(feature = \"box_from_c_string\", since = \"1.20.0\")]\nimpl From<CString> for Box<CStr> {\n    /// Converts a [`CString`] into a [`Box`]`<CStr>` without copying or allocating.\n    ///\n    /// [`CString`]: ../ffi/struct.CString.html\n    /// [`Box`]: ../boxed/struct.Box.html\n    #[inline]\n    fn from(s: CString) -> Box<CStr> {\n        s.into_boxed_c_str()\n    }\n}\n\n#[stable(feature = \"cow_from_cstr\", since = \"1.28.0\")]\nimpl<'a> From<CString> for Cow<'a, CStr> {\n    #[inline]\n    fn from(s: CString) -> Cow<'a, CStr> {\n        Cow::Owned(s)\n    }\n}\n\n#[stable(feature = \"cow_from_cstr\", since = \"1.28.0\")]\nimpl<'a> From<&'a CStr> for Cow<'a, CStr> {\n    #[inline]\n    fn from(s: &'a CStr) -> Cow<'a, CStr> {\n        Cow::Borrowed(s)\n    }\n}\n\n#[stable(feature = \"cow_from_cstr\", since = \"1.28.0\")]\nimpl<'a> From<&'a CString> for Cow<'a, CStr> {\n    #[inline]\n    fn from(s: &'a CString) -> Cow<'a, CStr> {\n        Cow::Borrowed(s.as_c_str())\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<CString> for Arc<CStr> {\n    /// Converts a [`CString`] into a [`Arc`]`<CStr>` without copying or allocating.\n    ///\n    /// [`CString`]: ../ffi/struct.CString.html\n    /// [`Arc`]: ../sync/struct.Arc.html\n    #[inline]\n    fn from(s: CString) -> Arc<CStr> {\n        let arc: Arc<[u8]> = Arc::from(s.into_inner());\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a CStr> for Arc<CStr> {\n    #[inline]\n    fn from(s: &CStr) -> Arc<CStr> {\n        let arc: Arc<[u8]> = Arc::from(s.to_bytes_with_nul());\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<CString> for Rc<CStr> {\n    /// Converts a [`CString`] into a [`Rc`]`<CStr>` without copying or allocating.\n    ///\n    /// [`CString`]: ../ffi/struct.CString.html\n    /// [`Rc`]: ../rc/struct.Rc.html\n    #[inline]\n    fn from(s: CString) -> Rc<CStr> {\n        let rc: Rc<[u8]> = Rc::from(s.into_inner());\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a CStr> for Rc<CStr> {\n    #[inline]\n    fn from(s: &CStr) -> Rc<CStr> {\n        let rc: Rc<[u8]> = Rc::from(s.to_bytes_with_nul());\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) }\n    }\n}\n\n#[stable(feature = \"default_box_extra\", since = \"1.17.0\")]\nimpl Default for Box<CStr> {\n    fn default() -> Box<CStr> {\n        let boxed: Box<[u8]> = Box::from([0]);\n        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }\n    }\n}\n\nimpl NulError {\n    /// Returns the position of the nul byte in the slice that caused\n    /// [`CString::new`] to fail.\n    ///\n    /// [`CString::new`]: struct.CString.html#method.new\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let nul_error = CString::new(\"foo\\0bar\").unwrap_err();\n    /// assert_eq!(nul_error.nul_position(), 3);\n    ///\n    /// let nul_error = CString::new(\"foo bar\\0\").unwrap_err();\n    /// assert_eq!(nul_error.nul_position(), 7);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn nul_position(&self) -> usize { self.0 }\n\n    /// Consumes this error, returning the underlying vector of bytes which\n    /// generated the error in the first place.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let nul_error = CString::new(\"foo\\0bar\").unwrap_err();\n    /// assert_eq!(nul_error.into_vec(), b\"foo\\0bar\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_vec(self) -> Vec<u8> { self.1 }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Error for NulError {\n    fn description(&self) -> &str { \"nul byte found in data\" }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for NulError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"nul byte found in provided data at position: {}\", self.0)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl From<NulError> for io::Error {\n    /// Converts a [`NulError`] into a [`io::Error`].\n    ///\n    /// [`NulError`]: ../ffi/struct.NulError.html\n    /// [`io::Error`]: ../io/struct.Error.html\n    fn from(_: NulError) -> io::Error {\n        io::Error::new(io::ErrorKind::InvalidInput,\n                       \"data provided contains a nul byte\")\n    }\n}\n\n#[stable(feature = \"frombyteswithnulerror_impls\", since = \"1.17.0\")]\nimpl Error for FromBytesWithNulError {\n    fn description(&self) -> &str {\n        match self.kind {\n            FromBytesWithNulErrorKind::InteriorNul(..) =>\n                \"data provided contains an interior nul byte\",\n            FromBytesWithNulErrorKind::NotNulTerminated =>\n                \"data provided is not nul terminated\",\n        }\n    }\n}\n\n#[stable(feature = \"frombyteswithnulerror_impls\", since = \"1.17.0\")]\nimpl fmt::Display for FromBytesWithNulError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.write_str(self.description())?;\n        if let FromBytesWithNulErrorKind::InteriorNul(pos) = self.kind {\n            write!(f, \" at byte pos {}\", pos)?;\n        }\n        Ok(())\n    }\n}\n\nimpl IntoStringError {\n    /// Consumes this error, returning original [`CString`] which generated the\n    /// error.\n    ///\n    /// [`CString`]: struct.CString.html\n    #[stable(feature = \"cstring_into\", since = \"1.7.0\")]\n    pub fn into_cstring(self) -> CString {\n        self.inner\n    }\n\n    /// Access the underlying UTF-8 error that was the cause of this error.\n    #[stable(feature = \"cstring_into\", since = \"1.7.0\")]\n    pub fn utf8_error(&self) -> Utf8Error {\n        self.error\n    }\n}\n\n#[stable(feature = \"cstring_into\", since = \"1.7.0\")]\nimpl Error for IntoStringError {\n    fn description(&self) -> &str {\n        \"C string contained non-utf8 bytes\"\n    }\n\n    fn cause(&self) -> Option<&dyn Error> {\n        Some(&self.error)\n    }\n}\n\n#[stable(feature = \"cstring_into\", since = \"1.7.0\")]\nimpl fmt::Display for IntoStringError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.description().fmt(f)\n    }\n}\n\nimpl CStr {\n    /// Wraps a raw C string with a safe C string wrapper.\n    ///\n    /// This function will wrap the provided `ptr` with a `CStr` wrapper, which\n    /// allows inspection and interoperation of non-owned C strings. This method\n    /// is unsafe for a number of reasons:\n    ///\n    /// * There is no guarantee to the validity of `ptr`.\n    /// * The returned lifetime is not guaranteed to be the actual lifetime of\n    ///   `ptr`.\n    /// * There is no guarantee that the memory pointed to by `ptr` contains a\n    ///   valid nul terminator byte at the end of the string.\n    /// * It is not guaranteed that the memory pointed by `ptr` won't change\n    ///   before the `CStr` has been destroyed.\n    ///\n    /// > **Note**: This operation is intended to be a 0-cost cast but it is\n    /// > currently implemented with an up-front calculation of the length of\n    /// > the string. This is not guaranteed to always be the case.\n    ///\n    /// # Examples\n    ///\n    /// ```ignore (extern-declaration)\n    /// # fn main() {\n    /// use std::ffi::CStr;\n    /// use std::os::raw::c_char;\n    ///\n    /// extern {\n    ///     fn my_string() -> *const c_char;\n    /// }\n    ///\n    /// unsafe {\n    ///     let slice = CStr::from_ptr(my_string());\n    ///     println!(\"string returned: {}\", slice.to_str().unwrap());\n    /// }\n    /// # }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr {\n        let len = sys::strlen(ptr);\n        let ptr = ptr as *const u8;\n        CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len as usize + 1))\n    }\n\n    /// Creates a C string wrapper from a byte slice.\n    ///\n    /// This function will cast the provided `bytes` to a `CStr`\n    /// wrapper after ensuring that the byte slice is nul-terminated\n    /// and does not contain any interior nul bytes.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let cstr = CStr::from_bytes_with_nul(b\"hello\\0\");\n    /// assert!(cstr.is_ok());\n    /// ```\n    ///\n    /// Creating a `CStr` without a trailing nul terminator is an error:\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"hello\");\n    /// assert!(c_str.is_err());\n    /// ```\n    ///\n    /// Creating a `CStr` with an interior nul byte is an error:\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"he\\0llo\\0\");\n    /// assert!(c_str.is_err());\n    /// ```\n    #[stable(feature = \"cstr_from_bytes\", since = \"1.10.0\")]\n    pub fn from_bytes_with_nul(bytes: &[u8])\n                               -> Result<&CStr, FromBytesWithNulError> {\n        let nul_pos = memchr::memchr(0, bytes);\n        if let Some(nul_pos) = nul_pos {\n            if nul_pos + 1 != bytes.len() {\n                return Err(FromBytesWithNulError::interior_nul(nul_pos));\n            }\n            Ok(unsafe { CStr::from_bytes_with_nul_unchecked(bytes) })\n        } else {\n            Err(FromBytesWithNulError::not_nul_terminated())\n        }\n    }\n\n    /// Unsafely creates a C string wrapper from a byte slice.\n    ///\n    /// This function will cast the provided `bytes` to a `CStr` wrapper without\n    /// performing any sanity checks. The provided slice **must** be nul-terminated\n    /// and not contain any interior nul bytes.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::{CStr, CString};\n    ///\n    /// unsafe {\n    ///     let cstring = CString::new(\"hello\").expect(\"CString::new failed\");\n    ///     let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul());\n    ///     assert_eq!(cstr, &*cstring);\n    /// }\n    /// ```\n    #[inline]\n    #[stable(feature = \"cstr_from_bytes\", since = \"1.10.0\")]\n    #[rustc_const_unstable(feature = \"const_cstr_unchecked\")]\n    pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr {\n        &*(bytes as *const [u8] as *const CStr)\n    }\n\n    /// Returns the inner pointer to this C string.\n    ///\n    /// The returned pointer will be valid for as long as `self` is, and points\n    /// to a contiguous region of memory terminated with a 0 byte to represent\n    /// the end of the string.\n    ///\n    /// **WARNING**\n    ///\n    /// It is your responsibility to make sure that the underlying memory is not\n    /// freed too early. For example, the following code will cause undefined\n    /// behavior when `ptr` is used inside the `unsafe` block:\n    ///\n    /// ```no_run\n    /// # #![allow(unused_must_use)]\n    /// use std::ffi::{CString};\n    ///\n    /// let ptr = CString::new(\"Hello\").expect(\"CString::new failed\").as_ptr();\n    /// unsafe {\n    ///     // `ptr` is dangling\n    ///     *ptr;\n    /// }\n    /// ```\n    ///\n    /// This happens because the pointer returned by `as_ptr` does not carry any\n    /// lifetime information and the [`CString`] is deallocated immediately after\n    /// the `CString::new(\"Hello\").expect(\"CString::new failed\").as_ptr()` expression is evaluated.\n    /// To fix the problem, bind the `CString` to a local variable:\n    ///\n    /// ```no_run\n    /// # #![allow(unused_must_use)]\n    /// use std::ffi::{CString};\n    ///\n    /// let hello = CString::new(\"Hello\").expect(\"CString::new failed\");\n    /// let ptr = hello.as_ptr();\n    /// unsafe {\n    ///     // `ptr` is valid because `hello` is in scope\n    ///     *ptr;\n    /// }\n    /// ```\n    ///\n    /// This way, the lifetime of the `CString` in `hello` encompasses\n    /// the lifetime of `ptr` and the `unsafe` block.\n    ///\n    /// [`CString`]: struct.CString.html\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_ptr(&self) -> *const c_char {\n        self.inner.as_ptr()\n    }\n\n    /// Converts this C string to a byte slice.\n    ///\n    /// The returned slice will **not** contain the trailing nul terminator that this C\n    /// string has.\n    ///\n    /// > **Note**: This method is currently implemented as a constant-time\n    /// > cast, but it is planned to alter its definition in the future to\n    /// > perform the length calculation whenever this method is called.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"foo\\0\").expect(\"CStr::from_bytes_with_nul failed\");\n    /// assert_eq!(c_str.to_bytes(), b\"foo\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_bytes(&self) -> &[u8] {\n        let bytes = self.to_bytes_with_nul();\n        &bytes[..bytes.len() - 1]\n    }\n\n    /// Converts this C string to a byte slice containing the trailing 0 byte.\n    ///\n    /// This function is the equivalent of [`to_bytes`] except that it will retain\n    /// the trailing nul terminator instead of chopping it off.\n    ///\n    /// > **Note**: This method is currently implemented as a 0-cost cast, but\n    /// > it is planned to alter its definition in the future to perform the\n    /// > length calculation whenever this method is called.\n    ///\n    /// [`to_bytes`]: #method.to_bytes\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"foo\\0\").expect(\"CStr::from_bytes_with_nul failed\");\n    /// assert_eq!(c_str.to_bytes_with_nul(), b\"foo\\0\");\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_bytes_with_nul(&self) -> &[u8] {\n        unsafe { &*(&self.inner as *const [c_char] as *const [u8]) }\n    }\n\n    /// Yields a [`&str`] slice if the `CStr` contains valid UTF-8.\n    ///\n    /// If the contents of the `CStr` are valid UTF-8 data, this\n    /// function will return the corresponding [`&str`] slice. Otherwise,\n    /// it will return an error with details of where UTF-8 validation failed.\n    ///\n    /// > **Note**: This method is currently implemented to check for validity\n    /// > after a constant-time cast, but it is planned to alter its definition\n    /// > in the future to perform the length calculation in addition to the\n    /// > UTF-8 check whenever this method is called.\n    ///\n    /// [`&str`]: ../primitive.str.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"foo\\0\").expect(\"CStr::from_bytes_with_nul failed\");\n    /// assert_eq!(c_str.to_str(), Ok(\"foo\"));\n    /// ```\n    #[stable(feature = \"cstr_to_str\", since = \"1.4.0\")]\n    pub fn to_str(&self) -> Result<&str, str::Utf8Error> {\n        // NB: When CStr is changed to perform the length check in .to_bytes()\n        // instead of in from_ptr(), it may be worth considering if this should\n        // be rewritten to do the UTF-8 check inline with the length calculation\n        // instead of doing it afterwards.\n        str::from_utf8(self.to_bytes())\n    }\n\n    /// Converts a `CStr` into a [`Cow`]`<`[`str`]`>`.\n    ///\n    /// If the contents of the `CStr` are valid UTF-8 data, this\n    /// function will return a [`Cow`]`::`[`Borrowed`]`(`[`&str`]`)`\n    /// with the the corresponding [`&str`] slice. Otherwise, it will\n    /// replace any invalid UTF-8 sequences with\n    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD] and return a\n    /// [`Cow`]`::`[`Owned`]`(`[`String`]`)` with the result.\n    ///\n    /// > **Note**: This method is currently implemented to check for validity\n    /// > after a constant-time cast, but it is planned to alter its definition\n    /// > in the future to perform the length calculation in addition to the\n    /// > UTF-8 check whenever this method is called.\n    ///\n    /// [`Cow`]: ../borrow/enum.Cow.html\n    /// [`Borrowed`]: ../borrow/enum.Cow.html#variant.Borrowed\n    /// [`Owned`]: ../borrow/enum.Cow.html#variant.Owned\n    /// [`str`]: ../primitive.str.html\n    /// [`String`]: ../string/struct.String.html\n    /// [U+FFFD]: ../char/constant.REPLACEMENT_CHARACTER.html\n    ///\n    /// # Examples\n    ///\n    /// Calling `to_string_lossy` on a `CStr` containing valid UTF-8:\n    ///\n    /// ```\n    /// use std::borrow::Cow;\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"Hello World\\0\")\n    ///                  .expect(\"CStr::from_bytes_with_nul failed\");\n    /// assert_eq!(c_str.to_string_lossy(), Cow::Borrowed(\"Hello World\"));\n    /// ```\n    ///\n    /// Calling `to_string_lossy` on a `CStr` containing invalid UTF-8:\n    ///\n    /// ```\n    /// use std::borrow::Cow;\n    /// use std::ffi::CStr;\n    ///\n    /// let c_str = CStr::from_bytes_with_nul(b\"Hello \\xF0\\x90\\x80World\\0\")\n    ///                  .expect(\"CStr::from_bytes_with_nul failed\");\n    /// assert_eq!(\n    ///     c_str.to_string_lossy(),\n    ///     Cow::Owned(String::from(\"Hello \ufffdWorld\")) as Cow<str>\n    /// );\n    /// ```\n    #[stable(feature = \"cstr_to_str\", since = \"1.4.0\")]\n    pub fn to_string_lossy(&self) -> Cow<str> {\n        String::from_utf8_lossy(self.to_bytes())\n    }\n\n    /// Converts a [`Box`]`<CStr>` into a [`CString`] without copying or allocating.\n    ///\n    /// [`Box`]: ../boxed/struct.Box.html\n    /// [`CString`]: struct.CString.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::ffi::CString;\n    ///\n    /// let c_string = CString::new(b\"foo\".to_vec()).expect(\"CString::new failed\");\n    /// let boxed = c_string.into_boxed_c_str();\n    /// assert_eq!(boxed.into_c_string(), CString::new(\"foo\").expect(\"CString::new failed\"));\n    /// ```\n    #[stable(feature = \"into_boxed_c_str\", since = \"1.20.0\")]\n    pub fn into_c_string(self: Box<CStr>) -> CString {\n        let raw = Box::into_raw(self) as *mut [u8];\n        CString { inner: unsafe { Box::from_raw(raw) } }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for CStr {\n    fn eq(&self, other: &CStr) -> bool {\n        self.to_bytes().eq(other.to_bytes())\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for CStr {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for CStr {\n    fn partial_cmp(&self, other: &CStr) -> Option<Ordering> {\n        self.to_bytes().partial_cmp(&other.to_bytes())\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for CStr {\n    fn cmp(&self, other: &CStr) -> Ordering {\n        self.to_bytes().cmp(&other.to_bytes())\n    }\n}\n\n#[stable(feature = \"cstr_borrow\", since = \"1.3.0\")]\nimpl ToOwned for CStr {\n    type Owned = CString;\n\n    fn to_owned(&self) -> CString {\n        CString { inner: self.to_bytes_with_nul().into() }\n    }\n}\n\n#[stable(feature = \"cstring_asref\", since = \"1.7.0\")]\nimpl<'a> From<&'a CStr> for CString {\n    fn from(s: &'a CStr) -> CString {\n        s.to_owned()\n    }\n}\n\n#[stable(feature = \"cstring_asref\", since = \"1.7.0\")]\nimpl ops::Index<ops::RangeFull> for CString {\n    type Output = CStr;\n\n    #[inline]\n    fn index(&self, _index: ops::RangeFull) -> &CStr {\n        self\n    }\n}\n\n#[stable(feature = \"cstring_asref\", since = \"1.7.0\")]\nimpl AsRef<CStr> for CStr {\n    #[inline]\n    fn as_ref(&self) -> &CStr {\n        self\n    }\n}\n\n#[stable(feature = \"cstring_asref\", since = \"1.7.0\")]\nimpl AsRef<CStr> for CString {\n    #[inline]\n    fn as_ref(&self) -> &CStr {\n        self\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n    use os::raw::c_char;\n    use borrow::Cow::{Borrowed, Owned};\n    use hash::{Hash, Hasher};\n    use collections::hash_map::DefaultHasher;\n    use rc::Rc;\n    use sync::Arc;\n\n    #[test]\n    fn c_to_rust() {\n        let data = b\"123\\0\";\n        let ptr = data.as_ptr() as *const c_char;\n        unsafe {\n            assert_eq!(CStr::from_ptr(ptr).to_bytes(), b\"123\");\n            assert_eq!(CStr::from_ptr(ptr).to_bytes_with_nul(), b\"123\\0\");\n        }\n    }\n\n    #[test]\n    fn simple() {\n        let s = CString::new(\"1234\").unwrap();\n        assert_eq!(s.as_bytes(), b\"1234\");\n        assert_eq!(s.as_bytes_with_nul(), b\"1234\\0\");\n    }\n\n    #[test]\n    fn build_with_zero1() {\n        assert!(CString::new(&b\"\\0\"[..]).is_err());\n    }\n    #[test]\n    fn build_with_zero2() {\n        assert!(CString::new(vec![0]).is_err());\n    }\n\n    #[test]\n    fn build_with_zero3() {\n        unsafe {\n            let s = CString::from_vec_unchecked(vec![0]);\n            assert_eq!(s.as_bytes(), b\"\\0\");\n        }\n    }\n\n    #[test]\n    fn formatted() {\n        let s = CString::new(&b\"abc\\x01\\x02\\n\\xE2\\x80\\xA6\\xFF\"[..]).unwrap();\n        assert_eq!(format!(\"{:?}\", s), r#\"\"abc\\x01\\x02\\n\\xe2\\x80\\xa6\\xff\"\"#);\n    }\n\n    #[test]\n    fn borrowed() {\n        unsafe {\n            let s = CStr::from_ptr(b\"12\\0\".as_ptr() as *const _);\n            assert_eq!(s.to_bytes(), b\"12\");\n            assert_eq!(s.to_bytes_with_nul(), b\"12\\0\");\n        }\n    }\n\n    #[test]\n    fn to_str() {\n        let data = b\"123\\xE2\\x80\\xA6\\0\";\n        let ptr = data.as_ptr() as *const c_char;\n        unsafe {\n            assert_eq!(CStr::from_ptr(ptr).to_str(), Ok(\"123\u2026\"));\n            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Borrowed(\"123\u2026\"));\n        }\n        let data = b\"123\\xE2\\0\";\n        let ptr = data.as_ptr() as *const c_char;\n        unsafe {\n            assert!(CStr::from_ptr(ptr).to_str().is_err());\n            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Owned::<str>(format!(\"123\\u{FFFD}\")));\n        }\n    }\n\n    #[test]\n    fn to_owned() {\n        let data = b\"123\\0\";\n        let ptr = data.as_ptr() as *const c_char;\n\n        let owned = unsafe { CStr::from_ptr(ptr).to_owned() };\n        assert_eq!(owned.as_bytes_with_nul(), data);\n    }\n\n    #[test]\n    fn equal_hash() {\n        let data = b\"123\\xE2\\xFA\\xA6\\0\";\n        let ptr = data.as_ptr() as *const c_char;\n        let cstr: &'static CStr = unsafe { CStr::from_ptr(ptr) };\n\n        let mut s = DefaultHasher::new();\n        cstr.hash(&mut s);\n        let cstr_hash = s.finish();\n        let mut s = DefaultHasher::new();\n        CString::new(&data[..data.len() - 1]).unwrap().hash(&mut s);\n        let cstring_hash = s.finish();\n\n        assert_eq!(cstr_hash, cstring_hash);\n    }\n\n    #[test]\n    fn from_bytes_with_nul() {\n        let data = b\"123\\0\";\n        let cstr = CStr::from_bytes_with_nul(data);\n        assert_eq!(cstr.map(CStr::to_bytes), Ok(&b\"123\"[..]));\n        let cstr = CStr::from_bytes_with_nul(data);\n        assert_eq!(cstr.map(CStr::to_bytes_with_nul), Ok(&b\"123\\0\"[..]));\n\n        unsafe {\n            let cstr = CStr::from_bytes_with_nul(data);\n            let cstr_unchecked = CStr::from_bytes_with_nul_unchecked(data);\n            assert_eq!(cstr, Ok(cstr_unchecked));\n        }\n    }\n\n    #[test]\n    fn from_bytes_with_nul_unterminated() {\n        let data = b\"123\";\n        let cstr = CStr::from_bytes_with_nul(data);\n        assert!(cstr.is_err());\n    }\n\n    #[test]\n    fn from_bytes_with_nul_interior() {\n        let data = b\"1\\023\\0\";\n        let cstr = CStr::from_bytes_with_nul(data);\n        assert!(cstr.is_err());\n    }\n\n    #[test]\n    fn into_boxed() {\n        let orig: &[u8] = b\"Hello, world!\\0\";\n        let cstr = CStr::from_bytes_with_nul(orig).unwrap();\n        let boxed: Box<CStr> = Box::from(cstr);\n        let cstring = cstr.to_owned().into_boxed_c_str().into_c_string();\n        assert_eq!(cstr, &*boxed);\n        assert_eq!(&*boxed, &*cstring);\n        assert_eq!(&*cstring, cstr);\n    }\n\n    #[test]\n    fn boxed_default() {\n        let boxed = <Box<CStr>>::default();\n        assert_eq!(boxed.to_bytes_with_nul(), &[0]);\n    }\n\n    #[test]\n    fn into_rc() {\n        let orig: &[u8] = b\"Hello, world!\\0\";\n        let cstr = CStr::from_bytes_with_nul(orig).unwrap();\n        let rc: Rc<CStr> = Rc::from(cstr);\n        let arc: Arc<CStr> = Arc::from(cstr);\n\n        assert_eq!(&*rc, cstr);\n        assert_eq!(&*arc, cstr);\n\n        let rc2: Rc<CStr> = Rc::from(cstr.to_owned());\n        let arc2: Arc<CStr> = Arc::from(cstr.to_owned());\n\n        assert_eq!(&*rc2, cstr);\n        assert_eq!(&*arc2, cstr);\n    }\n\n    #[test]\n    fn cstr_const_constructor() {\n        const CSTR: &'static CStr = unsafe {\n            CStr::from_bytes_with_nul_unchecked(b\"Hello, world!\\0\")\n        };\n\n        assert_eq!(CSTR.to_str().unwrap(), \"Hello, world!\");\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Cross-platform path manipulation.\n//!\n//! This module provides two types, [`PathBuf`] and [`Path`][`Path`] (akin to [`String`]\n//! and [`str`]), for working with paths abstractly. These types are thin wrappers\n//! around [`OsString`] and [`OsStr`] respectively, meaning that they work directly\n//! on strings according to the local platform's path syntax.\n//!\n//! Paths can be parsed into [`Component`]s by iterating over the structure\n//! returned by the [`components`] method on [`Path`]. [`Component`]s roughly\n//! correspond to the substrings between path separators (`/` or `\\`). You can\n//! reconstruct an equivalent path from components with the [`push`] method on\n//! [`PathBuf`]; note that the paths may differ syntactically by the\n//! normalization described in the documentation for the [`components`] method.\n//!\n//! ## Simple usage\n//!\n//! Path manipulation includes both parsing components from slices and building\n//! new owned paths.\n//!\n//! To parse a path, you can create a [`Path`] slice from a [`str`]\n//! slice and start asking questions:\n//!\n//! ```\n//! use std::path::Path;\n//! use std::ffi::OsStr;\n//!\n//! let path = Path::new(\"/tmp/foo/bar.txt\");\n//!\n//! let parent = path.parent();\n//! assert_eq!(parent, Some(Path::new(\"/tmp/foo\")));\n//!\n//! let file_stem = path.file_stem();\n//! assert_eq!(file_stem, Some(OsStr::new(\"bar\")));\n//!\n//! let extension = path.extension();\n//! assert_eq!(extension, Some(OsStr::new(\"txt\")));\n//! ```\n//!\n//! To build or modify paths, use [`PathBuf`]:\n//!\n//! ```\n//! use std::path::PathBuf;\n//!\n//! // This way works...\n//! let mut path = PathBuf::from(\"c:\\\\\");\n//!\n//! path.push(\"windows\");\n//! path.push(\"system32\");\n//!\n//! path.set_extension(\"dll\");\n//!\n//! // ... but push is best used if you don't know everything up\n//! // front. If you do, this way is better:\n//! let path: PathBuf = [\"c:\\\\\", \"windows\", \"system32.dll\"].iter().collect();\n//! ```\n//!\n//! [`Component`]: ../../std/path/enum.Component.html\n//! [`components`]: ../../std/path/struct.Path.html#method.components\n//! [`PathBuf`]: ../../std/path/struct.PathBuf.html\n//! [`Path`]: ../../std/path/struct.Path.html\n//! [`push`]: ../../std/path/struct.PathBuf.html#method.push\n//! [`String`]: ../../std/string/struct.String.html\n//!\n//! [`str`]: ../../std/primitive.str.html\n//! [`OsString`]: ../../std/ffi/struct.OsString.html\n//! [`OsStr`]: ../../std/ffi/struct.OsStr.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse borrow::{Borrow, Cow};\nuse cmp;\nuse error::Error;\nuse fmt;\nuse fs;\nuse hash::{Hash, Hasher};\nuse io;\nuse iter::{self, FusedIterator};\nuse ops::{self, Deref};\nuse rc::Rc;\nuse str::FromStr;\nuse string::ParseError;\nuse sync::Arc;\n\nuse ffi::{OsStr, OsString};\n\nuse sys::path::{is_sep_byte, is_verbatim_sep, MAIN_SEP_STR, parse_prefix};\n\n////////////////////////////////////////////////////////////////////////////////\n// GENERAL NOTES\n////////////////////////////////////////////////////////////////////////////////\n//\n// Parsing in this module is done by directly transmuting OsStr to [u8] slices,\n// taking advantage of the fact that OsStr always encodes ASCII characters\n// as-is.  Eventually, this transmutation should be replaced by direct uses of\n// OsStr APIs for parsing, but it will take a while for those to become\n// available.\n\n////////////////////////////////////////////////////////////////////////////////\n// Windows Prefixes\n////////////////////////////////////////////////////////////////////////////////\n\n/// Windows path prefixes, e.g. `C:` or `\\\\server\\share`.\n///\n/// Windows uses a variety of path prefix styles, including references to drive\n/// volumes (like `C:`), network shared folders (like `\\\\server\\share`), and\n/// others. In addition, some path prefixes are \"verbatim\" (i.e. prefixed with\n/// `\\\\?\\`), in which case `/` is *not* treated as a separator and essentially\n/// no normalization is performed.\n///\n/// # Examples\n///\n/// ```\n/// use std::path::{Component, Path, Prefix};\n/// use std::path::Prefix::*;\n/// use std::ffi::OsStr;\n///\n/// fn get_path_prefix(s: &str) -> Prefix {\n///     let path = Path::new(s);\n///     match path.components().next().unwrap() {\n///         Component::Prefix(prefix_component) => prefix_component.kind(),\n///         _ => panic!(),\n///     }\n/// }\n///\n/// # if cfg!(windows) {\n/// assert_eq!(Verbatim(OsStr::new(\"pictures\")),\n///            get_path_prefix(r\"\\\\?\\pictures\\kittens\"));\n/// assert_eq!(VerbatimUNC(OsStr::new(\"server\"), OsStr::new(\"share\")),\n///            get_path_prefix(r\"\\\\?\\UNC\\server\\share\"));\n/// assert_eq!(VerbatimDisk(b'C'), get_path_prefix(r\"\\\\?\\c:\\\"));\n/// assert_eq!(DeviceNS(OsStr::new(\"BrainInterface\")),\n///            get_path_prefix(r\"\\\\.\\BrainInterface\"));\n/// assert_eq!(UNC(OsStr::new(\"server\"), OsStr::new(\"share\")),\n///            get_path_prefix(r\"\\\\server\\share\"));\n/// assert_eq!(Disk(b'C'), get_path_prefix(r\"C:\\Users\\Rust\\Pictures\\Ferris\"));\n/// # }\n/// ```\n#[derive(Copy, Clone, Debug, Hash, PartialOrd, Ord, PartialEq, Eq)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Prefix<'a> {\n    /// Verbatim prefix, e.g. `\\\\?\\cat_pics`.\n    ///\n    /// Verbatim prefixes consist of `\\\\?\\` immediately followed by the given\n    /// component.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Verbatim(#[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr),\n\n    /// Verbatim prefix using Windows' _**U**niform **N**aming **C**onvention_,\n    /// e.g. `\\\\?\\UNC\\server\\share`.\n    ///\n    /// Verbatim UNC prefixes consist of `\\\\?\\UNC\\` immediately followed by the\n    /// server's hostname and a share name.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    VerbatimUNC(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr,\n        #[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr,\n    ),\n\n    /// Verbatim disk prefix, e.g. `\\\\?\\C:\\`.\n    ///\n    /// Verbatim disk prefixes consist of `\\\\?\\` immediately followed by the\n    /// drive letter and `:\\`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    VerbatimDisk(#[stable(feature = \"rust1\", since = \"1.0.0\")] u8),\n\n    /// Device namespace prefix, e.g. `\\\\.\\COM42`.\n    ///\n    /// Device namespace prefixes consist of `\\\\.\\` immediately followed by the\n    /// device name.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    DeviceNS(#[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr),\n\n    /// Prefix using Windows' _**U**niform **N**aming **C**onvention_, e.g.\n    /// `\\\\server\\share`.\n    ///\n    /// UNC prefixes consist of the server's hostname and a share name.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    UNC(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr,\n        #[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr,\n    ),\n\n    /// Prefix `C:` for the given disk drive.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Disk(#[stable(feature = \"rust1\", since = \"1.0.0\")] u8),\n}\n\nimpl<'a> Prefix<'a> {\n    #[inline]\n    fn len(&self) -> usize {\n        use self::Prefix::*;\n        fn os_str_len(s: &OsStr) -> usize {\n            os_str_as_u8_slice(s).len()\n        }\n        match *self {\n            Verbatim(x) => 4 + os_str_len(x),\n            VerbatimUNC(x, y) => {\n                8 + os_str_len(x) +\n                if os_str_len(y) > 0 {\n                    1 + os_str_len(y)\n                } else {\n                    0\n                }\n            },\n            VerbatimDisk(_) => 6,\n            UNC(x, y) => {\n                2 + os_str_len(x) +\n                if os_str_len(y) > 0 {\n                    1 + os_str_len(y)\n                } else {\n                    0\n                }\n            },\n            DeviceNS(x) => 4 + os_str_len(x),\n            Disk(_) => 2,\n        }\n\n    }\n\n    /// Determines if the prefix is verbatim, i.e. begins with `\\\\?\\`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Prefix::*;\n    /// use std::ffi::OsStr;\n    ///\n    /// assert!(Verbatim(OsStr::new(\"pictures\")).is_verbatim());\n    /// assert!(VerbatimUNC(OsStr::new(\"server\"), OsStr::new(\"share\")).is_verbatim());\n    /// assert!(VerbatimDisk(b'C').is_verbatim());\n    /// assert!(!DeviceNS(OsStr::new(\"BrainInterface\")).is_verbatim());\n    /// assert!(!UNC(OsStr::new(\"server\"), OsStr::new(\"share\")).is_verbatim());\n    /// assert!(!Disk(b'C').is_verbatim());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_verbatim(&self) -> bool {\n        use self::Prefix::*;\n        match *self {\n            Verbatim(_) | VerbatimDisk(_) | VerbatimUNC(..) => true,\n            _ => false,\n        }\n    }\n\n    #[inline]\n    fn is_drive(&self) -> bool {\n        match *self {\n            Prefix::Disk(_) => true,\n            _ => false,\n        }\n    }\n\n    #[inline]\n    fn has_implicit_root(&self) -> bool {\n        !self.is_drive()\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Exposed parsing helpers\n////////////////////////////////////////////////////////////////////////////////\n\n/// Determines whether the character is one of the permitted path\n/// separators for the current platform.\n///\n/// # Examples\n///\n/// ```\n/// use std::path;\n///\n/// assert!(path::is_separator('/')); // '/' works for both Unix and Windows\n/// assert!(!path::is_separator('\u2764'));\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn is_separator(c: char) -> bool {\n    c.is_ascii() && is_sep_byte(c as u8)\n}\n\n/// The primary separator of path components for the current platform.\n///\n/// For example, `/` on Unix and `\\` on Windows.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAIN_SEPARATOR: char = ::sys::path::MAIN_SEP;\n\n////////////////////////////////////////////////////////////////////////////////\n// Misc helpers\n////////////////////////////////////////////////////////////////////////////////\n\n// Iterate through `iter` while it matches `prefix`; return `None` if `prefix`\n// is not a prefix of `iter`, otherwise return `Some(iter_after_prefix)` giving\n// `iter` after having exhausted `prefix`.\nfn iter_after<'a, 'b, I, J>(mut iter: I, mut prefix: J) -> Option<I>\n    where I: Iterator<Item = Component<'a>> + Clone,\n          J: Iterator<Item = Component<'b>>,\n{\n    loop {\n        let mut iter_next = iter.clone();\n        match (iter_next.next(), prefix.next()) {\n            (Some(ref x), Some(ref y)) if x == y => (),\n            (Some(_), Some(_)) => return None,\n            (Some(_), None) => return Some(iter),\n            (None, None) => return Some(iter),\n            (None, Some(_)) => return None,\n        }\n        iter = iter_next;\n    }\n}\n\n// See note at the top of this module to understand why these are used:\nfn os_str_as_u8_slice(s: &OsStr) -> &[u8] {\n    unsafe { &*(s as *const OsStr as *const [u8]) }\n}\nunsafe fn u8_slice_as_os_str(s: &[u8]) -> &OsStr {\n    &*(s as *const [u8] as *const OsStr)\n}\n\n// Detect scheme on Redox\nfn has_redox_scheme(s: &[u8]) -> bool {\n    cfg!(target_os = \"redox\") && s.split(|b| *b == b'/').next().unwrap_or(b\"\").contains(&b':')\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Cross-platform, iterator-independent parsing\n////////////////////////////////////////////////////////////////////////////////\n\n/// Says whether the first byte after the prefix is a separator.\nfn has_physical_root(s: &[u8], prefix: Option<Prefix>) -> bool {\n    let path = if let Some(p) = prefix {\n        &s[p.len()..]\n    } else {\n        s\n    };\n    !path.is_empty() && is_sep_byte(path[0])\n}\n\n// basic workhorse for splitting stem and extension\nfn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {\n    unsafe {\n        if os_str_as_u8_slice(file) == b\"..\" {\n            return (Some(file), None);\n        }\n\n        // The unsafety here stems from converting between &OsStr and &[u8]\n        // and back. This is safe to do because (1) we only look at ASCII\n        // contents of the encoding and (2) new &OsStr values are produced\n        // only from ASCII-bounded slices of existing &OsStr values.\n\n        let mut iter = os_str_as_u8_slice(file).rsplitn(2, |b| *b == b'.');\n        let after = iter.next();\n        let before = iter.next();\n        if before == Some(b\"\") {\n            (Some(file), None)\n        } else {\n            (before.map(|s| u8_slice_as_os_str(s)),\n             after.map(|s| u8_slice_as_os_str(s)))\n        }\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// The core iterators\n////////////////////////////////////////////////////////////////////////////////\n\n/// Component parsing works by a double-ended state machine; the cursors at the\n/// front and back of the path each keep track of what parts of the path have\n/// been consumed so far.\n///\n/// Going front to back, a path is made up of a prefix, a starting\n/// directory component, and a body (of normal components)\n#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]\nenum State {\n    Prefix = 0,         // c:\n    StartDir = 1,       // / or . or nothing\n    Body = 2,           // foo/bar/baz\n    Done = 3,\n}\n\n/// A structure wrapping a Windows path prefix as well as its unparsed string\n/// representation.\n///\n/// In addition to the parsed [`Prefix`] information returned by [`kind`],\n/// `PrefixComponent` also holds the raw and unparsed [`OsStr`] slice,\n/// returned by [`as_os_str`].\n///\n/// Instances of this `struct` can be obtained by matching against the\n/// [`Prefix` variant] on [`Component`].\n///\n/// Does not occur on Unix.\n///\n/// # Examples\n///\n/// ```\n/// # if cfg!(windows) {\n/// use std::path::{Component, Path, Prefix};\n/// use std::ffi::OsStr;\n///\n/// let path = Path::new(r\"c:\\you\\later\\\");\n/// match path.components().next().unwrap() {\n///     Component::Prefix(prefix_component) => {\n///         assert_eq!(Prefix::Disk(b'C'), prefix_component.kind());\n///         assert_eq!(OsStr::new(\"c:\"), prefix_component.as_os_str());\n///     }\n///     _ => unreachable!(),\n/// }\n/// # }\n/// ```\n///\n/// [`as_os_str`]: #method.as_os_str\n/// [`Component`]: enum.Component.html\n/// [`kind`]: #method.kind\n/// [`OsStr`]: ../../std/ffi/struct.OsStr.html\n/// [`Prefix` variant]: enum.Component.html#variant.Prefix\n/// [`Prefix`]: enum.Prefix.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Copy, Clone, Eq, Debug)]\npub struct PrefixComponent<'a> {\n    /// The prefix as an unparsed `OsStr` slice.\n    raw: &'a OsStr,\n\n    /// The parsed prefix data.\n    parsed: Prefix<'a>,\n}\n\nimpl<'a> PrefixComponent<'a> {\n    /// Returns the parsed prefix data.\n    ///\n    /// See [`Prefix`]'s documentation for more information on the different\n    /// kinds of prefixes.\n    ///\n    /// [`Prefix`]: enum.Prefix.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn kind(&self) -> Prefix<'a> {\n        self.parsed\n    }\n\n    /// Returns the raw [`OsStr`] slice for this prefix.\n    ///\n    /// [`OsStr`]: ../../std/ffi/struct.OsStr.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_os_str(&self) -> &'a OsStr {\n        self.raw\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::PartialEq for PrefixComponent<'a> {\n    fn eq(&self, other: &PrefixComponent<'a>) -> bool {\n        cmp::PartialEq::eq(&self.parsed, &other.parsed)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::PartialOrd for PrefixComponent<'a> {\n    fn partial_cmp(&self, other: &PrefixComponent<'a>) -> Option<cmp::Ordering> {\n        cmp::PartialOrd::partial_cmp(&self.parsed, &other.parsed)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::Ord for PrefixComponent<'a> {\n    fn cmp(&self, other: &PrefixComponent<'a>) -> cmp::Ordering {\n        cmp::Ord::cmp(&self.parsed, &other.parsed)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Hash for PrefixComponent<'a> {\n    fn hash<H: Hasher>(&self, h: &mut H) {\n        self.parsed.hash(h);\n    }\n}\n\n/// A single component of a path.\n///\n/// A `Component` roughly corresponds to a substring between path separators\n/// (`/` or `\\`).\n///\n/// This `enum` is created by iterating over [`Components`], which in turn is\n/// created by the [`components`][`Path::components`] method on [`Path`].\n///\n/// # Examples\n///\n/// ```rust\n/// use std::path::{Component, Path};\n///\n/// let path = Path::new(\"/tmp/foo/bar.txt\");\n/// let components = path.components().collect::<Vec<_>>();\n/// assert_eq!(&components, &[\n///     Component::RootDir,\n///     Component::Normal(\"tmp\".as_ref()),\n///     Component::Normal(\"foo\".as_ref()),\n///     Component::Normal(\"bar.txt\".as_ref()),\n/// ]);\n/// ```\n///\n/// [`Components`]: struct.Components.html\n/// [`Path`]: struct.Path.html\n/// [`Path::components`]: struct.Path.html#method.components\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Component<'a> {\n    /// A Windows path prefix, e.g. `C:` or `\\\\server\\share`.\n    ///\n    /// There is a large variety of prefix types, see [`Prefix`]'s documentation\n    /// for more.\n    ///\n    /// Does not occur on Unix.\n    ///\n    /// [`Prefix`]: enum.Prefix.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Prefix(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")] PrefixComponent<'a>\n    ),\n\n    /// The root directory component, appears after any prefix and before anything else.\n    ///\n    /// It represents a separator that designates that a path starts from root.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    RootDir,\n\n    /// A reference to the current directory, i.e. `.`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    CurDir,\n\n    /// A reference to the parent directory, i.e. `..`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    ParentDir,\n\n    /// A normal component, e.g. `a` and `b` in `a/b`.\n    ///\n    /// This variant is the most common one, it represents references to files\n    /// or directories.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Normal(#[stable(feature = \"rust1\", since = \"1.0.0\")] &'a OsStr),\n}\n\nimpl<'a> Component<'a> {\n    /// Extracts the underlying [`OsStr`] slice.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"./tmp/foo/bar.txt\");\n    /// let components: Vec<_> = path.components().map(|comp| comp.as_os_str()).collect();\n    /// assert_eq!(&components, &[\".\", \"tmp\", \"foo\", \"bar.txt\"]);\n    /// ```\n    ///\n    /// [`OsStr`]: ../../std/ffi/struct.OsStr.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_os_str(self) -> &'a OsStr {\n        match self {\n            Component::Prefix(p) => p.as_os_str(),\n            Component::RootDir => OsStr::new(MAIN_SEP_STR),\n            Component::CurDir => OsStr::new(\".\"),\n            Component::ParentDir => OsStr::new(\"..\"),\n            Component::Normal(path) => path,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> AsRef<OsStr> for Component<'a> {\n    fn as_ref(&self) -> &OsStr {\n        self.as_os_str()\n    }\n}\n\n#[stable(feature = \"path_component_asref\", since = \"1.25.0\")]\nimpl<'a> AsRef<Path> for Component<'a> {\n    fn as_ref(&self) -> &Path {\n        self.as_os_str().as_ref()\n    }\n}\n\n/// An iterator over the [`Component`]s of a [`Path`].\n///\n/// This `struct` is created by the [`components`] method on [`Path`].\n/// See its documentation for more.\n///\n/// # Examples\n///\n/// ```\n/// use std::path::Path;\n///\n/// let path = Path::new(\"/tmp/foo/bar.txt\");\n///\n/// for component in path.components() {\n///     println!(\"{:?}\", component);\n/// }\n/// ```\n///\n/// [`Component`]: enum.Component.html\n/// [`components`]: struct.Path.html#method.components\n/// [`Path`]: struct.Path.html\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Components<'a> {\n    // The path left to parse components from\n    path: &'a [u8],\n\n    // The prefix as it was originally parsed, if any\n    prefix: Option<Prefix<'a>>,\n\n    // true if path *physically* has a root separator; for most Windows\n    // prefixes, it may have a \"logical\" rootseparator for the purposes of\n    // normalization, e.g.  \\\\server\\share == \\\\server\\share\\.\n    has_physical_root: bool,\n\n    // The iterator is double-ended, and these two states keep track of what has\n    // been produced from either end\n    front: State,\n    back: State,\n}\n\n/// An iterator over the [`Component`]s of a [`Path`], as [`OsStr`] slices.\n///\n/// This `struct` is created by the [`iter`] method on [`Path`].\n/// See its documentation for more.\n///\n/// [`Component`]: enum.Component.html\n/// [`iter`]: struct.Path.html#method.iter\n/// [`OsStr`]: ../../std/ffi/struct.OsStr.html\n/// [`Path`]: struct.Path.html\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Iter<'a> {\n    inner: Components<'a>,\n}\n\n#[stable(feature = \"path_components_debug\", since = \"1.13.0\")]\nimpl<'a> fmt::Debug for Components<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        struct DebugHelper<'a>(&'a Path);\n\n        impl<'a> fmt::Debug for DebugHelper<'a> {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                f.debug_list()\n                    .entries(self.0.components())\n                    .finish()\n            }\n        }\n\n        f.debug_tuple(\"Components\")\n            .field(&DebugHelper(self.as_path()))\n            .finish()\n    }\n}\n\nimpl<'a> Components<'a> {\n    // how long is the prefix, if any?\n    #[inline]\n    fn prefix_len(&self) -> usize {\n        self.prefix.as_ref().map(Prefix::len).unwrap_or(0)\n    }\n\n    #[inline]\n    fn prefix_verbatim(&self) -> bool {\n        self.prefix.as_ref().map(Prefix::is_verbatim).unwrap_or(false)\n    }\n\n    /// how much of the prefix is left from the point of view of iteration?\n    #[inline]\n    fn prefix_remaining(&self) -> usize {\n        if self.front == State::Prefix {\n            self.prefix_len()\n        } else {\n            0\n        }\n    }\n\n    // Given the iteration so far, how much of the pre-State::Body path is left?\n    #[inline]\n    fn len_before_body(&self) -> usize {\n        let root = if self.front <= State::StartDir && self.has_physical_root {\n            1\n        } else {\n            0\n        };\n        let cur_dir = if self.front <= State::StartDir && self.include_cur_dir() {\n            1\n        } else {\n            0\n        };\n        self.prefix_remaining() + root + cur_dir\n    }\n\n    // is the iteration complete?\n    #[inline]\n    fn finished(&self) -> bool {\n        self.front == State::Done || self.back == State::Done || self.front > self.back\n    }\n\n    #[inline]\n    fn is_sep_byte(&self, b: u8) -> bool {\n        if self.prefix_verbatim() {\n            is_verbatim_sep(b)\n        } else {\n            is_sep_byte(b)\n        }\n    }\n\n    /// Extracts a slice corresponding to the portion of the path remaining for iteration.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let mut components = Path::new(\"/tmp/foo/bar.txt\").components();\n    /// components.next();\n    /// components.next();\n    ///\n    /// assert_eq!(Path::new(\"foo/bar.txt\"), components.as_path());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_path(&self) -> &'a Path {\n        let mut comps = self.clone();\n        if comps.front == State::Body {\n            comps.trim_left();\n        }\n        if comps.back == State::Body {\n            comps.trim_right();\n        }\n        unsafe { Path::from_u8_slice(comps.path) }\n    }\n\n    /// Is the *original* path rooted?\n    fn has_root(&self) -> bool {\n        if self.has_physical_root {\n            return true;\n        }\n        if let Some(p) = self.prefix {\n            if p.has_implicit_root() {\n                return true;\n            }\n        }\n        false\n    }\n\n    /// Should the normalized path include a leading . ?\n    fn include_cur_dir(&self) -> bool {\n        if self.has_root() {\n            return false;\n        }\n        let mut iter = self.path[self.prefix_len()..].iter();\n        match (iter.next(), iter.next()) {\n            (Some(&b'.'), None) => true,\n            (Some(&b'.'), Some(&b)) => self.is_sep_byte(b),\n            _ => false,\n        }\n    }\n\n    // parse a given byte sequence into the corresponding path component\n    fn parse_single_component<'b>(&self, comp: &'b [u8]) -> Option<Component<'b>> {\n        match comp {\n            b\".\" if self.prefix_verbatim() => Some(Component::CurDir),\n            b\".\" => None, // . components are normalized away, except at\n                          // the beginning of a path, which is treated\n                          // separately via `include_cur_dir`\n            b\"..\" => Some(Component::ParentDir),\n            b\"\" => None,\n            _ => Some(Component::Normal(unsafe { u8_slice_as_os_str(comp) })),\n        }\n    }\n\n    // parse a component from the left, saying how many bytes to consume to\n    // remove the component\n    fn parse_next_component(&self) -> (usize, Option<Component<'a>>) {\n        debug_assert!(self.front == State::Body);\n        let (extra, comp) = match self.path.iter().position(|b| self.is_sep_byte(*b)) {\n            None => (0, self.path),\n            Some(i) => (1, &self.path[..i]),\n        };\n        (comp.len() + extra, self.parse_single_component(comp))\n    }\n\n    // parse a component from the right, saying how many bytes to consume to\n    // remove the component\n    fn parse_next_component_back(&self) -> (usize, Option<Component<'a>>) {\n        debug_assert!(self.back == State::Body);\n        let start = self.len_before_body();\n        let (extra, comp) = match self.path[start..].iter().rposition(|b| self.is_sep_byte(*b)) {\n            None => (0, &self.path[start..]),\n            Some(i) => (1, &self.path[start + i + 1..]),\n        };\n        (comp.len() + extra, self.parse_single_component(comp))\n    }\n\n    // trim away repeated separators (i.e. empty components) on the left\n    fn trim_left(&mut self) {\n        while !self.path.is_empty() {\n            let (size, comp) = self.parse_next_component();\n            if comp.is_some() {\n                return;\n            } else {\n                self.path = &self.path[size..];\n            }\n        }\n    }\n\n    // trim away repeated separators (i.e. empty components) on the right\n    fn trim_right(&mut self) {\n        while self.path.len() > self.len_before_body() {\n            let (size, comp) = self.parse_next_component_back();\n            if comp.is_some() {\n                return;\n            } else {\n                self.path = &self.path[..self.path.len() - size];\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> AsRef<Path> for Components<'a> {\n    fn as_ref(&self) -> &Path {\n        self.as_path()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> AsRef<OsStr> for Components<'a> {\n    fn as_ref(&self) -> &OsStr {\n        self.as_path().as_os_str()\n    }\n}\n\n#[stable(feature = \"path_iter_debug\", since = \"1.13.0\")]\nimpl<'a> fmt::Debug for Iter<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        struct DebugHelper<'a>(&'a Path);\n\n        impl<'a> fmt::Debug for DebugHelper<'a> {\n            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n                f.debug_list()\n                    .entries(self.0.iter())\n                    .finish()\n            }\n        }\n\n        f.debug_tuple(\"Iter\")\n            .field(&DebugHelper(self.as_path()))\n            .finish()\n    }\n}\n\nimpl<'a> Iter<'a> {\n    /// Extracts a slice corresponding to the portion of the path remaining for iteration.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let mut iter = Path::new(\"/tmp/foo/bar.txt\").iter();\n    /// iter.next();\n    /// iter.next();\n    ///\n    /// assert_eq!(Path::new(\"foo/bar.txt\"), iter.as_path());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_path(&self) -> &'a Path {\n        self.inner.as_path()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> AsRef<Path> for Iter<'a> {\n    fn as_ref(&self) -> &Path {\n        self.as_path()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> AsRef<OsStr> for Iter<'a> {\n    fn as_ref(&self) -> &OsStr {\n        self.as_path().as_os_str()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for Iter<'a> {\n    type Item = &'a OsStr;\n\n    fn next(&mut self) -> Option<&'a OsStr> {\n        self.inner.next().map(Component::as_os_str)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> DoubleEndedIterator for Iter<'a> {\n    fn next_back(&mut self) -> Option<&'a OsStr> {\n        self.inner.next_back().map(Component::as_os_str)\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a> FusedIterator for Iter<'a> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Iterator for Components<'a> {\n    type Item = Component<'a>;\n\n    fn next(&mut self) -> Option<Component<'a>> {\n        while !self.finished() {\n            match self.front {\n                State::Prefix if self.prefix_len() > 0 => {\n                    self.front = State::StartDir;\n                    debug_assert!(self.prefix_len() <= self.path.len());\n                    let raw = &self.path[..self.prefix_len()];\n                    self.path = &self.path[self.prefix_len()..];\n                    return Some(Component::Prefix(PrefixComponent {\n                        raw: unsafe { u8_slice_as_os_str(raw) },\n                        parsed: self.prefix.unwrap(),\n                    }));\n                }\n                State::Prefix => {\n                    self.front = State::StartDir;\n                }\n                State::StartDir => {\n                    self.front = State::Body;\n                    if self.has_physical_root {\n                        debug_assert!(!self.path.is_empty());\n                        self.path = &self.path[1..];\n                        return Some(Component::RootDir);\n                    } else if let Some(p) = self.prefix {\n                        if p.has_implicit_root() && !p.is_verbatim() {\n                            return Some(Component::RootDir);\n                        }\n                    } else if self.include_cur_dir() {\n                        debug_assert!(!self.path.is_empty());\n                        self.path = &self.path[1..];\n                        return Some(Component::CurDir);\n                    }\n                }\n                State::Body if !self.path.is_empty() => {\n                    let (size, comp) = self.parse_next_component();\n                    self.path = &self.path[size..];\n                    if comp.is_some() {\n                        return comp;\n                    }\n                }\n                State::Body => {\n                    self.front = State::Done;\n                }\n                State::Done => unreachable!(),\n            }\n        }\n        None\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> DoubleEndedIterator for Components<'a> {\n    fn next_back(&mut self) -> Option<Component<'a>> {\n        while !self.finished() {\n            match self.back {\n                State::Body if self.path.len() > self.len_before_body() => {\n                    let (size, comp) = self.parse_next_component_back();\n                    self.path = &self.path[..self.path.len() - size];\n                    if comp.is_some() {\n                        return comp;\n                    }\n                }\n                State::Body => {\n                    self.back = State::StartDir;\n                }\n                State::StartDir => {\n                    self.back = State::Prefix;\n                    if self.has_physical_root {\n                        self.path = &self.path[..self.path.len() - 1];\n                        return Some(Component::RootDir);\n                    } else if let Some(p) = self.prefix {\n                        if p.has_implicit_root() && !p.is_verbatim() {\n                            return Some(Component::RootDir);\n                        }\n                    } else if self.include_cur_dir() {\n                        self.path = &self.path[..self.path.len() - 1];\n                        return Some(Component::CurDir);\n                    }\n                }\n                State::Prefix if self.prefix_len() > 0 => {\n                    self.back = State::Done;\n                    return Some(Component::Prefix(PrefixComponent {\n                        raw: unsafe { u8_slice_as_os_str(self.path) },\n                        parsed: self.prefix.unwrap(),\n                    }));\n                }\n                State::Prefix => {\n                    self.back = State::Done;\n                    return None;\n                }\n                State::Done => unreachable!(),\n            }\n        }\n        None\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a> FusedIterator for Components<'a> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::PartialEq for Components<'a> {\n    fn eq(&self, other: &Components<'a>) -> bool {\n        Iterator::eq(self.clone(), other.clone())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::Eq for Components<'a> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::PartialOrd for Components<'a> {\n    fn partial_cmp(&self, other: &Components<'a>) -> Option<cmp::Ordering> {\n        Iterator::partial_cmp(self.clone(), other.clone())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> cmp::Ord for Components<'a> {\n    fn cmp(&self, other: &Components<'a>) -> cmp::Ordering {\n        Iterator::cmp(self.clone(), other.clone())\n    }\n}\n\n/// An iterator over [`Path`] and its ancestors.\n///\n/// This `struct` is created by the [`ancestors`] method on [`Path`].\n/// See its documentation for more.\n///\n/// # Examples\n///\n/// ```\n/// use std::path::Path;\n///\n/// let path = Path::new(\"/foo/bar\");\n///\n/// for ancestor in path.ancestors() {\n///     println!(\"{}\", ancestor.display());\n/// }\n/// ```\n///\n/// [`ancestors`]: struct.Path.html#method.ancestors\n/// [`Path`]: struct.Path.html\n#[derive(Copy, Clone, Debug)]\n#[stable(feature = \"path_ancestors\", since = \"1.28.0\")]\npub struct Ancestors<'a> {\n    next: Option<&'a Path>,\n}\n\n#[stable(feature = \"path_ancestors\", since = \"1.28.0\")]\nimpl<'a> Iterator for Ancestors<'a> {\n    type Item = &'a Path;\n\n    fn next(&mut self) -> Option<Self::Item> {\n        let next = self.next;\n        self.next = next.and_then(Path::parent);\n        next\n    }\n}\n\n#[stable(feature = \"path_ancestors\", since = \"1.28.0\")]\nimpl<'a> FusedIterator for Ancestors<'a> {}\n\n////////////////////////////////////////////////////////////////////////////////\n// Basic types and traits\n////////////////////////////////////////////////////////////////////////////////\n\n/// An owned, mutable path (akin to [`String`]).\n///\n/// This type provides methods like [`push`] and [`set_extension`] that mutate\n/// the path in place. It also implements [`Deref`] to [`Path`], meaning that\n/// all methods on [`Path`] slices are available on `PathBuf` values as well.\n///\n/// [`String`]: ../string/struct.String.html\n/// [`Path`]: struct.Path.html\n/// [`push`]: struct.PathBuf.html#method.push\n/// [`set_extension`]: struct.PathBuf.html#method.set_extension\n/// [`Deref`]: ../ops/trait.Deref.html\n///\n/// More details about the overall approach can be found in\n/// the [module documentation](index.html).\n///\n/// # Examples\n///\n/// You can use [`push`] to build up a `PathBuf` from\n/// components:\n///\n/// ```\n/// use std::path::PathBuf;\n///\n/// let mut path = PathBuf::new();\n///\n/// path.push(r\"C:\\\");\n/// path.push(\"windows\");\n/// path.push(\"system32\");\n///\n/// path.set_extension(\"dll\");\n/// ```\n///\n/// However, [`push`] is best used for dynamic situations. This is a better way\n/// to do this when you know all of the components ahead of time:\n///\n/// ```\n/// use std::path::PathBuf;\n///\n/// let path: PathBuf = [r\"C:\\\", \"windows\", \"system32.dll\"].iter().collect();\n/// ```\n///\n/// We can still do better than this! Since these are all strings, we can use\n/// `From::from`:\n///\n/// ```\n/// use std::path::PathBuf;\n///\n/// let path = PathBuf::from(r\"C:\\windows\\system32.dll\");\n/// ```\n///\n/// Which method works best depends on what kind of situation you're in.\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct PathBuf {\n    inner: OsString,\n}\n\nimpl PathBuf {\n    fn as_mut_vec(&mut self) -> &mut Vec<u8> {\n        unsafe { &mut *(self as *mut PathBuf as *mut Vec<u8>) }\n    }\n\n    /// Allocates an empty `PathBuf`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::PathBuf;\n    ///\n    /// let path = PathBuf::new();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> PathBuf {\n        PathBuf { inner: OsString::new() }\n    }\n\n    /// Coerces to a [`Path`] slice.\n    ///\n    /// [`Path`]: struct.Path.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let p = PathBuf::from(\"/test\");\n    /// assert_eq!(Path::new(\"/test\"), p.as_path());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_path(&self) -> &Path {\n        self\n    }\n\n    /// Extends `self` with `path`.\n    ///\n    /// If `path` is absolute, it replaces the current path.\n    ///\n    /// On Windows:\n    ///\n    /// * if `path` has a root but no prefix (e.g. `\\windows`), it\n    ///   replaces everything except for the prefix (if any) of `self`.\n    /// * if `path` has a prefix but no root, it replaces `self`.\n    ///\n    /// # Examples\n    ///\n    /// Pushing a relative path extends the existing path:\n    ///\n    /// ```\n    /// use std::path::PathBuf;\n    ///\n    /// let mut path = PathBuf::from(\"/tmp\");\n    /// path.push(\"file.bk\");\n    /// assert_eq!(path, PathBuf::from(\"/tmp/file.bk\"));\n    /// ```\n    ///\n    /// Pushing an absolute path replaces the existing path:\n    ///\n    /// ```\n    /// use std::path::PathBuf;\n    ///\n    /// let mut path = PathBuf::from(\"/tmp\");\n    /// path.push(\"/etc\");\n    /// assert_eq!(path, PathBuf::from(\"/etc\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn push<P: AsRef<Path>>(&mut self, path: P) {\n        self._push(path.as_ref())\n    }\n\n    fn _push(&mut self, path: &Path) {\n        // in general, a separator is needed if the rightmost byte is not a separator\n        let mut need_sep = self.as_mut_vec().last().map(|c| !is_sep_byte(*c)).unwrap_or(false);\n\n        // in the special case of `C:` on Windows, do *not* add a separator\n        {\n            let comps = self.components();\n            if comps.prefix_len() > 0 && comps.prefix_len() == comps.path.len() &&\n               comps.prefix.unwrap().is_drive() {\n                need_sep = false\n            }\n        }\n\n        // absolute `path` replaces `self`\n        if path.is_absolute() || path.prefix().is_some() {\n            self.as_mut_vec().truncate(0);\n\n        // `path` has a root but no prefix, e.g. `\\windows` (Windows only)\n        } else if path.has_root() {\n            let prefix_len = self.components().prefix_remaining();\n            self.as_mut_vec().truncate(prefix_len);\n\n        // `path` is a pure relative path\n        } else if need_sep {\n            self.inner.push(MAIN_SEP_STR);\n        }\n\n        self.inner.push(path);\n    }\n\n    /// Truncates `self` to [`self.parent`].\n    ///\n    /// Returns `false` and does nothing if [`self.file_name`] is [`None`].\n    /// Otherwise, returns `true`.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`self.parent`]: struct.PathBuf.html#method.parent\n    /// [`self.file_name`]: struct.PathBuf.html#method.file_name\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let mut p = PathBuf::from(\"/test/test.rs\");\n    ///\n    /// p.pop();\n    /// assert_eq!(Path::new(\"/test\"), p);\n    /// p.pop();\n    /// assert_eq!(Path::new(\"/\"), p);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn pop(&mut self) -> bool {\n        match self.parent().map(|p| p.as_u8_slice().len()) {\n            Some(len) => {\n                self.as_mut_vec().truncate(len);\n                true\n            }\n            None => false,\n        }\n    }\n\n    /// Updates [`self.file_name`] to `file_name`.\n    ///\n    /// If [`self.file_name`] was [`None`], this is equivalent to pushing\n    /// `file_name`.\n    ///\n    /// Otherwise it is equivalent to calling [`pop`] and then pushing\n    /// `file_name`. The new path will be a sibling of the original path.\n    /// (That is, it will have the same parent.)\n    ///\n    /// [`self.file_name`]: struct.PathBuf.html#method.file_name\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`pop`]: struct.PathBuf.html#method.pop\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::PathBuf;\n    ///\n    /// let mut buf = PathBuf::from(\"/\");\n    /// assert!(buf.file_name() == None);\n    /// buf.set_file_name(\"bar\");\n    /// assert!(buf == PathBuf::from(\"/bar\"));\n    /// assert!(buf.file_name().is_some());\n    /// buf.set_file_name(\"baz.txt\");\n    /// assert!(buf == PathBuf::from(\"/baz.txt\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set_file_name<S: AsRef<OsStr>>(&mut self, file_name: S) {\n        self._set_file_name(file_name.as_ref())\n    }\n\n    fn _set_file_name(&mut self, file_name: &OsStr) {\n        if self.file_name().is_some() {\n            let popped = self.pop();\n            debug_assert!(popped);\n        }\n        self.push(file_name);\n    }\n\n    /// Updates [`self.extension`] to `extension`.\n    ///\n    /// Returns `false` and does nothing if [`self.file_name`] is [`None`],\n    /// returns `true` and updates the extension otherwise.\n    ///\n    /// If [`self.extension`] is [`None`], the extension is added; otherwise\n    /// it is replaced.\n    ///\n    /// [`self.file_name`]: struct.PathBuf.html#method.file_name\n    /// [`self.extension`]: struct.PathBuf.html#method.extension\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let mut p = PathBuf::from(\"/feel/the\");\n    ///\n    /// p.set_extension(\"force\");\n    /// assert_eq!(Path::new(\"/feel/the.force\"), p.as_path());\n    ///\n    /// p.set_extension(\"dark_side\");\n    /// assert_eq!(Path::new(\"/feel/the.dark_side\"), p.as_path());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool {\n        self._set_extension(extension.as_ref())\n    }\n\n    fn _set_extension(&mut self, extension: &OsStr) -> bool {\n        if self.file_name().is_none() {\n            return false;\n        }\n\n        let mut stem = match self.file_stem() {\n            Some(stem) => stem.to_os_string(),\n            None => OsString::new(),\n        };\n\n        if !os_str_as_u8_slice(extension).is_empty() {\n            stem.push(\".\");\n            stem.push(extension);\n        }\n        self.set_file_name(&stem);\n\n        true\n    }\n\n    /// Consumes the `PathBuf`, yielding its internal [`OsString`] storage.\n    ///\n    /// [`OsString`]: ../ffi/struct.OsString.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::PathBuf;\n    ///\n    /// let p = PathBuf::from(\"/the/head\");\n    /// let os_str = p.into_os_string();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_os_string(self) -> OsString {\n        self.inner\n    }\n\n    /// Converts this `PathBuf` into a [boxed][`Box`] [`Path`].\n    ///\n    /// [`Box`]: ../../std/boxed/struct.Box.html\n    /// [`Path`]: struct.Path.html\n    #[stable(feature = \"into_boxed_path\", since = \"1.20.0\")]\n    pub fn into_boxed_path(self) -> Box<Path> {\n        let rw = Box::into_raw(self.inner.into_boxed_os_str()) as *mut Path;\n        unsafe { Box::from_raw(rw) }\n    }\n}\n\n#[stable(feature = \"box_from_path\", since = \"1.17.0\")]\nimpl<'a> From<&'a Path> for Box<Path> {\n    fn from(path: &'a Path) -> Box<Path> {\n        let boxed: Box<OsStr> = path.inner.into();\n        let rw = Box::into_raw(boxed) as *mut Path;\n        unsafe { Box::from_raw(rw) }\n    }\n}\n\n#[stable(feature = \"path_buf_from_box\", since = \"1.18.0\")]\nimpl From<Box<Path>> for PathBuf {\n    fn from(boxed: Box<Path>) -> PathBuf {\n        boxed.into_path_buf()\n    }\n}\n\n#[stable(feature = \"box_from_path_buf\", since = \"1.20.0\")]\nimpl From<PathBuf> for Box<Path> {\n    fn from(p: PathBuf) -> Box<Path> {\n        p.into_boxed_path()\n    }\n}\n\n#[stable(feature = \"more_box_slice_clone\", since = \"1.29.0\")]\nimpl Clone for Box<Path> {\n    #[inline]\n    fn clone(&self) -> Self {\n        self.to_path_buf().into_boxed_path()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: ?Sized + AsRef<OsStr>> From<&'a T> for PathBuf {\n    fn from(s: &'a T) -> PathBuf {\n        PathBuf::from(s.as_ref().to_os_string())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl From<OsString> for PathBuf {\n    fn from(s: OsString) -> PathBuf {\n        PathBuf { inner: s }\n    }\n}\n\n#[stable(feature = \"from_path_buf_for_os_string\", since = \"1.14.0\")]\nimpl From<PathBuf> for OsString {\n    fn from(path_buf : PathBuf) -> OsString {\n        path_buf.inner\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl From<String> for PathBuf {\n    fn from(s: String) -> PathBuf {\n        PathBuf::from(OsString::from(s))\n    }\n}\n\n#[stable(feature = \"path_from_str\", since = \"1.26.0\")]\nimpl FromStr for PathBuf {\n    type Err = ParseError;\n\n    fn from_str(s: &str) -> Result<Self, Self::Err> {\n        Ok(PathBuf::from(s))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<P: AsRef<Path>> iter::FromIterator<P> for PathBuf {\n    fn from_iter<I: IntoIterator<Item = P>>(iter: I) -> PathBuf {\n        let mut buf = PathBuf::new();\n        buf.extend(iter);\n        buf\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<P: AsRef<Path>> iter::Extend<P> for PathBuf {\n    fn extend<I: IntoIterator<Item = P>>(&mut self, iter: I) {\n        for p in iter {\n            self.push(p.as_ref())\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for PathBuf {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&**self, formatter)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ops::Deref for PathBuf {\n    type Target = Path;\n\n    fn deref(&self) -> &Path {\n        Path::new(&self.inner)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Borrow<Path> for PathBuf {\n    fn borrow(&self) -> &Path {\n        self.deref()\n    }\n}\n\n#[stable(feature = \"default_for_pathbuf\", since = \"1.17.0\")]\nimpl Default for PathBuf {\n    fn default() -> Self {\n        PathBuf::new()\n    }\n}\n\n#[stable(feature = \"cow_from_path\", since = \"1.6.0\")]\nimpl<'a> From<&'a Path> for Cow<'a, Path> {\n    #[inline]\n    fn from(s: &'a Path) -> Cow<'a, Path> {\n        Cow::Borrowed(s)\n    }\n}\n\n#[stable(feature = \"cow_from_path\", since = \"1.6.0\")]\nimpl<'a> From<PathBuf> for Cow<'a, Path> {\n    #[inline]\n    fn from(s: PathBuf) -> Cow<'a, Path> {\n        Cow::Owned(s)\n    }\n}\n\n#[stable(feature = \"cow_from_pathbuf_ref\", since = \"1.28.0\")]\nimpl<'a> From<&'a PathBuf> for Cow<'a, Path> {\n    #[inline]\n    fn from(p: &'a PathBuf) -> Cow<'a, Path> {\n        Cow::Borrowed(p.as_path())\n    }\n}\n\n#[stable(feature = \"pathbuf_from_cow_path\", since = \"1.28.0\")]\nimpl<'a> From<Cow<'a, Path>> for PathBuf {\n    #[inline]\n    fn from(p: Cow<'a, Path>) -> Self {\n        p.into_owned()\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<PathBuf> for Arc<Path> {\n    #[inline]\n    fn from(s: PathBuf) -> Arc<Path> {\n        let arc: Arc<OsStr> = Arc::from(s.into_os_string());\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a Path> for Arc<Path> {\n    #[inline]\n    fn from(s: &Path) -> Arc<Path> {\n        let arc: Arc<OsStr> = Arc::from(s.as_os_str());\n        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Path) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl From<PathBuf> for Rc<Path> {\n    #[inline]\n    fn from(s: PathBuf) -> Rc<Path> {\n        let rc: Rc<OsStr> = Rc::from(s.into_os_string());\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }\n    }\n}\n\n#[stable(feature = \"shared_from_slice2\", since = \"1.24.0\")]\nimpl<'a> From<&'a Path> for Rc<Path> {\n    #[inline]\n    fn from(s: &Path) -> Rc<Path> {\n        let rc: Rc<OsStr> = Rc::from(s.as_os_str());\n        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Path) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToOwned for Path {\n    type Owned = PathBuf;\n    fn to_owned(&self) -> PathBuf {\n        self.to_path_buf()\n    }\n    fn clone_into(&self, target: &mut PathBuf) {\n        self.inner.clone_into(&mut target.inner);\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::PartialEq for PathBuf {\n    fn eq(&self, other: &PathBuf) -> bool {\n        self.components() == other.components()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Hash for PathBuf {\n    fn hash<H: Hasher>(&self, h: &mut H) {\n        self.as_path().hash(h)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::Eq for PathBuf {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::PartialOrd for PathBuf {\n    fn partial_cmp(&self, other: &PathBuf) -> Option<cmp::Ordering> {\n        self.components().partial_cmp(other.components())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::Ord for PathBuf {\n    fn cmp(&self, other: &PathBuf) -> cmp::Ordering {\n        self.components().cmp(other.components())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for PathBuf {\n    fn as_ref(&self) -> &OsStr {\n        &self.inner[..]\n    }\n}\n\n/// A slice of a path (akin to [`str`]).\n///\n/// This type supports a number of operations for inspecting a path, including\n/// breaking the path into its components (separated by `/` on Unix and by either\n/// `/` or `\\` on Windows), extracting the file name, determining whether the path\n/// is absolute, and so on.\n///\n/// This is an *unsized* type, meaning that it must always be used behind a\n/// pointer like `&` or [`Box`]. For an owned version of this type,\n/// see [`PathBuf`].\n///\n/// [`str`]: ../primitive.str.html\n/// [`Box`]: ../boxed/struct.Box.html\n/// [`PathBuf`]: struct.PathBuf.html\n///\n/// More details about the overall approach can be found in\n/// the [module documentation](index.html).\n///\n/// # Examples\n///\n/// ```\n/// use std::path::Path;\n/// use std::ffi::OsStr;\n///\n/// // Note: this example does work on Windows\n/// let path = Path::new(\"./foo/bar.txt\");\n///\n/// let parent = path.parent();\n/// assert_eq!(parent, Some(Path::new(\"./foo\")));\n///\n/// let file_stem = path.file_stem();\n/// assert_eq!(file_stem, Some(OsStr::new(\"bar\")));\n///\n/// let extension = path.extension();\n/// assert_eq!(extension, Some(OsStr::new(\"txt\")));\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Path {\n    inner: OsStr,\n}\n\n/// An error returned from [`Path::strip_prefix`][`strip_prefix`] if the prefix\n/// was not found.\n///\n/// This `struct` is created by the [`strip_prefix`] method on [`Path`].\n/// See its documentation for more.\n///\n/// [`strip_prefix`]: struct.Path.html#method.strip_prefix\n/// [`Path`]: struct.Path.html\n#[derive(Debug, Clone, PartialEq, Eq)]\n#[stable(since = \"1.7.0\", feature = \"strip_prefix\")]\npub struct StripPrefixError(());\n\nimpl Path {\n    // The following (private!) function allows construction of a path from a u8\n    // slice, which is only safe when it is known to follow the OsStr encoding.\n    unsafe fn from_u8_slice(s: &[u8]) -> &Path {\n        Path::new(u8_slice_as_os_str(s))\n    }\n    // The following (private!) function reveals the byte encoding used for OsStr.\n    fn as_u8_slice(&self) -> &[u8] {\n        os_str_as_u8_slice(&self.inner)\n    }\n\n    /// Directly wraps a string slice as a `Path` slice.\n    ///\n    /// This is a cost-free conversion.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// Path::new(\"foo.txt\");\n    /// ```\n    ///\n    /// You can create `Path`s from `String`s, or even other `Path`s:\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let string = String::from(\"foo.txt\");\n    /// let from_string = Path::new(&string);\n    /// let from_path = Path::new(&from_string);\n    /// assert_eq!(from_string, from_path);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path {\n        unsafe { &*(s.as_ref() as *const OsStr as *const Path) }\n    }\n\n    /// Yields the underlying [`OsStr`] slice.\n    ///\n    /// [`OsStr`]: ../ffi/struct.OsStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let os_str = Path::new(\"foo.txt\").as_os_str();\n    /// assert_eq!(os_str, std::ffi::OsStr::new(\"foo.txt\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn as_os_str(&self) -> &OsStr {\n        &self.inner\n    }\n\n    /// Yields a [`&str`] slice if the `Path` is valid unicode.\n    ///\n    /// This conversion may entail doing a check for UTF-8 validity.\n    ///\n    /// [`&str`]: ../primitive.str.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"foo.txt\");\n    /// assert_eq!(path.to_str(), Some(\"foo.txt\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_str(&self) -> Option<&str> {\n        self.inner.to_str()\n    }\n\n    /// Converts a `Path` to a [`Cow<str>`].\n    ///\n    /// Any non-Unicode sequences are replaced with\n    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].\n    ///\n    /// [`Cow<str>`]: ../borrow/enum.Cow.html\n    /// [U+FFFD]: ../char/constant.REPLACEMENT_CHARACTER.html\n    ///\n    /// # Examples\n    ///\n    /// Calling `to_string_lossy` on a `Path` with valid unicode:\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"foo.txt\");\n    /// assert_eq!(path.to_string_lossy(), \"foo.txt\");\n    /// ```\n    ///\n    /// Had `path` contained invalid unicode, the `to_string_lossy` call might\n    /// have returned `\"fo\ufffd.txt\"`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_string_lossy(&self) -> Cow<str> {\n        self.inner.to_string_lossy()\n    }\n\n    /// Converts a `Path` to an owned [`PathBuf`].\n    ///\n    /// [`PathBuf`]: struct.PathBuf.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path_buf = Path::new(\"foo.txt\").to_path_buf();\n    /// assert_eq!(path_buf, std::path::PathBuf::from(\"foo.txt\"));\n    /// ```\n    #[rustc_conversion_suggestion]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_path_buf(&self) -> PathBuf {\n        PathBuf::from(self.inner.to_os_string())\n    }\n\n    /// Returns `true` if the `Path` is absolute, i.e. if it is independent of\n    /// the current directory.\n    ///\n    /// * On Unix, a path is absolute if it starts with the root, so\n    /// `is_absolute` and [`has_root`] are equivalent.\n    ///\n    /// * On Windows, a path is absolute if it has a prefix and starts with the\n    /// root: `c:\\windows` is absolute, while `c:temp` and `\\temp` are not.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// assert!(!Path::new(\"foo.txt\").is_absolute());\n    /// ```\n    ///\n    /// [`has_root`]: #method.has_root\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[allow(deprecated)]\n    pub fn is_absolute(&self) -> bool {\n        if cfg!(target_os = \"redox\") {\n            // FIXME: Allow Redox prefixes\n            self.has_root() || has_redox_scheme(self.as_u8_slice())\n        } else {\n            self.has_root() && (cfg!(unix) || self.prefix().is_some())\n        }\n    }\n\n    /// Returns `true` if the `Path` is relative, i.e. not absolute.\n    ///\n    /// See [`is_absolute`]'s documentation for more details.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// assert!(Path::new(\"foo.txt\").is_relative());\n    /// ```\n    ///\n    /// [`is_absolute`]: #method.is_absolute\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_relative(&self) -> bool {\n        !self.is_absolute()\n    }\n\n    fn prefix(&self) -> Option<Prefix> {\n        self.components().prefix\n    }\n\n    /// Returns `true` if the `Path` has a root.\n    ///\n    /// * On Unix, a path has a root if it begins with `/`.\n    ///\n    /// * On Windows, a path has a root if it:\n    ///     * has no prefix and begins with a separator, e.g. `\\windows`\n    ///     * has a prefix followed by a separator, e.g. `c:\\windows` but not `c:windows`\n    ///     * has any non-disk prefix, e.g. `\\\\server\\share`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// assert!(Path::new(\"/etc/passwd\").has_root());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn has_root(&self) -> bool {\n        self.components().has_root()\n    }\n\n    /// Returns the `Path` without its final component, if there is one.\n    ///\n    /// Returns [`None`] if the path terminates in a root or prefix.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/foo/bar\");\n    /// let parent = path.parent().unwrap();\n    /// assert_eq!(parent, Path::new(\"/foo\"));\n    ///\n    /// let grand_parent = parent.parent().unwrap();\n    /// assert_eq!(grand_parent, Path::new(\"/\"));\n    /// assert_eq!(grand_parent.parent(), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn parent(&self) -> Option<&Path> {\n        let mut comps = self.components();\n        let comp = comps.next_back();\n        comp.and_then(|p| {\n            match p {\n                Component::Normal(_) |\n                Component::CurDir |\n                Component::ParentDir => Some(comps.as_path()),\n                _ => None,\n            }\n        })\n    }\n\n    /// Produces an iterator over `Path` and its ancestors.\n    ///\n    /// The iterator will yield the `Path` that is returned if the [`parent`] method is used zero\n    /// or more times. That means, the iterator will yield `&self`, `&self.parent().unwrap()`,\n    /// `&self.parent().unwrap().parent().unwrap()` and so on. If the [`parent`] method returns\n    /// [`None`], the iterator will do likewise. The iterator will always yield at least one value,\n    /// namely `&self`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let mut ancestors = Path::new(\"/foo/bar\").ancestors();\n    /// assert_eq!(ancestors.next(), Some(Path::new(\"/foo/bar\")));\n    /// assert_eq!(ancestors.next(), Some(Path::new(\"/foo\")));\n    /// assert_eq!(ancestors.next(), Some(Path::new(\"/\")));\n    /// assert_eq!(ancestors.next(), None);\n    /// ```\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [`parent`]: struct.Path.html#method.parent\n    #[stable(feature = \"path_ancestors\", since = \"1.28.0\")]\n    pub fn ancestors(&self) -> Ancestors {\n        Ancestors {\n            next: Some(&self),\n        }\n    }\n\n    /// Returns the final component of the `Path`, if there is one.\n    ///\n    /// If the path is a normal file, this is the file name. If it's the path of a directory, this\n    /// is the directory name.\n    ///\n    /// Returns [`None`] if the path terminates in `..`.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    /// use std::ffi::OsStr;\n    ///\n    /// assert_eq!(Some(OsStr::new(\"bin\")), Path::new(\"/usr/bin/\").file_name());\n    /// assert_eq!(Some(OsStr::new(\"foo.txt\")), Path::new(\"tmp/foo.txt\").file_name());\n    /// assert_eq!(Some(OsStr::new(\"foo.txt\")), Path::new(\"foo.txt/.\").file_name());\n    /// assert_eq!(Some(OsStr::new(\"foo.txt\")), Path::new(\"foo.txt/.//\").file_name());\n    /// assert_eq!(None, Path::new(\"foo.txt/..\").file_name());\n    /// assert_eq!(None, Path::new(\"/\").file_name());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn file_name(&self) -> Option<&OsStr> {\n        self.components().next_back().and_then(|p| {\n            match p {\n                Component::Normal(p) => Some(p.as_ref()),\n                _ => None,\n            }\n        })\n    }\n\n    /// Returns a path that, when joined onto `base`, yields `self`.\n    ///\n    /// # Errors\n    ///\n    /// If `base` is not a prefix of `self` (i.e. [`starts_with`]\n    /// returns `false`), returns [`Err`].\n    ///\n    /// [`starts_with`]: #method.starts_with\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let path = Path::new(\"/test/haha/foo.txt\");\n    ///\n    /// assert_eq!(path.strip_prefix(\"/\"), Ok(Path::new(\"test/haha/foo.txt\")));\n    /// assert_eq!(path.strip_prefix(\"/test\"), Ok(Path::new(\"haha/foo.txt\")));\n    /// assert_eq!(path.strip_prefix(\"/test/\"), Ok(Path::new(\"haha/foo.txt\")));\n    /// assert_eq!(path.strip_prefix(\"/test/haha/foo.txt\"), Ok(Path::new(\"\")));\n    /// assert_eq!(path.strip_prefix(\"/test/haha/foo.txt/\"), Ok(Path::new(\"\")));\n    /// assert_eq!(path.strip_prefix(\"test\").is_ok(), false);\n    /// assert_eq!(path.strip_prefix(\"/haha\").is_ok(), false);\n    ///\n    /// let prefix = PathBuf::from(\"/test/\");\n    /// assert_eq!(path.strip_prefix(prefix), Ok(Path::new(\"haha/foo.txt\")));\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"path_strip_prefix\")]\n    pub fn strip_prefix<P>(&self, base: P)\n                           -> Result<&Path, StripPrefixError>\n        where P: AsRef<Path>\n    {\n        self._strip_prefix(base.as_ref())\n    }\n\n    fn _strip_prefix(&self, base: &Path)\n                     -> Result<&Path, StripPrefixError> {\n        iter_after(self.components(), base.components())\n            .map(|c| c.as_path())\n            .ok_or(StripPrefixError(()))\n    }\n\n    /// Determines whether `base` is a prefix of `self`.\n    ///\n    /// Only considers whole path components to match.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/etc/passwd\");\n    ///\n    /// assert!(path.starts_with(\"/etc\"));\n    /// assert!(path.starts_with(\"/etc/\"));\n    /// assert!(path.starts_with(\"/etc/passwd\"));\n    /// assert!(path.starts_with(\"/etc/passwd/\"));\n    ///\n    /// assert!(!path.starts_with(\"/e\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool {\n        self._starts_with(base.as_ref())\n    }\n\n    fn _starts_with(&self, base: &Path) -> bool {\n        iter_after(self.components(), base.components()).is_some()\n    }\n\n    /// Determines whether `child` is a suffix of `self`.\n    ///\n    /// Only considers whole path components to match.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/etc/passwd\");\n    ///\n    /// assert!(path.ends_with(\"passwd\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool {\n        self._ends_with(child.as_ref())\n    }\n\n    fn _ends_with(&self, child: &Path) -> bool {\n        iter_after(self.components().rev(), child.components().rev()).is_some()\n    }\n\n    /// Extracts the stem (non-extension) portion of [`self.file_name`].\n    ///\n    /// [`self.file_name`]: struct.Path.html#method.file_name\n    ///\n    /// The stem is:\n    ///\n    /// * [`None`], if there is no file name;\n    /// * The entire file name if there is no embedded `.`;\n    /// * The entire file name if the file name begins with `.` and has no other `.`s within;\n    /// * Otherwise, the portion of the file name before the final `.`\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"foo.rs\");\n    ///\n    /// assert_eq!(\"foo\", path.file_stem().unwrap());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn file_stem(&self) -> Option<&OsStr> {\n        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.or(after))\n    }\n\n    /// Extracts the extension of [`self.file_name`], if possible.\n    ///\n    /// The extension is:\n    ///\n    /// * [`None`], if there is no file name;\n    /// * [`None`], if there is no embedded `.`;\n    /// * [`None`], if the file name begins with `.` and has no other `.`s within;\n    /// * Otherwise, the portion of the file name after the final `.`\n    ///\n    /// [`self.file_name`]: struct.Path.html#method.file_name\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"foo.rs\");\n    ///\n    /// assert_eq!(\"rs\", path.extension().unwrap());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn extension(&self) -> Option<&OsStr> {\n        self.file_name().map(split_file_at_dot).and_then(|(before, after)| before.and(after))\n    }\n\n    /// Creates an owned [`PathBuf`] with `path` adjoined to `self`.\n    ///\n    /// See [`PathBuf::push`] for more details on what it means to adjoin a path.\n    ///\n    /// [`PathBuf`]: struct.PathBuf.html\n    /// [`PathBuf::push`]: struct.PathBuf.html#method.push\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// assert_eq!(Path::new(\"/etc\").join(\"passwd\"), PathBuf::from(\"/etc/passwd\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf {\n        self._join(path.as_ref())\n    }\n\n    fn _join(&self, path: &Path) -> PathBuf {\n        let mut buf = self.to_path_buf();\n        buf.push(path);\n        buf\n    }\n\n    /// Creates an owned [`PathBuf`] like `self` but with the given file name.\n    ///\n    /// See [`PathBuf::set_file_name`] for more details.\n    ///\n    /// [`PathBuf`]: struct.PathBuf.html\n    /// [`PathBuf::set_file_name`]: struct.PathBuf.html#method.set_file_name\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let path = Path::new(\"/tmp/foo.txt\");\n    /// assert_eq!(path.with_file_name(\"bar.txt\"), PathBuf::from(\"/tmp/bar.txt\"));\n    ///\n    /// let path = Path::new(\"/tmp\");\n    /// assert_eq!(path.with_file_name(\"var\"), PathBuf::from(\"/var\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf {\n        self._with_file_name(file_name.as_ref())\n    }\n\n    fn _with_file_name(&self, file_name: &OsStr) -> PathBuf {\n        let mut buf = self.to_path_buf();\n        buf.set_file_name(file_name);\n        buf\n    }\n\n    /// Creates an owned [`PathBuf`] like `self` but with the given extension.\n    ///\n    /// See [`PathBuf::set_extension`] for more details.\n    ///\n    /// [`PathBuf`]: struct.PathBuf.html\n    /// [`PathBuf::set_extension`]: struct.PathBuf.html#method.set_extension\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let path = Path::new(\"foo.rs\");\n    /// assert_eq!(path.with_extension(\"txt\"), PathBuf::from(\"foo.txt\"));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf {\n        self._with_extension(extension.as_ref())\n    }\n\n    fn _with_extension(&self, extension: &OsStr) -> PathBuf {\n        let mut buf = self.to_path_buf();\n        buf.set_extension(extension);\n        buf\n    }\n\n    /// Produces an iterator over the [`Component`]s of the path.\n    ///\n    /// When parsing the path, there is a small amount of normalization:\n    ///\n    /// * Repeated separators are ignored, so `a/b` and `a//b` both have\n    ///   `a` and `b` as components.\n    ///\n    /// * Occurrences of `.` are normalized away, except if they are at the\n    ///   beginning of the path. For example, `a/./b`, `a/b/`, `a/b/.` and\n    ///   `a/b` all have `a` and `b` as components, but `./a/b` starts with\n    ///   an additional [`CurDir`] component.\n    ///\n    /// Note that no other normalization takes place; in particular, `a/c`\n    /// and `a/b/../c` are distinct, to account for the possibility that `b`\n    /// is a symbolic link (so its parent isn't `a`).\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{Path, Component};\n    /// use std::ffi::OsStr;\n    ///\n    /// let mut components = Path::new(\"/tmp/foo.txt\").components();\n    ///\n    /// assert_eq!(components.next(), Some(Component::RootDir));\n    /// assert_eq!(components.next(), Some(Component::Normal(OsStr::new(\"tmp\"))));\n    /// assert_eq!(components.next(), Some(Component::Normal(OsStr::new(\"foo.txt\"))));\n    /// assert_eq!(components.next(), None)\n    /// ```\n    ///\n    /// [`Component`]: enum.Component.html\n    /// [`CurDir`]: enum.Component.html#variant.CurDir\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn components(&self) -> Components {\n        let prefix = parse_prefix(self.as_os_str());\n        Components {\n            path: self.as_u8_slice(),\n            prefix,\n            has_physical_root: has_physical_root(self.as_u8_slice(), prefix) ||\n                               has_redox_scheme(self.as_u8_slice()),\n            front: State::Prefix,\n            back: State::Body,\n        }\n    }\n\n    /// Produces an iterator over the path's components viewed as [`OsStr`]\n    /// slices.\n    ///\n    /// For more information about the particulars of how the path is separated\n    /// into components, see [`components`].\n    ///\n    /// [`components`]: #method.components\n    /// [`OsStr`]: ../ffi/struct.OsStr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::{self, Path};\n    /// use std::ffi::OsStr;\n    ///\n    /// let mut it = Path::new(\"/tmp/foo.txt\").iter();\n    /// assert_eq!(it.next(), Some(OsStr::new(&path::MAIN_SEPARATOR.to_string())));\n    /// assert_eq!(it.next(), Some(OsStr::new(\"tmp\")));\n    /// assert_eq!(it.next(), Some(OsStr::new(\"foo.txt\")));\n    /// assert_eq!(it.next(), None)\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter(&self) -> Iter {\n        Iter { inner: self.components() }\n    }\n\n    /// Returns an object that implements [`Display`] for safely printing paths\n    /// that may contain non-Unicode data.\n    ///\n    /// [`Display`]: ../fmt/trait.Display.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/tmp/foo.rs\");\n    ///\n    /// println!(\"{}\", path.display());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn display(&self) -> Display {\n        Display { path: self }\n    }\n\n    /// Queries the file system to get information about a file, directory, etc.\n    ///\n    /// This function will traverse symbolic links to query information about the\n    /// destination file.\n    ///\n    /// This is an alias to [`fs::metadata`].\n    ///\n    /// [`fs::metadata`]: ../fs/fn.metadata.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/Minas/tirith\");\n    /// let metadata = path.metadata().expect(\"metadata call failed\");\n    /// println!(\"{:?}\", metadata.file_type());\n    /// ```\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn metadata(&self) -> io::Result<fs::Metadata> {\n        fs::metadata(self)\n    }\n\n    /// Queries the metadata about a file without following symlinks.\n    ///\n    /// This is an alias to [`fs::symlink_metadata`].\n    ///\n    /// [`fs::symlink_metadata`]: ../fs/fn.symlink_metadata.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/Minas/tirith\");\n    /// let metadata = path.symlink_metadata().expect(\"symlink_metadata call failed\");\n    /// println!(\"{:?}\", metadata.file_type());\n    /// ```\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn symlink_metadata(&self) -> io::Result<fs::Metadata> {\n        fs::symlink_metadata(self)\n    }\n\n    /// Returns the canonical, absolute form of the path with all intermediate\n    /// components normalized and symbolic links resolved.\n    ///\n    /// This is an alias to [`fs::canonicalize`].\n    ///\n    /// [`fs::canonicalize`]: ../fs/fn.canonicalize.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::{Path, PathBuf};\n    ///\n    /// let path = Path::new(\"/foo/test/../test/bar.rs\");\n    /// assert_eq!(path.canonicalize().unwrap(), PathBuf::from(\"/foo/test/bar.rs\"));\n    /// ```\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn canonicalize(&self) -> io::Result<PathBuf> {\n        fs::canonicalize(self)\n    }\n\n    /// Reads a symbolic link, returning the file that the link points to.\n    ///\n    /// This is an alias to [`fs::read_link`].\n    ///\n    /// [`fs::read_link`]: ../fs/fn.read_link.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/laputa/sky_castle.rs\");\n    /// let path_link = path.read_link().expect(\"read_link call failed\");\n    /// ```\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn read_link(&self) -> io::Result<PathBuf> {\n        fs::read_link(self)\n    }\n\n    /// Returns an iterator over the entries within a directory.\n    ///\n    /// The iterator will yield instances of [`io::Result`]`<`[`DirEntry`]`>`. New\n    /// errors may be encountered after an iterator is initially constructed.\n    ///\n    /// This is an alias to [`fs::read_dir`].\n    ///\n    /// [`io::Result`]: ../io/type.Result.html\n    /// [`DirEntry`]: ../fs/struct.DirEntry.html\n    /// [`fs::read_dir`]: ../fs/fn.read_dir.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    ///\n    /// let path = Path::new(\"/laputa\");\n    /// for entry in path.read_dir().expect(\"read_dir call failed\") {\n    ///     if let Ok(entry) = entry {\n    ///         println!(\"{:?}\", entry.path());\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn read_dir(&self) -> io::Result<fs::ReadDir> {\n        fs::read_dir(self)\n    }\n\n    /// Returns whether the path points at an existing entity.\n    ///\n    /// This function will traverse symbolic links to query information about the\n    /// destination file. In case of broken symbolic links this will return `false`.\n    ///\n    /// If you cannot access the directory containing the file, e.g. because of a\n    /// permission error, this will return `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    /// assert_eq!(Path::new(\"does_not_exist.txt\").exists(), false);\n    /// ```\n    ///\n    /// # See Also\n    ///\n    /// This is a convenience function that coerces errors to false. If you want to\n    /// check errors, call [fs::metadata].\n    ///\n    /// [fs::metadata]: ../../std/fs/fn.metadata.html\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn exists(&self) -> bool {\n        fs::metadata(self).is_ok()\n    }\n\n    /// Returns whether the path exists on disk and is pointing at a regular file.\n    ///\n    /// This function will traverse symbolic links to query information about the\n    /// destination file. In case of broken symbolic links this will return `false`.\n    ///\n    /// If you cannot access the directory containing the file, e.g. because of a\n    /// permission error, this will return `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    /// assert_eq!(Path::new(\"./is_a_directory/\").is_file(), false);\n    /// assert_eq!(Path::new(\"a_file.txt\").is_file(), true);\n    /// ```\n    ///\n    /// # See Also\n    ///\n    /// This is a convenience function that coerces errors to false. If you want to\n    /// check errors, call [fs::metadata] and handle its Result. Then call\n    /// [fs::Metadata::is_file] if it was Ok.\n    ///\n    /// [fs::metadata]: ../../std/fs/fn.metadata.html\n    /// [fs::Metadata::is_file]: ../../std/fs/struct.Metadata.html#method.is_file\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn is_file(&self) -> bool {\n        fs::metadata(self).map(|m| m.is_file()).unwrap_or(false)\n    }\n\n    /// Returns whether the path exists on disk and is pointing at a directory.\n    ///\n    /// This function will traverse symbolic links to query information about the\n    /// destination file. In case of broken symbolic links this will return `false`.\n    ///\n    /// If you cannot access the directory containing the file, e.g. because of a\n    /// permission error, this will return `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::path::Path;\n    /// assert_eq!(Path::new(\"./is_a_directory/\").is_dir(), true);\n    /// assert_eq!(Path::new(\"a_file.txt\").is_dir(), false);\n    /// ```\n    ///\n    /// # See Also\n    ///\n    /// This is a convenience function that coerces errors to false. If you want to\n    /// check errors, call [fs::metadata] and handle its Result. Then call\n    /// [fs::Metadata::is_dir] if it was Ok.\n    ///\n    /// [fs::metadata]: ../../std/fs/fn.metadata.html\n    /// [fs::Metadata::is_dir]: ../../std/fs/struct.Metadata.html#method.is_dir\n    #[stable(feature = \"path_ext\", since = \"1.5.0\")]\n    pub fn is_dir(&self) -> bool {\n        fs::metadata(self).map(|m| m.is_dir()).unwrap_or(false)\n    }\n\n    /// Converts a [`Box<Path>`][`Box`] into a [`PathBuf`] without copying or\n    /// allocating.\n    ///\n    /// [`Box`]: ../../std/boxed/struct.Box.html\n    /// [`PathBuf`]: struct.PathBuf.html\n    #[stable(feature = \"into_boxed_path\", since = \"1.20.0\")]\n    pub fn into_path_buf(self: Box<Path>) -> PathBuf {\n        let rw = Box::into_raw(self) as *mut OsStr;\n        let inner = unsafe { Box::from_raw(rw) };\n        PathBuf { inner: OsString::from(inner) }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<OsStr> for Path {\n    fn as_ref(&self) -> &OsStr {\n        &self.inner\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for Path {\n    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.inner, formatter)\n    }\n}\n\n/// Helper struct for safely printing paths with [`format!`] and `{}`.\n///\n/// A [`Path`] might contain non-Unicode data. This `struct` implements the\n/// [`Display`] trait in a way that mitigates that. It is created by the\n/// [`display`][`Path::display`] method on [`Path`].\n///\n/// # Examples\n///\n/// ```\n/// use std::path::Path;\n///\n/// let path = Path::new(\"/tmp/foo.rs\");\n///\n/// println!(\"{}\", path.display());\n/// ```\n///\n/// [`Display`]: ../../std/fmt/trait.Display.html\n/// [`format!`]: ../../std/macro.format.html\n/// [`Path`]: struct.Path.html\n/// [`Path::display`]: struct.Path.html#method.display\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Display<'a> {\n    path: &'a Path,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> fmt::Debug for Display<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.path, f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> fmt::Display for Display<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.path.inner.display(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::PartialEq for Path {\n    fn eq(&self, other: &Path) -> bool {\n        self.components().eq(other.components())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Hash for Path {\n    fn hash<H: Hasher>(&self, h: &mut H) {\n        for component in self.components() {\n            component.hash(h);\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::Eq for Path {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::PartialOrd for Path {\n    fn partial_cmp(&self, other: &Path) -> Option<cmp::Ordering> {\n        self.components().partial_cmp(other.components())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl cmp::Ord for Path {\n    fn cmp(&self, other: &Path) -> cmp::Ordering {\n        self.components().cmp(other.components())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for Path {\n    fn as_ref(&self) -> &Path {\n        self\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for OsStr {\n    fn as_ref(&self) -> &Path {\n        Path::new(self)\n    }\n}\n\n#[stable(feature = \"cow_os_str_as_ref_path\", since = \"1.8.0\")]\nimpl<'a> AsRef<Path> for Cow<'a, OsStr> {\n    fn as_ref(&self) -> &Path {\n        Path::new(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for OsString {\n    fn as_ref(&self) -> &Path {\n        Path::new(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for str {\n    fn as_ref(&self) -> &Path {\n        Path::new(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for String {\n    fn as_ref(&self) -> &Path {\n        Path::new(self)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl AsRef<Path> for PathBuf {\n    fn as_ref(&self) -> &Path {\n        self\n    }\n}\n\n#[stable(feature = \"path_into_iter\", since = \"1.6.0\")]\nimpl<'a> IntoIterator for &'a PathBuf {\n    type Item = &'a OsStr;\n    type IntoIter = Iter<'a>;\n    fn into_iter(self) -> Iter<'a> { self.iter() }\n}\n\n#[stable(feature = \"path_into_iter\", since = \"1.6.0\")]\nimpl<'a> IntoIterator for &'a Path {\n    type Item = &'a OsStr;\n    type IntoIter = Iter<'a>;\n    fn into_iter(self) -> Iter<'a> { self.iter() }\n}\n\nmacro_rules! impl_cmp {\n    ($lhs:ty, $rhs: ty) => {\n        #[stable(feature = \"partialeq_path\", since = \"1.6.0\")]\n        impl<'a, 'b> PartialEq<$rhs> for $lhs {\n            #[inline]\n            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other) }\n        }\n\n        #[stable(feature = \"partialeq_path\", since = \"1.6.0\")]\n        impl<'a, 'b> PartialEq<$lhs> for $rhs {\n            #[inline]\n            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self, other) }\n        }\n\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$rhs> for $lhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {\n                <Path as PartialOrd>::partial_cmp(self, other)\n            }\n        }\n\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$lhs> for $rhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {\n                <Path as PartialOrd>::partial_cmp(self, other)\n            }\n        }\n    }\n}\n\nimpl_cmp!(PathBuf, Path);\nimpl_cmp!(PathBuf, &'a Path);\nimpl_cmp!(Cow<'a, Path>, Path);\nimpl_cmp!(Cow<'a, Path>, &'b Path);\nimpl_cmp!(Cow<'a, Path>, PathBuf);\n\nmacro_rules! impl_cmp_os_str {\n    ($lhs:ty, $rhs: ty) => {\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialEq<$rhs> for $lhs {\n            #[inline]\n            fn eq(&self, other: &$rhs) -> bool { <Path as PartialEq>::eq(self, other.as_ref()) }\n        }\n\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialEq<$lhs> for $rhs {\n            #[inline]\n            fn eq(&self, other: &$lhs) -> bool { <Path as PartialEq>::eq(self.as_ref(), other) }\n        }\n\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$rhs> for $lhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {\n                <Path as PartialOrd>::partial_cmp(self, other.as_ref())\n            }\n        }\n\n        #[stable(feature = \"cmp_path\", since = \"1.8.0\")]\n        impl<'a, 'b> PartialOrd<$lhs> for $rhs {\n            #[inline]\n            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {\n                <Path as PartialOrd>::partial_cmp(self.as_ref(), other)\n            }\n        }\n    }\n}\n\nimpl_cmp_os_str!(PathBuf, OsStr);\nimpl_cmp_os_str!(PathBuf, &'a OsStr);\nimpl_cmp_os_str!(PathBuf, Cow<'a, OsStr>);\nimpl_cmp_os_str!(PathBuf, OsString);\nimpl_cmp_os_str!(Path, OsStr);\nimpl_cmp_os_str!(Path, &'a OsStr);\nimpl_cmp_os_str!(Path, Cow<'a, OsStr>);\nimpl_cmp_os_str!(Path, OsString);\nimpl_cmp_os_str!(&'a Path, OsStr);\nimpl_cmp_os_str!(&'a Path, Cow<'b, OsStr>);\nimpl_cmp_os_str!(&'a Path, OsString);\nimpl_cmp_os_str!(Cow<'a, Path>, OsStr);\nimpl_cmp_os_str!(Cow<'a, Path>, &'b OsStr);\nimpl_cmp_os_str!(Cow<'a, Path>, OsString);\n\n#[stable(since = \"1.7.0\", feature = \"strip_prefix\")]\nimpl fmt::Display for StripPrefixError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.description().fmt(f)\n    }\n}\n\n#[stable(since = \"1.7.0\", feature = \"strip_prefix\")]\nimpl Error for StripPrefixError {\n    fn description(&self) -> &str { \"prefix not found\" }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    use rc::Rc;\n    use sync::Arc;\n\n    macro_rules! t(\n        ($path:expr, iter: $iter:expr) => (\n            {\n                let path = Path::new($path);\n\n                // Forward iteration\n                let comps = path.iter()\n                    .map(|p| p.to_string_lossy().into_owned())\n                    .collect::<Vec<String>>();\n                let exp: &[&str] = &$iter;\n                let exps = exp.iter().map(|s| s.to_string()).collect::<Vec<String>>();\n                assert!(comps == exps, \"iter: Expected {:?}, found {:?}\",\n                        exps, comps);\n\n                // Reverse iteration\n                let comps = Path::new($path).iter().rev()\n                    .map(|p| p.to_string_lossy().into_owned())\n                    .collect::<Vec<String>>();\n                let exps = exps.into_iter().rev().collect::<Vec<String>>();\n                assert!(comps == exps, \"iter().rev(): Expected {:?}, found {:?}\",\n                        exps, comps);\n            }\n        );\n\n        ($path:expr, has_root: $has_root:expr, is_absolute: $is_absolute:expr) => (\n            {\n                let path = Path::new($path);\n\n                let act_root = path.has_root();\n                assert!(act_root == $has_root, \"has_root: Expected {:?}, found {:?}\",\n                        $has_root, act_root);\n\n                let act_abs = path.is_absolute();\n                assert!(act_abs == $is_absolute, \"is_absolute: Expected {:?}, found {:?}\",\n                        $is_absolute, act_abs);\n            }\n        );\n\n        ($path:expr, parent: $parent:expr, file_name: $file:expr) => (\n            {\n                let path = Path::new($path);\n\n                let parent = path.parent().map(|p| p.to_str().unwrap());\n                let exp_parent: Option<&str> = $parent;\n                assert!(parent == exp_parent, \"parent: Expected {:?}, found {:?}\",\n                        exp_parent, parent);\n\n                let file = path.file_name().map(|p| p.to_str().unwrap());\n                let exp_file: Option<&str> = $file;\n                assert!(file == exp_file, \"file_name: Expected {:?}, found {:?}\",\n                        exp_file, file);\n            }\n        );\n\n        ($path:expr, file_stem: $file_stem:expr, extension: $extension:expr) => (\n            {\n                let path = Path::new($path);\n\n                let stem = path.file_stem().map(|p| p.to_str().unwrap());\n                let exp_stem: Option<&str> = $file_stem;\n                assert!(stem == exp_stem, \"file_stem: Expected {:?}, found {:?}\",\n                        exp_stem, stem);\n\n                let ext = path.extension().map(|p| p.to_str().unwrap());\n                let exp_ext: Option<&str> = $extension;\n                assert!(ext == exp_ext, \"extension: Expected {:?}, found {:?}\",\n                        exp_ext, ext);\n            }\n        );\n\n        ($path:expr, iter: $iter:expr,\n                     has_root: $has_root:expr, is_absolute: $is_absolute:expr,\n                     parent: $parent:expr, file_name: $file:expr,\n                     file_stem: $file_stem:expr, extension: $extension:expr) => (\n            {\n                t!($path, iter: $iter);\n                t!($path, has_root: $has_root, is_absolute: $is_absolute);\n                t!($path, parent: $parent, file_name: $file);\n                t!($path, file_stem: $file_stem, extension: $extension);\n            }\n        );\n    );\n\n    #[test]\n    fn into() {\n        use borrow::Cow;\n\n        let static_path = Path::new(\"/home/foo\");\n        let static_cow_path: Cow<'static, Path> = static_path.into();\n        let pathbuf = PathBuf::from(\"/home/foo\");\n\n        {\n            let path: &Path = &pathbuf;\n            let borrowed_cow_path: Cow<Path> = path.into();\n\n            assert_eq!(static_cow_path, borrowed_cow_path);\n        }\n\n        let owned_cow_path: Cow<'static, Path> = pathbuf.into();\n\n        assert_eq!(static_cow_path, owned_cow_path);\n    }\n\n    #[test]\n    #[cfg(unix)]\n    pub fn test_decompositions_unix() {\n        t!(\"\",\n           iter: [],\n           has_root: false,\n           is_absolute: false,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"/\",\n           iter: [\"/\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"/foo\",\n           iter: [\"/\", \"foo\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"/foo/\",\n           iter: [\"/\", \"foo\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/bar\",\n           iter: [\"foo\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"/foo/bar\",\n           iter: [\"/\", \"foo\", \"bar\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"/foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"///foo///\",\n           iter: [\"/\", \"foo\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"///foo///bar\",\n           iter: [\"/\", \"foo\", \"bar\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"///foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"./.\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"/..\",\n           iter: [\"/\", \"..\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"/\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"../\",\n           iter: [\"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/.\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/..\",\n           iter: [\"foo\", \"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/./\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/./bar\",\n           iter: [\"foo\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"foo/../\",\n           iter: [\"foo\", \"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/../bar\",\n           iter: [\"foo\", \"..\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo/..\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"./a\",\n           iter: [\".\", \"a\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\".\"),\n           file_name: Some(\"a\"),\n           file_stem: Some(\"a\"),\n           extension: None\n           );\n\n        t!(\".\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"./\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"a/b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a//b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a/./b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a/b/c\",\n           iter: [\"a\", \"b\", \"c\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a/b\"),\n           file_name: Some(\"c\"),\n           file_stem: Some(\"c\"),\n           extension: None\n           );\n\n        t!(\".foo\",\n           iter: [\".foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\".foo\"),\n           file_stem: Some(\".foo\"),\n           extension: None\n           );\n    }\n\n    #[test]\n    #[cfg(windows)]\n    pub fn test_decompositions_windows() {\n        t!(\"\",\n           iter: [],\n           has_root: false,\n           is_absolute: false,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"/\",\n           iter: [\"\\\\\"],\n           has_root: true,\n           is_absolute: false,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\",\n           iter: [\"\\\\\"],\n           has_root: true,\n           is_absolute: false,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"c:\",\n           iter: [\"c:\"],\n           has_root: false,\n           is_absolute: false,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"c:\\\\\",\n           iter: [\"c:\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"c:/\",\n           iter: [\"c:\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"/foo\",\n           iter: [\"\\\\\", \"foo\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"/foo/\",\n           iter: [\"\\\\\", \"foo\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/bar\",\n           iter: [\"foo\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"/foo/bar\",\n           iter: [\"\\\\\", \"foo\", \"bar\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"/foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"///foo///\",\n           iter: [\"\\\\\", \"foo\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"/\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"///foo///bar\",\n           iter: [\"\\\\\", \"foo\", \"bar\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"///foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"./.\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"/..\",\n           iter: [\"\\\\\", \"..\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"/\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"../\",\n           iter: [\"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/.\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/..\",\n           iter: [\"foo\", \"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/./\",\n           iter: [\"foo\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: Some(\"foo\"),\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo/./bar\",\n           iter: [\"foo\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"foo/../\",\n           iter: [\"foo\", \"..\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"foo/../bar\",\n           iter: [\"foo\", \"..\", \"bar\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"foo/..\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n        t!(\"./a\",\n           iter: [\".\", \"a\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\".\"),\n           file_name: Some(\"a\"),\n           file_stem: Some(\"a\"),\n           extension: None\n           );\n\n        t!(\".\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"./\",\n           iter: [\".\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"\"),\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"a/b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a//b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a/./b\",\n           iter: [\"a\", \"b\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n\n        t!(\"a/b/c\",\n           iter: [\"a\", \"b\", \"c\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a/b\"),\n           file_name: Some(\"c\"),\n           file_stem: Some(\"c\"),\n           extension: None);\n\n        t!(\"a\\\\b\\\\c\",\n           iter: [\"a\", \"b\", \"c\"],\n           has_root: false,\n           is_absolute: false,\n           parent: Some(\"a\\\\b\"),\n           file_name: Some(\"c\"),\n           file_stem: Some(\"c\"),\n           extension: None\n           );\n\n        t!(\"\\\\a\",\n           iter: [\"\\\\\", \"a\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"\\\\\"),\n           file_name: Some(\"a\"),\n           file_stem: Some(\"a\"),\n           extension: None\n           );\n\n        t!(\"c:\\\\foo.txt\",\n           iter: [\"c:\", \"\\\\\", \"foo.txt\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"c:\\\\\"),\n           file_name: Some(\"foo.txt\"),\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"\\\\\\\\server\\\\share\\\\foo.txt\",\n           iter: [\"\\\\\\\\server\\\\share\", \"\\\\\", \"foo.txt\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\server\\\\share\\\\\"),\n           file_name: Some(\"foo.txt\"),\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"\\\\\\\\server\\\\share\",\n           iter: [\"\\\\\\\\server\\\\share\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\server\",\n           iter: [\"\\\\\", \"server\"],\n           has_root: true,\n           is_absolute: false,\n           parent: Some(\"\\\\\"),\n           file_name: Some(\"server\"),\n           file_stem: Some(\"server\"),\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\bar\\\\foo.txt\",\n           iter: [\"\\\\\\\\?\\\\bar\", \"\\\\\", \"foo.txt\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\?\\\\bar\\\\\"),\n           file_name: Some(\"foo.txt\"),\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"\\\\\\\\?\\\\bar\",\n           iter: [\"\\\\\\\\?\\\\bar\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\\",\n           iter: [\"\\\\\\\\?\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\foo.txt\",\n           iter: [\"\\\\\\\\?\\\\UNC\\\\server\\\\share\", \"\\\\\", \"foo.txt\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\\"),\n           file_name: Some(\"foo.txt\"),\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"\\\\\\\\?\\\\UNC\\\\server\",\n           iter: [\"\\\\\\\\?\\\\UNC\\\\server\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\UNC\\\\\",\n           iter: [\"\\\\\\\\?\\\\UNC\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\C:\\\\foo.txt\",\n           iter: [\"\\\\\\\\?\\\\C:\", \"\\\\\", \"foo.txt\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\?\\\\C:\\\\\"),\n           file_name: Some(\"foo.txt\"),\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n\n        t!(\"\\\\\\\\?\\\\C:\\\\\",\n           iter: [\"\\\\\\\\?\\\\C:\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\?\\\\C:\",\n           iter: [\"\\\\\\\\?\\\\C:\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\?\\\\foo/bar\",\n           iter: [\"\\\\\\\\?\\\\foo/bar\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\?\\\\C:/foo\",\n           iter: [\"\\\\\\\\?\\\\C:/foo\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\.\\\\foo\\\\bar\",\n           iter: [\"\\\\\\\\.\\\\foo\", \"\\\\\", \"bar\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\.\\\\foo\\\\\"),\n           file_name: Some(\"bar\"),\n           file_stem: Some(\"bar\"),\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\.\\\\foo\",\n           iter: [\"\\\\\\\\.\\\\foo\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\.\\\\foo/bar\",\n           iter: [\"\\\\\\\\.\\\\foo/bar\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\.\\\\foo\\\\bar/baz\",\n           iter: [\"\\\\\\\\.\\\\foo\", \"\\\\\", \"bar\", \"baz\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\.\\\\foo\\\\bar\"),\n           file_name: Some(\"baz\"),\n           file_stem: Some(\"baz\"),\n           extension: None\n           );\n\n\n        t!(\"\\\\\\\\.\\\\\",\n           iter: [\"\\\\\\\\.\\\\\", \"\\\\\"],\n           has_root: true,\n           is_absolute: true,\n           parent: None,\n           file_name: None,\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\\\\\\\\?\\\\a\\\\b\\\\\",\n           iter: [\"\\\\\\\\?\\\\a\", \"\\\\\", \"b\"],\n           has_root: true,\n           is_absolute: true,\n           parent: Some(\"\\\\\\\\?\\\\a\\\\\"),\n           file_name: Some(\"b\"),\n           file_stem: Some(\"b\"),\n           extension: None\n           );\n    }\n\n    #[test]\n    pub fn test_stem_ext() {\n        t!(\"foo\",\n           file_stem: Some(\"foo\"),\n           extension: None\n           );\n\n        t!(\"foo.\",\n           file_stem: Some(\"foo\"),\n           extension: Some(\"\")\n           );\n\n        t!(\".foo\",\n           file_stem: Some(\".foo\"),\n           extension: None\n           );\n\n        t!(\"foo.txt\",\n           file_stem: Some(\"foo\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"foo.bar.txt\",\n           file_stem: Some(\"foo.bar\"),\n           extension: Some(\"txt\")\n           );\n\n        t!(\"foo.bar.\",\n           file_stem: Some(\"foo.bar\"),\n           extension: Some(\"\")\n           );\n\n        t!(\".\",\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"..\",\n           file_stem: None,\n           extension: None\n           );\n\n        t!(\"\",\n           file_stem: None,\n           extension: None\n           );\n    }\n\n    #[test]\n    pub fn test_push() {\n        macro_rules! tp(\n            ($path:expr, $push:expr, $expected:expr) => ( {\n                let mut actual = PathBuf::from($path);\n                actual.push($push);\n                assert!(actual.to_str() == Some($expected),\n                        \"pushing {:?} onto {:?}: Expected {:?}, got {:?}\",\n                        $push, $path, $expected, actual.to_str().unwrap());\n            });\n        );\n\n        if cfg!(unix) {\n            tp!(\"\", \"foo\", \"foo\");\n            tp!(\"foo\", \"bar\", \"foo/bar\");\n            tp!(\"foo/\", \"bar\", \"foo/bar\");\n            tp!(\"foo//\", \"bar\", \"foo//bar\");\n            tp!(\"foo/.\", \"bar\", \"foo/./bar\");\n            tp!(\"foo./.\", \"bar\", \"foo././bar\");\n            tp!(\"foo\", \"\", \"foo/\");\n            tp!(\"foo\", \".\", \"foo/.\");\n            tp!(\"foo\", \"..\", \"foo/..\");\n            tp!(\"foo\", \"/\", \"/\");\n            tp!(\"/foo/bar\", \"/\", \"/\");\n            tp!(\"/foo/bar\", \"/baz\", \"/baz\");\n            tp!(\"/foo/bar\", \"./baz\", \"/foo/bar/./baz\");\n        } else {\n            tp!(\"\", \"foo\", \"foo\");\n            tp!(\"foo\", \"bar\", r\"foo\\bar\");\n            tp!(\"foo/\", \"bar\", r\"foo/bar\");\n            tp!(r\"foo\\\", \"bar\", r\"foo\\bar\");\n            tp!(\"foo//\", \"bar\", r\"foo//bar\");\n            tp!(r\"foo\\\\\", \"bar\", r\"foo\\\\bar\");\n            tp!(\"foo/.\", \"bar\", r\"foo/.\\bar\");\n            tp!(\"foo./.\", \"bar\", r\"foo./.\\bar\");\n            tp!(r\"foo\\.\", \"bar\", r\"foo\\.\\bar\");\n            tp!(r\"foo.\\.\", \"bar\", r\"foo.\\.\\bar\");\n            tp!(\"foo\", \"\", \"foo\\\\\");\n            tp!(\"foo\", \".\", r\"foo\\.\");\n            tp!(\"foo\", \"..\", r\"foo\\..\");\n            tp!(\"foo\", \"/\", \"/\");\n            tp!(\"foo\", r\"\\\", r\"\\\");\n            tp!(\"/foo/bar\", \"/\", \"/\");\n            tp!(r\"\\foo\\bar\", r\"\\\", r\"\\\");\n            tp!(\"/foo/bar\", \"/baz\", \"/baz\");\n            tp!(\"/foo/bar\", r\"\\baz\", r\"\\baz\");\n            tp!(\"/foo/bar\", \"./baz\", r\"/foo/bar\\./baz\");\n            tp!(\"/foo/bar\", r\".\\baz\", r\"/foo/bar\\.\\baz\");\n\n            tp!(\"c:\\\\\", \"windows\", \"c:\\\\windows\");\n            tp!(\"c:\", \"windows\", \"c:windows\");\n\n            tp!(\"a\\\\b\\\\c\", \"d\", \"a\\\\b\\\\c\\\\d\");\n            tp!(\"\\\\a\\\\b\\\\c\", \"d\", \"\\\\a\\\\b\\\\c\\\\d\");\n            tp!(\"a\\\\b\", \"c\\\\d\", \"a\\\\b\\\\c\\\\d\");\n            tp!(\"a\\\\b\", \"\\\\c\\\\d\", \"\\\\c\\\\d\");\n            tp!(\"a\\\\b\", \".\", \"a\\\\b\\\\.\");\n            tp!(\"a\\\\b\", \"..\\\\c\", \"a\\\\b\\\\..\\\\c\");\n            tp!(\"a\\\\b\", \"C:a.txt\", \"C:a.txt\");\n            tp!(\"a\\\\b\", \"C:\\\\a.txt\", \"C:\\\\a.txt\");\n            tp!(\"C:\\\\a\", \"C:\\\\b.txt\", \"C:\\\\b.txt\");\n            tp!(\"C:\\\\a\\\\b\\\\c\", \"C:d\", \"C:d\");\n            tp!(\"C:a\\\\b\\\\c\", \"C:d\", \"C:d\");\n            tp!(\"C:\", r\"a\\b\\c\", r\"C:a\\b\\c\");\n            tp!(\"C:\", r\"..\\a\", r\"C:..\\a\");\n            tp!(\"\\\\\\\\server\\\\share\\\\foo\",\n                \"bar\",\n                \"\\\\\\\\server\\\\share\\\\foo\\\\bar\");\n            tp!(\"\\\\\\\\server\\\\share\\\\foo\", \"C:baz\", \"C:baz\");\n            tp!(\"\\\\\\\\?\\\\C:\\\\a\\\\b\", \"C:c\\\\d\", \"C:c\\\\d\");\n            tp!(\"\\\\\\\\?\\\\C:a\\\\b\", \"C:c\\\\d\", \"C:c\\\\d\");\n            tp!(\"\\\\\\\\?\\\\C:\\\\a\\\\b\", \"C:\\\\c\\\\d\", \"C:\\\\c\\\\d\");\n            tp!(\"\\\\\\\\?\\\\foo\\\\bar\", \"baz\", \"\\\\\\\\?\\\\foo\\\\bar\\\\baz\");\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\foo\",\n                \"bar\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\foo\\\\bar\");\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\", \"C:\\\\a\", \"C:\\\\a\");\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\", \"C:a\", \"C:a\");\n\n            // Note: modified from old path API\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\", \"foo\", \"\\\\\\\\?\\\\UNC\\\\server\\\\foo\");\n\n            tp!(\"C:\\\\a\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\");\n            tp!(\"\\\\\\\\.\\\\foo\\\\bar\", \"baz\", \"\\\\\\\\.\\\\foo\\\\bar\\\\baz\");\n            tp!(\"\\\\\\\\.\\\\foo\\\\bar\", \"C:a\", \"C:a\");\n            // again, not sure about the following, but I'm assuming \\\\.\\ should be verbatim\n            tp!(\"\\\\\\\\.\\\\foo\", \"..\\\\bar\", \"\\\\\\\\.\\\\foo\\\\..\\\\bar\");\n\n            tp!(\"\\\\\\\\?\\\\C:\", \"foo\", \"\\\\\\\\?\\\\C:\\\\foo\"); // this is a weird one\n        }\n    }\n\n    #[test]\n    pub fn test_pop() {\n        macro_rules! tp(\n            ($path:expr, $expected:expr, $output:expr) => ( {\n                let mut actual = PathBuf::from($path);\n                let output = actual.pop();\n                assert!(actual.to_str() == Some($expected) && output == $output,\n                        \"popping from {:?}: Expected {:?}/{:?}, got {:?}/{:?}\",\n                        $path, $expected, $output,\n                        actual.to_str().unwrap(), output);\n            });\n        );\n\n        tp!(\"\", \"\", false);\n        tp!(\"/\", \"/\", false);\n        tp!(\"foo\", \"\", true);\n        tp!(\".\", \"\", true);\n        tp!(\"/foo\", \"/\", true);\n        tp!(\"/foo/bar\", \"/foo\", true);\n        tp!(\"foo/bar\", \"foo\", true);\n        tp!(\"foo/.\", \"\", true);\n        tp!(\"foo//bar\", \"foo\", true);\n\n        if cfg!(windows) {\n            tp!(\"a\\\\b\\\\c\", \"a\\\\b\", true);\n            tp!(\"\\\\a\", \"\\\\\", true);\n            tp!(\"\\\\\", \"\\\\\", false);\n\n            tp!(\"C:\\\\a\\\\b\", \"C:\\\\a\", true);\n            tp!(\"C:\\\\a\", \"C:\\\\\", true);\n            tp!(\"C:\\\\\", \"C:\\\\\", false);\n            tp!(\"C:a\\\\b\", \"C:a\", true);\n            tp!(\"C:a\", \"C:\", true);\n            tp!(\"C:\", \"C:\", false);\n            tp!(\"\\\\\\\\server\\\\share\\\\a\\\\b\", \"\\\\\\\\server\\\\share\\\\a\", true);\n            tp!(\"\\\\\\\\server\\\\share\\\\a\", \"\\\\\\\\server\\\\share\\\\\", true);\n            tp!(\"\\\\\\\\server\\\\share\", \"\\\\\\\\server\\\\share\", false);\n            tp!(\"\\\\\\\\?\\\\a\\\\b\\\\c\", \"\\\\\\\\?\\\\a\\\\b\", true);\n            tp!(\"\\\\\\\\?\\\\a\\\\b\", \"\\\\\\\\?\\\\a\\\\\", true);\n            tp!(\"\\\\\\\\?\\\\a\", \"\\\\\\\\?\\\\a\", false);\n            tp!(\"\\\\\\\\?\\\\C:\\\\a\\\\b\", \"\\\\\\\\?\\\\C:\\\\a\", true);\n            tp!(\"\\\\\\\\?\\\\C:\\\\a\", \"\\\\\\\\?\\\\C:\\\\\", true);\n            tp!(\"\\\\\\\\?\\\\C:\\\\\", \"\\\\\\\\?\\\\C:\\\\\", false);\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\a\\\\b\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\a\",\n                true);\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\a\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\\\\\",\n                true);\n            tp!(\"\\\\\\\\?\\\\UNC\\\\server\\\\share\",\n                \"\\\\\\\\?\\\\UNC\\\\server\\\\share\",\n                false);\n            tp!(\"\\\\\\\\.\\\\a\\\\b\\\\c\", \"\\\\\\\\.\\\\a\\\\b\", true);\n            tp!(\"\\\\\\\\.\\\\a\\\\b\", \"\\\\\\\\.\\\\a\\\\\", true);\n            tp!(\"\\\\\\\\.\\\\a\", \"\\\\\\\\.\\\\a\", false);\n\n            tp!(\"\\\\\\\\?\\\\a\\\\b\\\\\", \"\\\\\\\\?\\\\a\\\\\", true);\n        }\n    }\n\n    #[test]\n    pub fn test_set_file_name() {\n        macro_rules! tfn(\n                ($path:expr, $file:expr, $expected:expr) => ( {\n                let mut p = PathBuf::from($path);\n                p.set_file_name($file);\n                assert!(p.to_str() == Some($expected),\n                        \"setting file name of {:?} to {:?}: Expected {:?}, got {:?}\",\n                        $path, $file, $expected,\n                        p.to_str().unwrap());\n            });\n        );\n\n        tfn!(\"foo\", \"foo\", \"foo\");\n        tfn!(\"foo\", \"bar\", \"bar\");\n        tfn!(\"foo\", \"\", \"\");\n        tfn!(\"\", \"foo\", \"foo\");\n        if cfg!(unix) {\n            tfn!(\".\", \"foo\", \"./foo\");\n            tfn!(\"foo/\", \"bar\", \"bar\");\n            tfn!(\"foo/.\", \"bar\", \"bar\");\n            tfn!(\"..\", \"foo\", \"../foo\");\n            tfn!(\"foo/..\", \"bar\", \"foo/../bar\");\n            tfn!(\"/\", \"foo\", \"/foo\");\n        } else {\n            tfn!(\".\", \"foo\", r\".\\foo\");\n            tfn!(r\"foo\\\", \"bar\", r\"bar\");\n            tfn!(r\"foo\\.\", \"bar\", r\"bar\");\n            tfn!(\"..\", \"foo\", r\"..\\foo\");\n            tfn!(r\"foo\\..\", \"bar\", r\"foo\\..\\bar\");\n            tfn!(r\"\\\", \"foo\", r\"\\foo\");\n        }\n    }\n\n    #[test]\n    pub fn test_set_extension() {\n        macro_rules! tfe(\n                ($path:expr, $ext:expr, $expected:expr, $output:expr) => ( {\n                let mut p = PathBuf::from($path);\n                let output = p.set_extension($ext);\n                assert!(p.to_str() == Some($expected) && output == $output,\n                        \"setting extension of {:?} to {:?}: Expected {:?}/{:?}, got {:?}/{:?}\",\n                        $path, $ext, $expected, $output,\n                        p.to_str().unwrap(), output);\n            });\n        );\n\n        tfe!(\"foo\", \"txt\", \"foo.txt\", true);\n        tfe!(\"foo.bar\", \"txt\", \"foo.txt\", true);\n        tfe!(\"foo.bar.baz\", \"txt\", \"foo.bar.txt\", true);\n        tfe!(\".test\", \"txt\", \".test.txt\", true);\n        tfe!(\"foo.txt\", \"\", \"foo\", true);\n        tfe!(\"foo\", \"\", \"foo\", true);\n        tfe!(\"\", \"foo\", \"\", false);\n        tfe!(\".\", \"foo\", \".\", false);\n        tfe!(\"foo/\", \"bar\", \"foo.bar\", true);\n        tfe!(\"foo/.\", \"bar\", \"foo.bar\", true);\n        tfe!(\"..\", \"foo\", \"..\", false);\n        tfe!(\"foo/..\", \"bar\", \"foo/..\", false);\n        tfe!(\"/\", \"foo\", \"/\", false);\n    }\n\n    #[test]\n    fn test_eq_receivers() {\n        use borrow::Cow;\n\n        let borrowed: &Path = Path::new(\"foo/bar\");\n        let mut owned: PathBuf = PathBuf::new();\n        owned.push(\"foo\");\n        owned.push(\"bar\");\n        let borrowed_cow: Cow<Path> = borrowed.into();\n        let owned_cow: Cow<Path> = owned.clone().into();\n\n        macro_rules! t {\n            ($($current:expr),+) => {\n                $(\n                    assert_eq!($current, borrowed);\n                    assert_eq!($current, owned);\n                    assert_eq!($current, borrowed_cow);\n                    assert_eq!($current, owned_cow);\n                )+\n            }\n        }\n\n        t!(borrowed, owned, borrowed_cow, owned_cow);\n    }\n\n    #[test]\n    pub fn test_compare() {\n        use hash::{Hash, Hasher};\n        use collections::hash_map::DefaultHasher;\n\n        fn hash<T: Hash>(t: T) -> u64 {\n            let mut s = DefaultHasher::new();\n            t.hash(&mut s);\n            s.finish()\n        }\n\n        macro_rules! tc(\n            ($path1:expr, $path2:expr, eq: $eq:expr,\n             starts_with: $starts_with:expr, ends_with: $ends_with:expr,\n             relative_from: $relative_from:expr) => ({\n                 let path1 = Path::new($path1);\n                 let path2 = Path::new($path2);\n\n                 let eq = path1 == path2;\n                 assert!(eq == $eq, \"{:?} == {:?}, expected {:?}, got {:?}\",\n                         $path1, $path2, $eq, eq);\n                 assert!($eq == (hash(path1) == hash(path2)),\n                         \"{:?} == {:?}, expected {:?}, got {} and {}\",\n                         $path1, $path2, $eq, hash(path1), hash(path2));\n\n                 let starts_with = path1.starts_with(path2);\n                 assert!(starts_with == $starts_with,\n                         \"{:?}.starts_with({:?}), expected {:?}, got {:?}\", $path1, $path2,\n                         $starts_with, starts_with);\n\n                 let ends_with = path1.ends_with(path2);\n                 assert!(ends_with == $ends_with,\n                         \"{:?}.ends_with({:?}), expected {:?}, got {:?}\", $path1, $path2,\n                         $ends_with, ends_with);\n\n                 let relative_from = path1.strip_prefix(path2)\n                                          .map(|p| p.to_str().unwrap())\n                                          .ok();\n                 let exp: Option<&str> = $relative_from;\n                 assert!(relative_from == exp,\n                         \"{:?}.strip_prefix({:?}), expected {:?}, got {:?}\",\n                         $path1, $path2, exp, relative_from);\n            });\n        );\n\n        tc!(\"\", \"\",\n            eq: true,\n            starts_with: true,\n            ends_with: true,\n            relative_from: Some(\"\")\n            );\n\n        tc!(\"foo\", \"\",\n            eq: false,\n            starts_with: true,\n            ends_with: true,\n            relative_from: Some(\"foo\")\n            );\n\n        tc!(\"\", \"foo\",\n            eq: false,\n            starts_with: false,\n            ends_with: false,\n            relative_from: None\n            );\n\n        tc!(\"foo\", \"foo\",\n            eq: true,\n            starts_with: true,\n            ends_with: true,\n            relative_from: Some(\"\")\n            );\n\n        tc!(\"foo/\", \"foo\",\n            eq: true,\n            starts_with: true,\n            ends_with: true,\n            relative_from: Some(\"\")\n            );\n\n        tc!(\"foo/bar\", \"foo\",\n            eq: false,\n            starts_with: true,\n            ends_with: false,\n            relative_from: Some(\"bar\")\n            );\n\n        tc!(\"foo/bar/baz\", \"foo/bar\",\n            eq: false,\n            starts_with: true,\n            ends_with: false,\n            relative_from: Some(\"baz\")\n            );\n\n        tc!(\"foo/bar\", \"foo/bar/baz\",\n            eq: false,\n            starts_with: false,\n            ends_with: false,\n            relative_from: None\n            );\n\n        tc!(\"./foo/bar/\", \".\",\n            eq: false,\n            starts_with: true,\n            ends_with: false,\n            relative_from: Some(\"foo/bar\")\n            );\n\n        if cfg!(windows) {\n            tc!(r\"C:\\src\\rust\\cargo-test\\test\\Cargo.toml\",\n                r\"c:\\src\\rust\\cargo-test\\test\",\n                eq: false,\n                starts_with: true,\n                ends_with: false,\n                relative_from: Some(\"Cargo.toml\")\n                );\n\n            tc!(r\"c:\\foo\", r\"C:\\foo\",\n                eq: true,\n                starts_with: true,\n                ends_with: true,\n                relative_from: Some(\"\")\n                );\n        }\n    }\n\n    #[test]\n    fn test_components_debug() {\n        let path = Path::new(\"/tmp\");\n\n        let mut components = path.components();\n\n        let expected = \"Components([RootDir, Normal(\\\"tmp\\\")])\";\n        let actual = format!(\"{:?}\", components);\n        assert_eq!(expected, actual);\n\n        let _ = components.next().unwrap();\n        let expected = \"Components([Normal(\\\"tmp\\\")])\";\n        let actual = format!(\"{:?}\", components);\n        assert_eq!(expected, actual);\n\n        let _ = components.next().unwrap();\n        let expected = \"Components([])\";\n        let actual = format!(\"{:?}\", components);\n        assert_eq!(expected, actual);\n    }\n\n    #[cfg(unix)]\n    #[test]\n    fn test_iter_debug() {\n        let path = Path::new(\"/tmp\");\n\n        let mut iter = path.iter();\n\n        let expected = \"Iter([\\\"/\\\", \\\"tmp\\\"])\";\n        let actual = format!(\"{:?}\", iter);\n        assert_eq!(expected, actual);\n\n        let _ = iter.next().unwrap();\n        let expected = \"Iter([\\\"tmp\\\"])\";\n        let actual = format!(\"{:?}\", iter);\n        assert_eq!(expected, actual);\n\n        let _ = iter.next().unwrap();\n        let expected = \"Iter([])\";\n        let actual = format!(\"{:?}\", iter);\n        assert_eq!(expected, actual);\n    }\n\n    #[test]\n    fn into_boxed() {\n        let orig: &str = \"some/sort/of/path\";\n        let path = Path::new(orig);\n        let boxed: Box<Path> = Box::from(path);\n        let path_buf = path.to_owned().into_boxed_path().into_path_buf();\n        assert_eq!(path, &*boxed);\n        assert_eq!(&*boxed, &*path_buf);\n        assert_eq!(&*path_buf, path);\n    }\n\n    #[test]\n    fn test_clone_into() {\n        let mut path_buf = PathBuf::from(\"supercalifragilisticexpialidocious\");\n        let path = Path::new(\"short\");\n        path.clone_into(&mut path_buf);\n        assert_eq!(path, path_buf);\n        assert!(path_buf.into_os_string().capacity() >= 15);\n    }\n\n    #[test]\n    fn display_format_flags() {\n        assert_eq!(format!(\"a{:#<5}b\", Path::new(\"\").display()), \"a#####b\");\n        assert_eq!(format!(\"a{:#<5}b\", Path::new(\"a\").display()), \"aa####b\");\n    }\n\n    #[test]\n    fn into_rc() {\n        let orig = \"hello/world\";\n        let path = Path::new(orig);\n        let rc: Rc<Path> = Rc::from(path);\n        let arc: Arc<Path> = Arc::from(path);\n\n        assert_eq!(&*rc, path);\n        assert_eq!(&*arc, path);\n\n        let rc2: Rc<Path> = Rc::from(path.to_owned());\n        let arc2: Arc<Path> = Arc::from(path.to_owned());\n\n        assert_eq!(&*rc2, path);\n        assert_eq!(&*arc2, path);\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Temporal quantification.\n//!\n//! Example:\n//!\n//! ```\n//! use std::time::Duration;\n//!\n//! let five_seconds = Duration::new(5, 0);\n//! // both declarations are equivalent\n//! assert_eq!(Duration::new(5, 0), Duration::from_secs(5));\n//! ```\n\n#![stable(feature = \"time\", since = \"1.3.0\")]\n\nuse error::Error;\nuse fmt;\nuse ops::{Add, Sub, AddAssign, SubAssign};\nuse sys::time;\nuse sys_common::FromInner;\n\n#[stable(feature = \"time\", since = \"1.3.0\")]\npub use core::time::Duration;\n\n/// A measurement of a monotonically nondecreasing clock.\n/// Opaque and useful only with `Duration`.\n///\n/// Instants are always guaranteed to be no less than any previously measured\n/// instant when created, and are often useful for tasks such as measuring\n/// benchmarks or timing how long an operation takes.\n///\n/// Note, however, that instants are not guaranteed to be **steady**.  In other\n/// words, each tick of the underlying clock may not be the same length (e.g.\n/// some seconds may be longer than others). An instant may jump forwards or\n/// experience time dilation (slow down or speed up), but it will never go\n/// backwards.\n///\n/// Instants are opaque types that can only be compared to one another. There is\n/// no method to get \"the number of seconds\" from an instant. Instead, it only\n/// allows measuring the duration between two instants (or comparing two\n/// instants).\n///\n/// The size of an `Instant` struct may vary depending on the target operating\n/// system.\n///\n/// Example:\n///\n/// ```no_run\n/// use std::time::{Duration, Instant};\n/// use std::thread::sleep;\n///\n/// fn main() {\n///    let now = Instant::now();\n///\n///    // we sleep for 2 seconds\n///    sleep(Duration::new(2, 0));\n///    // it prints '2'\n///    println!(\"{}\", now.elapsed().as_secs());\n/// }\n/// ```\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n#[stable(feature = \"time2\", since = \"1.8.0\")]\npub struct Instant(time::Instant);\n\n/// A measurement of the system clock, useful for talking to\n/// external entities like the file system or other processes.\n///\n/// Distinct from the [`Instant`] type, this time measurement **is not\n/// monotonic**. This means that you can save a file to the file system, then\n/// save another file to the file system, **and the second file has a\n/// `SystemTime` measurement earlier than the first**. In other words, an\n/// operation that happens after another operation in real time may have an\n/// earlier `SystemTime`!\n///\n/// Consequently, comparing two `SystemTime` instances to learn about the\n/// duration between them returns a [`Result`] instead of an infallible [`Duration`]\n/// to indicate that this sort of time drift may happen and needs to be handled.\n///\n/// Although a `SystemTime` cannot be directly inspected, the [`UNIX_EPOCH`]\n/// constant is provided in this module as an anchor in time to learn\n/// information about a `SystemTime`. By calculating the duration from this\n/// fixed point in time, a `SystemTime` can be converted to a human-readable time,\n/// or perhaps some other string representation.\n///\n/// The size of a `SystemTime` struct may vary depending on the target operating\n/// system.\n///\n/// [`Instant`]: ../../std/time/struct.Instant.html\n/// [`Result`]: ../../std/result/enum.Result.html\n/// [`Duration`]: ../../std/time/struct.Duration.html\n/// [`UNIX_EPOCH`]: ../../std/time/constant.UNIX_EPOCH.html\n///\n/// Example:\n///\n/// ```no_run\n/// use std::time::{Duration, SystemTime};\n/// use std::thread::sleep;\n///\n/// fn main() {\n///    let now = SystemTime::now();\n///\n///    // we sleep for 2 seconds\n///    sleep(Duration::new(2, 0));\n///    match now.elapsed() {\n///        Ok(elapsed) => {\n///            // it prints '2'\n///            println!(\"{}\", elapsed.as_secs());\n///        }\n///        Err(e) => {\n///            // an error occurred!\n///            println!(\"Error: {:?}\", e);\n///        }\n///    }\n/// }\n/// ```\n#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]\n#[stable(feature = \"time2\", since = \"1.8.0\")]\npub struct SystemTime(time::SystemTime);\n\n/// An error returned from the `duration_since` and `elapsed` methods on\n/// `SystemTime`, used to learn how far in the opposite direction a system time\n/// lies.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::thread::sleep;\n/// use std::time::{Duration, SystemTime};\n///\n/// let sys_time = SystemTime::now();\n/// sleep(Duration::from_secs(1));\n/// let new_sys_time = SystemTime::now();\n/// match sys_time.duration_since(new_sys_time) {\n///     Ok(_) => {}\n///     Err(e) => println!(\"SystemTimeError difference: {:?}\", e.duration()),\n/// }\n/// ```\n#[derive(Clone, Debug)]\n#[stable(feature = \"time2\", since = \"1.8.0\")]\npub struct SystemTimeError(Duration);\n\nimpl Instant {\n    /// Returns an instant corresponding to \"now\".\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::Instant;\n    ///\n    /// let now = Instant::now();\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn now() -> Instant {\n        Instant(time::Instant::now())\n    }\n\n    /// Returns the amount of time elapsed from another instant to this one.\n    ///\n    /// # Panics\n    ///\n    /// This function will panic if `earlier` is later than `self`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::time::{Duration, Instant};\n    /// use std::thread::sleep;\n    ///\n    /// let now = Instant::now();\n    /// sleep(Duration::new(1, 0));\n    /// let new_now = Instant::now();\n    /// println!(\"{:?}\", new_now.duration_since(now));\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn duration_since(&self, earlier: Instant) -> Duration {\n        self.0.sub_instant(&earlier.0)\n    }\n\n    /// Returns the amount of time elapsed since this instant was created.\n    ///\n    /// # Panics\n    ///\n    /// This function may panic if the current time is earlier than this\n    /// instant, which is something that can happen if an `Instant` is\n    /// produced synthetically.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::thread::sleep;\n    /// use std::time::{Duration, Instant};\n    ///\n    /// let instant = Instant::now();\n    /// let three_secs = Duration::from_secs(3);\n    /// sleep(three_secs);\n    /// assert!(instant.elapsed() >= three_secs);\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn elapsed(&self) -> Duration {\n        Instant::now() - *self\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Add<Duration> for Instant {\n    type Output = Instant;\n\n    fn add(self, other: Duration) -> Instant {\n        Instant(self.0.add_duration(&other))\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl AddAssign<Duration> for Instant {\n    fn add_assign(&mut self, other: Duration) {\n        *self = *self + other;\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Sub<Duration> for Instant {\n    type Output = Instant;\n\n    fn sub(self, other: Duration) -> Instant {\n        Instant(self.0.sub_duration(&other))\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl SubAssign<Duration> for Instant {\n    fn sub_assign(&mut self, other: Duration) {\n        *self = *self - other;\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Sub<Instant> for Instant {\n    type Output = Duration;\n\n    fn sub(self, other: Instant) -> Duration {\n        self.duration_since(other)\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl fmt::Debug for Instant {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\nimpl SystemTime {\n    /// An anchor in time which can be used to create new `SystemTime` instances or\n    /// learn about where in time a `SystemTime` lies.\n    ///\n    /// This constant is defined to be \"1970-01-01 00:00:00 UTC\" on all systems with\n    /// respect to the system clock. Using `duration_since` on an existing\n    /// `SystemTime` instance can tell how far away from this point in time a\n    /// measurement lies, and using `UNIX_EPOCH + duration` can be used to create a\n    /// `SystemTime` instance to represent another fixed point in time.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::time::SystemTime;\n    ///\n    /// match SystemTime::now().duration_since(SystemTime::UNIX_EPOCH) {\n    ///     Ok(n) => println!(\"1970-01-01 00:00:00 UTC was {} seconds ago!\", n.as_secs()),\n    ///     Err(_) => panic!(\"SystemTime before UNIX EPOCH!\"),\n    /// }\n    /// ```\n    #[stable(feature = \"assoc_unix_epoch\", since = \"1.28.0\")]\n    pub const UNIX_EPOCH: SystemTime = UNIX_EPOCH;\n\n    /// Returns the system time corresponding to \"now\".\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::SystemTime;\n    ///\n    /// let sys_time = SystemTime::now();\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn now() -> SystemTime {\n        SystemTime(time::SystemTime::now())\n    }\n\n    /// Returns the amount of time elapsed from an earlier point in time.\n    ///\n    /// This function may fail because measurements taken earlier are not\n    /// guaranteed to always be before later measurements (due to anomalies such\n    /// as the system clock being adjusted either forwards or backwards).\n    ///\n    /// If successful, [`Ok`]`(`[`Duration`]`)` is returned where the duration represents\n    /// the amount of time elapsed from the specified measurement to this one.\n    ///\n    /// Returns an [`Err`] if `earlier` is later than `self`, and the error\n    /// contains how far from `self` the time is.\n    ///\n    /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Duration`]: ../../std/time/struct.Duration.html\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::time::SystemTime;\n    ///\n    /// let sys_time = SystemTime::now();\n    /// let difference = sys_time.duration_since(sys_time)\n    ///                          .expect(\"SystemTime::duration_since failed\");\n    /// println!(\"{:?}\", difference);\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn duration_since(&self, earlier: SystemTime)\n                          -> Result<Duration, SystemTimeError> {\n        self.0.sub_time(&earlier.0).map_err(SystemTimeError)\n    }\n\n    /// Returns the amount of time elapsed since this system time was created.\n    ///\n    /// This function may fail as the underlying system clock is susceptible to\n    /// drift and updates (e.g. the system clock could go backwards), so this\n    /// function may not always succeed. If successful, [`Ok`]`(`[`Duration`]`)` is\n    /// returned where the duration represents the amount of time elapsed from\n    /// this time measurement to the current time.\n    ///\n    /// Returns an [`Err`] if `self` is later than the current system time, and\n    /// the error contains how far from the current system time `self` is.\n    ///\n    /// [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n    /// [`Duration`]: ../../std/time/struct.Duration.html\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::thread::sleep;\n    /// use std::time::{Duration, SystemTime};\n    ///\n    /// let sys_time = SystemTime::now();\n    /// let one_sec = Duration::from_secs(1);\n    /// sleep(one_sec);\n    /// assert!(sys_time.elapsed().unwrap() >= one_sec);\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn elapsed(&self) -> Result<Duration, SystemTimeError> {\n        SystemTime::now().duration_since(*self)\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Add<Duration> for SystemTime {\n    type Output = SystemTime;\n\n    fn add(self, dur: Duration) -> SystemTime {\n        SystemTime(self.0.add_duration(&dur))\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl AddAssign<Duration> for SystemTime {\n    fn add_assign(&mut self, other: Duration) {\n        *self = *self + other;\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Sub<Duration> for SystemTime {\n    type Output = SystemTime;\n\n    fn sub(self, dur: Duration) -> SystemTime {\n        SystemTime(self.0.sub_duration(&dur))\n    }\n}\n\n#[stable(feature = \"time_augmented_assignment\", since = \"1.9.0\")]\nimpl SubAssign<Duration> for SystemTime {\n    fn sub_assign(&mut self, other: Duration) {\n        *self = *self - other;\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl fmt::Debug for SystemTime {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.0.fmt(f)\n    }\n}\n\n/// An anchor in time which can be used to create new `SystemTime` instances or\n/// learn about where in time a `SystemTime` lies.\n///\n/// This constant is defined to be \"1970-01-01 00:00:00 UTC\" on all systems with\n/// respect to the system clock. Using `duration_since` on an existing\n/// [`SystemTime`] instance can tell how far away from this point in time a\n/// measurement lies, and using `UNIX_EPOCH + duration` can be used to create a\n/// [`SystemTime`] instance to represent another fixed point in time.\n///\n/// [`SystemTime`]: ../../std/time/struct.SystemTime.html\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::time::{SystemTime, UNIX_EPOCH};\n///\n/// match SystemTime::now().duration_since(UNIX_EPOCH) {\n///     Ok(n) => println!(\"1970-01-01 00:00:00 UTC was {} seconds ago!\", n.as_secs()),\n///     Err(_) => panic!(\"SystemTime before UNIX EPOCH!\"),\n/// }\n/// ```\n#[stable(feature = \"time2\", since = \"1.8.0\")]\npub const UNIX_EPOCH: SystemTime = SystemTime(time::UNIX_EPOCH);\n\nimpl SystemTimeError {\n    /// Returns the positive duration which represents how far forward the\n    /// second system time was from the first.\n    ///\n    /// A `SystemTimeError` is returned from the [`duration_since`] and [`elapsed`]\n    /// methods of [`SystemTime`] whenever the second system time represents a point later\n    /// in time than the `self` of the method call.\n    ///\n    /// [`duration_since`]: ../../std/time/struct.SystemTime.html#method.duration_since\n    /// [`elapsed`]: ../../std/time/struct.SystemTime.html#method.elapsed\n    /// [`SystemTime`]: ../../std/time/struct.SystemTime.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::thread::sleep;\n    /// use std::time::{Duration, SystemTime};\n    ///\n    /// let sys_time = SystemTime::now();\n    /// sleep(Duration::from_secs(1));\n    /// let new_sys_time = SystemTime::now();\n    /// match sys_time.duration_since(new_sys_time) {\n    ///     Ok(_) => {}\n    ///     Err(e) => println!(\"SystemTimeError difference: {:?}\", e.duration()),\n    /// }\n    /// ```\n    #[stable(feature = \"time2\", since = \"1.8.0\")]\n    pub fn duration(&self) -> Duration {\n        self.0\n    }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl Error for SystemTimeError {\n    fn description(&self) -> &str { \"other time was not earlier than self\" }\n}\n\n#[stable(feature = \"time2\", since = \"1.8.0\")]\nimpl fmt::Display for SystemTimeError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"second time provided was later than self\")\n    }\n}\n\nimpl FromInner<time::SystemTime> for SystemTime {\n    fn from_inner(time: time::SystemTime) -> SystemTime {\n        SystemTime(time)\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    use super::{Instant, SystemTime, Duration, UNIX_EPOCH};\n\n    macro_rules! assert_almost_eq {\n        ($a:expr, $b:expr) => ({\n            let (a, b) = ($a, $b);\n            if a != b {\n                let (a, b) = if a > b {(a, b)} else {(b, a)};\n                assert!(a - Duration::new(0, 100) <= b);\n            }\n        })\n    }\n\n    #[test]\n    fn instant_monotonic() {\n        let a = Instant::now();\n        let b = Instant::now();\n        assert!(b >= a);\n    }\n\n    #[test]\n    fn instant_elapsed() {\n        let a = Instant::now();\n        a.elapsed();\n    }\n\n    #[test]\n    fn instant_math() {\n        let a = Instant::now();\n        let b = Instant::now();\n        let dur = b.duration_since(a);\n        assert_almost_eq!(b - dur, a);\n        assert_almost_eq!(a + dur, b);\n\n        let second = Duration::new(1, 0);\n        assert_almost_eq!(a - second + second, a);\n    }\n\n    #[test]\n    #[should_panic]\n    fn instant_duration_panic() {\n        let a = Instant::now();\n        (a - Duration::new(1, 0)).duration_since(a);\n    }\n\n    #[test]\n    fn system_time_math() {\n        let a = SystemTime::now();\n        let b = SystemTime::now();\n        match b.duration_since(a) {\n            Ok(dur) if dur == Duration::new(0, 0) => {\n                assert_almost_eq!(a, b);\n            }\n            Ok(dur) => {\n                assert!(b > a);\n                assert_almost_eq!(b - dur, a);\n                assert_almost_eq!(a + dur, b);\n            }\n            Err(dur) => {\n                let dur = dur.duration();\n                assert!(a > b);\n                assert_almost_eq!(b + dur, a);\n                assert_almost_eq!(a - dur, b);\n            }\n        }\n\n        let second = Duration::new(1, 0);\n        assert_almost_eq!(a.duration_since(a - second).unwrap(), second);\n        assert_almost_eq!(a.duration_since(a + second).unwrap_err()\n                           .duration(), second);\n\n        assert_almost_eq!(a - second + second, a);\n\n        // A difference of 80 and 800 years cannot fit inside a 32-bit time_t\n        if !(cfg!(unix) && ::mem::size_of::<::libc::time_t>() <= 4) {\n            let eighty_years = second * 60 * 60 * 24 * 365 * 80;\n            assert_almost_eq!(a - eighty_years + eighty_years, a);\n            assert_almost_eq!(a - (eighty_years * 10) + (eighty_years * 10), a);\n        }\n\n        let one_second_from_epoch = UNIX_EPOCH + Duration::new(1, 0);\n        let one_second_from_epoch2 = UNIX_EPOCH + Duration::new(0, 500_000_000)\n            + Duration::new(0, 500_000_000);\n        assert_eq!(one_second_from_epoch, one_second_from_epoch2);\n    }\n\n    #[test]\n    fn system_time_elapsed() {\n        let a = SystemTime::now();\n        drop(a.elapsed());\n    }\n\n    #[test]\n    fn since_epoch() {\n        let ts = SystemTime::now();\n        let a = ts.duration_since(UNIX_EPOCH).unwrap();\n        let b = ts.duration_since(UNIX_EPOCH - Duration::new(1, 0)).unwrap();\n        assert!(b > a);\n        assert_eq!(b - a, Duration::new(1, 0));\n\n        let thirty_years = Duration::new(1, 0) * 60 * 60 * 24 * 365 * 30;\n\n        // Right now for CI this test is run in an emulator, and apparently the\n        // aarch64 emulator's sense of time is that we're still living in the\n        // 70s.\n        //\n        // Otherwise let's assume that we're all running computers later than\n        // 2000.\n        if !cfg!(target_arch = \"aarch64\") {\n            assert!(a > thirty_years);\n        }\n\n        // let's assume that we're all running computers earlier than 2090.\n        // Should give us ~70 years to fix this!\n        let hundred_twenty_years = thirty_years * 4;\n        assert!(a < hundred_twenty_years);\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Native threads.\n//!\n//! ## The threading model\n//!\n//! An executing Rust program consists of a collection of native OS threads,\n//! each with their own stack and local state. Threads can be named, and\n//! provide some built-in support for low-level synchronization.\n//!\n//! Communication between threads can be done through\n//! [channels], Rust's message-passing types, along with [other forms of thread\n//! synchronization](../../std/sync/index.html) and shared-memory data\n//! structures. In particular, types that are guaranteed to be\n//! threadsafe are easily shared between threads using the\n//! atomically-reference-counted container, [`Arc`].\n//!\n//! Fatal logic errors in Rust cause *thread panic*, during which\n//! a thread will unwind the stack, running destructors and freeing\n//! owned resources. While not meant as a 'try/catch' mechanism, panics\n//! in Rust can nonetheless be caught (unless compiling with `panic=abort`) with\n//! [`catch_unwind`](../../std/panic/fn.catch_unwind.html) and recovered\n//! from, or alternatively be resumed with\n//! [`resume_unwind`](../../std/panic/fn.resume_unwind.html). If the panic\n//! is not caught the thread will exit, but the panic may optionally be\n//! detected from a different thread with [`join`]. If the main thread panics\n//! without the panic being caught, the application will exit with a\n//! non-zero exit code.\n//!\n//! When the main thread of a Rust program terminates, the entire program shuts\n//! down, even if other threads are still running. However, this module provides\n//! convenient facilities for automatically waiting for the termination of a\n//! child thread (i.e., join).\n//!\n//! ## Spawning a thread\n//!\n//! A new thread can be spawned using the [`thread::spawn`][`spawn`] function:\n//!\n//! ```rust\n//! use std::thread;\n//!\n//! thread::spawn(move || {\n//!     // some work here\n//! });\n//! ```\n//!\n//! In this example, the spawned thread is \"detached\" from the current\n//! thread. This means that it can outlive its parent (the thread that spawned\n//! it), unless this parent is the main thread.\n//!\n//! The parent thread can also wait on the completion of the child\n//! thread; a call to [`spawn`] produces a [`JoinHandle`], which provides\n//! a `join` method for waiting:\n//!\n//! ```rust\n//! use std::thread;\n//!\n//! let child = thread::spawn(move || {\n//!     // some work here\n//! });\n//! // some work here\n//! let res = child.join();\n//! ```\n//!\n//! The [`join`] method returns a [`thread::Result`] containing [`Ok`] of the final\n//! value produced by the child thread, or [`Err`] of the value given to\n//! a call to [`panic!`] if the child panicked.\n//!\n//! ## Configuring threads\n//!\n//! A new thread can be configured before it is spawned via the [`Builder`] type,\n//! which currently allows you to set the name and stack size for the child thread:\n//!\n//! ```rust\n//! # #![allow(unused_must_use)]\n//! use std::thread;\n//!\n//! thread::Builder::new().name(\"child1\".to_string()).spawn(move || {\n//!     println!(\"Hello, world!\");\n//! });\n//! ```\n//!\n//! ## The `Thread` type\n//!\n//! Threads are represented via the [`Thread`] type, which you can get in one of\n//! two ways:\n//!\n//! * By spawning a new thread, e.g. using the [`thread::spawn`][`spawn`]\n//!   function, and calling [`thread`][`JoinHandle::thread`] on the [`JoinHandle`].\n//! * By requesting the current thread, using the [`thread::current`] function.\n//!\n//! The [`thread::current`] function is available even for threads not spawned\n//! by the APIs of this module.\n//!\n//! ## Thread-local storage\n//!\n//! This module also provides an implementation of thread-local storage for Rust\n//! programs. Thread-local storage is a method of storing data into a global\n//! variable that each thread in the program will have its own copy of.\n//! Threads do not share this data, so accesses do not need to be synchronized.\n//!\n//! A thread-local key owns the value it contains and will destroy the value when the\n//! thread exits. It is created with the [`thread_local!`] macro and can contain any\n//! value that is `'static` (no borrowed pointers). It provides an accessor function,\n//! [`with`], that yields a shared reference to the value to the specified\n//! closure. Thread-local keys allow only shared access to values, as there would be no\n//! way to guarantee uniqueness if mutable borrows were allowed. Most values\n//! will want to make use of some form of **interior mutability** through the\n//! [`Cell`] or [`RefCell`] types.\n//!\n//! ## Naming threads\n//!\n//! Threads are able to have associated names for identification purposes. By default, spawned\n//! threads are unnamed. To specify a name for a thread, build the thread with [`Builder`] and pass\n//! the desired thread name to [`Builder::name`]. To retrieve the thread name from within the\n//! thread, use [`Thread::name`]. A couple examples of where the name of a thread gets used:\n//!\n//! * If a panic occurs in a named thread, the thread name will be printed in the panic message.\n//! * The thread name is provided to the OS where applicable (e.g. `pthread_setname_np` in\n//!   unix-like platforms).\n//!\n//! ## Stack size\n//!\n//! The default stack size for spawned threads is 2 MiB, though this particular stack size is\n//! subject to change in the future. There are two ways to manually specify the stack size for\n//! spawned threads:\n//!\n//! * Build the thread with [`Builder`] and pass the desired stack size to [`Builder::stack_size`].\n//! * Set the `RUST_MIN_STACK` environment variable to an integer representing the desired stack\n//!   size (in bytes). Note that setting [`Builder::stack_size`] will override this.\n//!\n//! Note that the stack size of the main thread is *not* determined by Rust.\n//!\n//! [channels]: ../../std/sync/mpsc/index.html\n//! [`Arc`]: ../../std/sync/struct.Arc.html\n//! [`spawn`]: ../../std/thread/fn.spawn.html\n//! [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html\n//! [`JoinHandle::thread`]: ../../std/thread/struct.JoinHandle.html#method.thread\n//! [`join`]: ../../std/thread/struct.JoinHandle.html#method.join\n//! [`Result`]: ../../std/result/enum.Result.html\n//! [`Ok`]: ../../std/result/enum.Result.html#variant.Ok\n//! [`Err`]: ../../std/result/enum.Result.html#variant.Err\n//! [`panic!`]: ../../std/macro.panic.html\n//! [`Builder`]: ../../std/thread/struct.Builder.html\n//! [`Builder::stack_size`]: ../../std/thread/struct.Builder.html#method.stack_size\n//! [`Builder::name`]: ../../std/thread/struct.Builder.html#method.name\n//! [`thread::current`]: ../../std/thread/fn.current.html\n//! [`thread::Result`]: ../../std/thread/type.Result.html\n//! [`Thread`]: ../../std/thread/struct.Thread.html\n//! [`park`]: ../../std/thread/fn.park.html\n//! [`unpark`]: ../../std/thread/struct.Thread.html#method.unpark\n//! [`Thread::name`]: ../../std/thread/struct.Thread.html#method.name\n//! [`thread::park_timeout`]: ../../std/thread/fn.park_timeout.html\n//! [`Cell`]: ../cell/struct.Cell.html\n//! [`RefCell`]: ../cell/struct.RefCell.html\n//! [`thread_local!`]: ../macro.thread_local.html\n//! [`with`]: struct.LocalKey.html#method.with\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse any::Any;\nuse cell::UnsafeCell;\nuse ffi::{CStr, CString};\nuse fmt;\nuse io;\nuse panic;\nuse panicking;\nuse str;\nuse sync::{Mutex, Condvar, Arc};\nuse sync::atomic::AtomicUsize;\nuse sync::atomic::Ordering::SeqCst;\nuse sys::thread as imp;\nuse sys_common::mutex;\nuse sys_common::thread_info;\nuse sys_common::thread;\nuse sys_common::{AsInner, IntoInner};\nuse time::Duration;\n\n////////////////////////////////////////////////////////////////////////////////\n// Thread-local storage\n////////////////////////////////////////////////////////////////////////////////\n\n#[macro_use] mod local;\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::local::{LocalKey, AccessError};\n\n// The types used by the thread_local! macro to access TLS keys. Note that there\n// are two types, the \"OS\" type and the \"fast\" type. The OS thread local key\n// type is accessed via platform-specific API calls and is slow, while the fast\n// key type is accessed via code generated via LLVM, where TLS keys are set up\n// by the elf linker. Note that the OS TLS type is always available: on macOS\n// the standard library is compiled with support for older platform versions\n// where fast TLS was not available; end-user code is compiled with fast TLS\n// where available, but both are needed.\n\n#[unstable(feature = \"libstd_thread_internals\", issue = \"0\")]\n#[cfg(all(target_arch = \"wasm32\", not(target_feature = \"atomics\")))]\n#[doc(hidden)] pub use self::local::statik::Key as __StaticLocalKeyInner;\n#[unstable(feature = \"libstd_thread_internals\", issue = \"0\")]\n#[cfg(target_thread_local)]\n#[doc(hidden)] pub use self::local::fast::Key as __FastLocalKeyInner;\n#[unstable(feature = \"libstd_thread_internals\", issue = \"0\")]\n#[doc(hidden)] pub use self::local::os::Key as __OsLocalKeyInner;\n\n////////////////////////////////////////////////////////////////////////////////\n// Builder\n////////////////////////////////////////////////////////////////////////////////\n\n/// Thread factory, which can be used in order to configure the properties of\n/// a new thread.\n///\n/// Methods can be chained on it in order to configure it.\n///\n/// The two configurations available are:\n///\n/// - [`name`]: specifies an [associated name for the thread][naming-threads]\n/// - [`stack_size`]: specifies the [desired stack size for the thread][stack-size]\n///\n/// The [`spawn`] method will take ownership of the builder and create an\n/// [`io::Result`] to the thread handle with the given configuration.\n///\n/// The [`thread::spawn`] free function uses a `Builder` with default\n/// configuration and [`unwrap`]s its return value.\n///\n/// You may want to use [`spawn`] instead of [`thread::spawn`], when you want\n/// to recover from a failure to launch a thread, indeed the free function will\n/// panick where the `Builder` method will return a [`io::Result`].\n///\n/// # Examples\n///\n/// ```\n/// use std::thread;\n///\n/// let builder = thread::Builder::new();\n///\n/// let handler = builder.spawn(|| {\n///     // thread code\n/// }).unwrap();\n///\n/// handler.join().unwrap();\n/// ```\n///\n/// [`thread::spawn`]: ../../std/thread/fn.spawn.html\n/// [`stack_size`]: ../../std/thread/struct.Builder.html#method.stack_size\n/// [`name`]: ../../std/thread/struct.Builder.html#method.name\n/// [`spawn`]: ../../std/thread/struct.Builder.html#method.spawn\n/// [`io::Result`]: ../../std/io/type.Result.html\n/// [`unwrap`]: ../../std/result/enum.Result.html#method.unwrap\n/// [naming-threads]: ./index.html#naming-threads\n/// [stack-size]: ./index.html#stack-size\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct Builder {\n    // A name for the thread-to-be, for identification in panic messages\n    name: Option<String>,\n    // The size of the stack for the spawned thread in bytes\n    stack_size: Option<usize>,\n}\n\nimpl Builder {\n    /// Generates the base configuration for spawning a thread, from which\n    /// configuration methods can be chained.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new()\n    ///                               .name(\"foo\".into())\n    ///                               .stack_size(10);\n    ///\n    /// let handler = builder.spawn(|| {\n    ///     // thread code\n    /// }).unwrap();\n    ///\n    /// handler.join().unwrap();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> Builder {\n        Builder {\n            name: None,\n            stack_size: None,\n        }\n    }\n\n    /// Names the thread-to-be. Currently the name is used for identification\n    /// only in panic messages.\n    ///\n    /// The name must not contain null bytes (`\\0`).\n    ///\n    /// For more information about named threads, see\n    /// [this module-level documentation][naming-threads].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new()\n    ///     .name(\"foo\".into());\n    ///\n    /// let handler = builder.spawn(|| {\n    ///     assert_eq!(thread::current().name(), Some(\"foo\"))\n    /// }).unwrap();\n    ///\n    /// handler.join().unwrap();\n    /// ```\n    ///\n    /// [naming-threads]: ./index.html#naming-threads\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn name(mut self, name: String) -> Builder {\n        self.name = Some(name);\n        self\n    }\n\n    /// Sets the size of the stack (in bytes) for the new thread.\n    ///\n    /// The actual stack size may be greater than this value if\n    /// the platform specifies minimal stack size.\n    ///\n    /// For more information about the stack size for threads, see\n    /// [this module-level documentation][stack-size].\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new().stack_size(32 * 1024);\n    /// ```\n    ///\n    /// [stack-size]: ./index.html#stack-size\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn stack_size(mut self, size: usize) -> Builder {\n        self.stack_size = Some(size);\n        self\n    }\n\n    /// Spawns a new thread by taking ownership of the `Builder`, and returns an\n    /// [`io::Result`] to its [`JoinHandle`].\n    ///\n    /// The spawned thread may outlive the caller (unless the caller thread\n    /// is the main thread; the whole process is terminated when the main\n    /// thread finishes). The join handle can be used to block on\n    /// termination of the child thread, including recovering its panics.\n    ///\n    /// For a more complete documentation see [`thread::spawn`][`spawn`].\n    ///\n    /// # Errors\n    ///\n    /// Unlike the [`spawn`] free function, this method yields an\n    /// [`io::Result`] to capture any failure to create the thread at\n    /// the OS level.\n    ///\n    /// [`spawn`]: ../../std/thread/fn.spawn.html\n    /// [`io::Result`]: ../../std/io/type.Result.html\n    /// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html\n    ///\n    /// # Panics\n    ///\n    /// Panics if a thread name was set and it contained null bytes.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new();\n    ///\n    /// let handler = builder.spawn(|| {\n    ///     // thread code\n    /// }).unwrap();\n    ///\n    /// handler.join().unwrap();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn spawn<F, T>(self, f: F) -> io::Result<JoinHandle<T>> where\n        F: FnOnce() -> T, F: Send + 'static, T: Send + 'static\n    {\n        unsafe { self.spawn_unchecked(f) }\n    }\n\n    /// Spawns a new thread without any lifetime restrictions by taking ownership\n    /// of the `Builder`, and returns an [`io::Result`] to its [`JoinHandle`].\n    ///\n    /// The spawned thread may outlive the caller (unless the caller thread\n    /// is the main thread; the whole process is terminated when the main\n    /// thread finishes). The join handle can be used to block on\n    /// termination of the child thread, including recovering its panics.\n    ///\n    /// This method is identical to [`thread::Builder::spawn`][`Builder::spawn`],\n    /// except for the relaxed lifetime bounds, which render it unsafe.\n    /// For a more complete documentation see [`thread::spawn`][`spawn`].\n    ///\n    /// # Errors\n    ///\n    /// Unlike the [`spawn`] free function, this method yields an\n    /// [`io::Result`] to capture any failure to create the thread at\n    /// the OS level.\n    ///\n    /// # Panics\n    ///\n    /// Panics if a thread name was set and it contained null bytes.\n    ///\n    /// # Safety\n    ///\n    /// The caller has to ensure that no references in the supplied thread closure\n    /// or its return type can outlive the spawned thread's lifetime. This can be\n    /// guaranteed in two ways:\n    ///\n    /// - ensure that [`join`][`JoinHandle::join`] is called before any referenced\n    /// data is dropped\n    /// - use only types with `'static` lifetime bounds, i.e. those with no or only\n    /// `'static` references (both [`thread::Builder::spawn`][`Builder::spawn`]\n    /// and [`thread::spawn`][`spawn`] enforce this property statically)\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(thread_spawn_unchecked)]\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new();\n    ///\n    /// let x = 1;\n    /// let thread_x = &x;\n    ///\n    /// let handler = unsafe {\n    ///     builder.spawn_unchecked(move || {\n    ///         println!(\"x = {}\", *thread_x);\n    ///     }).unwrap()\n    /// };\n    ///\n    /// // caller has to ensure `join()` is called, otherwise\n    /// // it is possible to access freed memory if `x` gets\n    /// // dropped before the thread closure is executed!\n    /// handler.join().unwrap();\n    /// ```\n    ///\n    /// [`spawn`]: ../../std/thread/fn.spawn.html\n    /// [`Builder::spawn`]: ../../std/thread/struct.Builder.html#method.spawn\n    /// [`io::Result`]: ../../std/io/type.Result.html\n    /// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html\n    #[unstable(feature = \"thread_spawn_unchecked\", issue = \"55132\")]\n    pub unsafe fn spawn_unchecked<F, T>(self, f: F) -> io::Result<JoinHandle<T>> where\n        F: FnOnce() -> T, F: Send, T: Send\n    {\n        let Builder { name, stack_size } = self;\n\n        let stack_size = stack_size.unwrap_or_else(thread::min_stack);\n\n        let my_thread = Thread::new(name);\n        let their_thread = my_thread.clone();\n\n        let my_packet : Arc<UnsafeCell<Option<Result<T>>>>\n            = Arc::new(UnsafeCell::new(None));\n        let their_packet = my_packet.clone();\n\n        let main = move || {\n            if let Some(name) = their_thread.cname() {\n                imp::Thread::set_name(name);\n            }\n\n            thread_info::set(imp::guard::current(), their_thread);\n            #[cfg(feature = \"backtrace\")]\n            let try_result = panic::catch_unwind(panic::AssertUnwindSafe(|| {\n                ::sys_common::backtrace::__rust_begin_short_backtrace(f)\n            }));\n            #[cfg(not(feature = \"backtrace\"))]\n            let try_result = panic::catch_unwind(panic::AssertUnwindSafe(f));\n            *their_packet.get() = Some(try_result);\n        };\n\n        Ok(JoinHandle(JoinInner {\n            native: Some(imp::Thread::new(stack_size, Box::new(main))?),\n            thread: my_thread,\n            packet: Packet(my_packet),\n        }))\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Free functions\n////////////////////////////////////////////////////////////////////////////////\n\n/// Spawns a new thread, returning a [`JoinHandle`] for it.\n///\n/// The join handle will implicitly *detach* the child thread upon being\n/// dropped. In this case, the child thread may outlive the parent (unless\n/// the parent thread is the main thread; the whole process is terminated when\n/// the main thread finishes). Additionally, the join handle provides a [`join`]\n/// method that can be used to join the child thread. If the child thread\n/// panics, [`join`] will return an [`Err`] containing the argument given to\n/// [`panic`].\n///\n/// This will create a thread using default parameters of [`Builder`], if you\n/// want to specify the stack size or the name of the thread, use this API\n/// instead.\n///\n/// As you can see in the signature of `spawn` there are two constraints on\n/// both the closure given to `spawn` and its return value, let's explain them:\n///\n/// - The `'static` constraint means that the closure and its return value\n///   must have a lifetime of the whole program execution. The reason for this\n///   is that threads can `detach` and outlive the lifetime they have been\n///   created in.\n///   Indeed if the thread, and by extension its return value, can outlive their\n///   caller, we need to make sure that they will be valid afterwards, and since\n///   we *can't* know when it will return we need to have them valid as long as\n///   possible, that is until the end of the program, hence the `'static`\n///   lifetime.\n/// - The [`Send`] constraint is because the closure will need to be passed\n///   *by value* from the thread where it is spawned to the new thread. Its\n///   return value will need to be passed from the new thread to the thread\n///   where it is `join`ed.\n///   As a reminder, the [`Send`] marker trait expresses that it is safe to be\n///   passed from thread to thread. [`Sync`] expresses that it is safe to have a\n///   reference be passed from thread to thread.\n///\n/// # Panics\n///\n/// Panics if the OS fails to create a thread; use [`Builder::spawn`]\n/// to recover from such errors.\n///\n/// # Examples\n///\n/// Creating a thread.\n///\n/// ```\n/// use std::thread;\n///\n/// let handler = thread::spawn(|| {\n///     // thread code\n/// });\n///\n/// handler.join().unwrap();\n/// ```\n///\n/// As mentioned in the module documentation, threads are usually made to\n/// communicate using [`channels`], here is how it usually looks.\n///\n/// This example also shows how to use `move`, in order to give ownership\n/// of values to a thread.\n///\n/// ```\n/// use std::thread;\n/// use std::sync::mpsc::channel;\n///\n/// let (tx, rx) = channel();\n///\n/// let sender = thread::spawn(move || {\n///     tx.send(\"Hello, thread\".to_owned())\n///         .expect(\"Unable to send on channel\");\n/// });\n///\n/// let receiver = thread::spawn(move || {\n///     let value = rx.recv().expect(\"Unable to receive from channel\");\n///     println!(\"{}\", value);\n/// });\n///\n/// sender.join().expect(\"The sender thread has panicked\");\n/// receiver.join().expect(\"The receiver thread has panicked\");\n/// ```\n///\n/// A thread can also return a value through its [`JoinHandle`], you can use\n/// this to make asynchronous computations (futures might be more appropriate\n/// though).\n///\n/// ```\n/// use std::thread;\n///\n/// let computation = thread::spawn(|| {\n///     // Some expensive computation.\n///     42\n/// });\n///\n/// let result = computation.join().unwrap();\n/// println!(\"{}\", result);\n/// ```\n///\n/// [`channels`]: ../../std/sync/mpsc/index.html\n/// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html\n/// [`join`]: ../../std/thread/struct.JoinHandle.html#method.join\n/// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n/// [`panic`]: ../../std/macro.panic.html\n/// [`Builder::spawn`]: ../../std/thread/struct.Builder.html#method.spawn\n/// [`Builder`]: ../../std/thread/struct.Builder.html\n/// [`Send`]: ../../std/marker/trait.Send.html\n/// [`Sync`]: ../../std/marker/trait.Sync.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn spawn<F, T>(f: F) -> JoinHandle<T> where\n    F: FnOnce() -> T, F: Send + 'static, T: Send + 'static\n{\n    Builder::new().spawn(f).unwrap()\n}\n\n/// Gets a handle to the thread that invokes it.\n///\n/// # Examples\n///\n/// Getting a handle to the current thread with `thread::current()`:\n///\n/// ```\n/// use std::thread;\n///\n/// let handler = thread::Builder::new()\n///     .name(\"named thread\".into())\n///     .spawn(|| {\n///         let handle = thread::current();\n///         assert_eq!(handle.name(), Some(\"named thread\"));\n///     })\n///     .unwrap();\n///\n/// handler.join().unwrap();\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn current() -> Thread {\n    thread_info::current_thread().expect(\"use of std::thread::current() is not \\\n                                          possible after the thread's local \\\n                                          data has been destroyed\")\n}\n\n/// Cooperatively gives up a timeslice to the OS scheduler.\n///\n/// This is used when the programmer knows that the thread will have nothing\n/// to do for some time, and thus avoid wasting computing time.\n///\n/// For example when polling on a resource, it is common to check that it is\n/// available, and if not to yield in order to avoid busy waiting.\n///\n/// Thus the pattern of `yield`ing after a failed poll is rather common when\n/// implementing low-level shared resources or synchronization primitives.\n///\n/// However programmers will usually prefer to use [`channel`]s, [`Condvar`]s,\n/// [`Mutex`]es or [`join`] for their synchronization routines, as they avoid\n/// thinking about thread scheduling.\n///\n/// Note that [`channel`]s for example are implemented using this primitive.\n/// Indeed when you call `send` or `recv`, which are blocking, they will yield\n/// if the channel is not available.\n///\n/// # Examples\n///\n/// ```\n/// use std::thread;\n///\n/// thread::yield_now();\n/// ```\n///\n/// [`channel`]: ../../std/sync/mpsc/index.html\n/// [`spawn`]: ../../std/thread/fn.spawn.html\n/// [`join`]: ../../std/thread/struct.JoinHandle.html#method.join\n/// [`Mutex`]: ../../std/sync/struct.Mutex.html\n/// [`Condvar`]: ../../std/sync/struct.Condvar.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn yield_now() {\n    imp::Thread::yield_now()\n}\n\n/// Determines whether the current thread is unwinding because of panic.\n///\n/// A common use of this feature is to poison shared resources when writing\n/// unsafe code, by checking `panicking` when the `drop` is called.\n///\n/// This is usually not needed when writing safe code, as [`Mutex`es][Mutex]\n/// already poison themselves when a thread panics while holding the lock.\n///\n/// This can also be used in multithreaded applications, in order to send a\n/// message to other threads warning that a thread has panicked (e.g. for\n/// monitoring purposes).\n///\n/// # Examples\n///\n/// ```should_panic\n/// use std::thread;\n///\n/// struct SomeStruct;\n///\n/// impl Drop for SomeStruct {\n///     fn drop(&mut self) {\n///         if thread::panicking() {\n///             println!(\"dropped while unwinding\");\n///         } else {\n///             println!(\"dropped while not unwinding\");\n///         }\n///     }\n/// }\n///\n/// {\n///     print!(\"a: \");\n///     let a = SomeStruct;\n/// }\n///\n/// {\n///     print!(\"b: \");\n///     let b = SomeStruct;\n///     panic!()\n/// }\n/// ```\n///\n/// [Mutex]: ../../std/sync/struct.Mutex.html\n#[inline]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn panicking() -> bool {\n    panicking::panicking()\n}\n\n/// Puts the current thread to sleep for at least the specified amount of time.\n///\n/// The thread may sleep longer than the duration specified due to scheduling\n/// specifics or platform-dependent functionality. It will never sleep less.\n///\n/// # Platform-specific behavior\n///\n/// On Unix platforms, the underlying syscall may be interrupted by a\n/// spurious wakeup or signal handler. To ensure the sleep occurs for at least\n/// the specified duration, this function may invoke that system call multiple\n/// times.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::thread;\n///\n/// // Let's sleep for 2 seconds:\n/// thread::sleep_ms(2000);\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(since = \"1.6.0\", reason = \"replaced by `std::thread::sleep`\")]\npub fn sleep_ms(ms: u32) {\n    sleep(Duration::from_millis(ms as u64))\n}\n\n/// Puts the current thread to sleep for at least the specified amount of time.\n///\n/// The thread may sleep longer than the duration specified due to scheduling\n/// specifics or platform-dependent functionality. It will never sleep less.\n///\n/// # Platform-specific behavior\n///\n/// On Unix platforms, the underlying syscall may be interrupted by a\n/// spurious wakeup or signal handler. To ensure the sleep occurs for at least\n/// the specified duration, this function may invoke that system call multiple\n/// times.\n/// Platforms which do not support nanosecond precision for sleeping will\n/// have `dur` rounded up to the nearest granularity of time they can sleep for.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::{thread, time};\n///\n/// let ten_millis = time::Duration::from_millis(10);\n/// let now = time::Instant::now();\n///\n/// thread::sleep(ten_millis);\n///\n/// assert!(now.elapsed() >= ten_millis);\n/// ```\n#[stable(feature = \"thread_sleep\", since = \"1.4.0\")]\npub fn sleep(dur: Duration) {\n    imp::Thread::sleep(dur)\n}\n\n// constants for park/unpark\nconst EMPTY: usize = 0;\nconst PARKED: usize = 1;\nconst NOTIFIED: usize = 2;\n\n/// Blocks unless or until the current thread's token is made available.\n///\n/// A call to `park` does not guarantee that the thread will remain parked\n/// forever, and callers should be prepared for this possibility.\n///\n/// # park and unpark\n///\n/// Every thread is equipped with some basic low-level blocking support, via the\n/// [`thread::park`][`park`] function and [`thread::Thread::unpark`][`unpark`]\n/// method. [`park`] blocks the current thread, which can then be resumed from\n/// another thread by calling the [`unpark`] method on the blocked thread's\n/// handle.\n///\n/// Conceptually, each [`Thread`] handle has an associated token, which is\n/// initially not present:\n///\n/// * The [`thread::park`][`park`] function blocks the current thread unless or\n///   until the token is available for its thread handle, at which point it\n///   atomically consumes the token. It may also return *spuriously*, without\n///   consuming the token. [`thread::park_timeout`] does the same, but allows\n///   specifying a maximum time to block the thread for.\n///\n/// * The [`unpark`] method on a [`Thread`] atomically makes the token available\n///   if it wasn't already. Because the token is initially absent, [`unpark`]\n///   followed by [`park`] will result in the second call returning immediately.\n///\n/// In other words, each [`Thread`] acts a bit like a spinlock that can be\n/// locked and unlocked using `park` and `unpark`.\n///\n/// The API is typically used by acquiring a handle to the current thread,\n/// placing that handle in a shared data structure so that other threads can\n/// find it, and then `park`ing. When some desired condition is met, another\n/// thread calls [`unpark`] on the handle.\n///\n/// The motivation for this design is twofold:\n///\n/// * It avoids the need to allocate mutexes and condvars when building new\n///   synchronization primitives; the threads already provide basic\n///   blocking/signaling.\n///\n/// * It can be implemented very efficiently on many platforms.\n///\n/// # Examples\n///\n/// ```\n/// use std::thread;\n/// use std::time::Duration;\n///\n/// let parked_thread = thread::Builder::new()\n///     .spawn(|| {\n///         println!(\"Parking thread\");\n///         thread::park();\n///         println!(\"Thread unparked\");\n///     })\n///     .unwrap();\n///\n/// // Let some time pass for the thread to be spawned.\n/// thread::sleep(Duration::from_millis(10));\n///\n/// // There is no race condition here, if `unpark`\n/// // happens first, `park` will return immediately.\n/// println!(\"Unpark the thread\");\n/// parked_thread.thread().unpark();\n///\n/// parked_thread.join().unwrap();\n/// ```\n///\n/// [`Thread`]: ../../std/thread/struct.Thread.html\n/// [`park`]: ../../std/thread/fn.park.html\n/// [`unpark`]: ../../std/thread/struct.Thread.html#method.unpark\n/// [`thread::park_timeout`]: ../../std/thread/fn.park_timeout.html\n//\n// The implementation currently uses the trivial strategy of a Mutex+Condvar\n// with wakeup flag, which does not actually allow spurious wakeups. In the\n// future, this will be implemented in a more efficient way, perhaps along the lines of\n//   http://cr.openjdk.java.net/~stefank/6989984.1/raw_files/new/src/os/linux/vm/os_linux.cpp\n// or futuxes, and in either case may allow spurious wakeups.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn park() {\n    let thread = current();\n\n    // If we were previously notified then we consume this notification and\n    // return quickly.\n    if thread.inner.state.compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst).is_ok() {\n        return\n    }\n\n    // Otherwise we need to coordinate going to sleep\n    let mut m = thread.inner.lock.lock().unwrap();\n    match thread.inner.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) {\n        Ok(_) => {}\n        Err(NOTIFIED) => {\n            // We must read here, even though we know it will be `NOTIFIED`.\n            // This is because `unpark` may have been called again since we read\n            // `NOTIFIED` in the `compare_exchange` above. We must perform an\n            // acquire operation that synchronizes with that `unpark` to observe\n            // any writes it made before the call to unpark. To do that we must\n            // read from the write it made to `state`.\n            let old = thread.inner.state.swap(EMPTY, SeqCst);\n            assert_eq!(old, NOTIFIED, \"park state changed unexpectedly\");\n            return;\n        } // should consume this notification, so prohibit spurious wakeups in next park.\n        Err(_) => panic!(\"inconsistent park state\"),\n    }\n    loop {\n        m = thread.inner.cvar.wait(m).unwrap();\n        match thread.inner.state.compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst) {\n            Ok(_) => return, // got a notification\n            Err(_) => {} // spurious wakeup, go back to sleep\n        }\n    }\n}\n\n/// Use [`park_timeout`].\n///\n/// Blocks unless or until the current thread's token is made available or\n/// the specified duration has been reached (may wake spuriously).\n///\n/// The semantics of this function are equivalent to [`park`] except\n/// that the thread will be blocked for roughly no longer than `dur`. This\n/// method should not be used for precise timing due to anomalies such as\n/// preemption or platform differences that may not cause the maximum\n/// amount of time waited to be precisely `ms` long.\n///\n/// See the [park documentation][`park`] for more detail.\n///\n/// [`park_timeout`]: fn.park_timeout.html\n/// [`park`]: ../../std/thread/fn.park.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(since = \"1.6.0\", reason = \"replaced by `std::thread::park_timeout`\")]\npub fn park_timeout_ms(ms: u32) {\n    park_timeout(Duration::from_millis(ms as u64))\n}\n\n/// Blocks unless or until the current thread's token is made available or\n/// the specified duration has been reached (may wake spuriously).\n///\n/// The semantics of this function are equivalent to [`park`][park] except\n/// that the thread will be blocked for roughly no longer than `dur`. This\n/// method should not be used for precise timing due to anomalies such as\n/// preemption or platform differences that may not cause the maximum\n/// amount of time waited to be precisely `dur` long.\n///\n/// See the [park documentation][park] for more details.\n///\n/// # Platform-specific behavior\n///\n/// Platforms which do not support nanosecond precision for sleeping will have\n/// `dur` rounded up to the nearest granularity of time they can sleep for.\n///\n/// # Examples\n///\n/// Waiting for the complete expiration of the timeout:\n///\n/// ```rust,no_run\n/// use std::thread::park_timeout;\n/// use std::time::{Instant, Duration};\n///\n/// let timeout = Duration::from_secs(2);\n/// let beginning_park = Instant::now();\n///\n/// let mut timeout_remaining = timeout;\n/// loop {\n///     park_timeout(timeout_remaining);\n///     let elapsed = beginning_park.elapsed();\n///     if elapsed >= timeout {\n///         break;\n///     }\n///     println!(\"restarting park_timeout after {:?}\", elapsed);\n///     timeout_remaining = timeout - elapsed;\n/// }\n/// ```\n///\n/// [park]: fn.park.html\n#[stable(feature = \"park_timeout\", since = \"1.4.0\")]\npub fn park_timeout(dur: Duration) {\n    let thread = current();\n\n    // Like `park` above we have a fast path for an already-notified thread, and\n    // afterwards we start coordinating for a sleep.\n    // return quickly.\n    if thread.inner.state.compare_exchange(NOTIFIED, EMPTY, SeqCst, SeqCst).is_ok() {\n        return\n    }\n    let m = thread.inner.lock.lock().unwrap();\n    match thread.inner.state.compare_exchange(EMPTY, PARKED, SeqCst, SeqCst) {\n        Ok(_) => {}\n        Err(NOTIFIED) => {\n            // We must read again here, see `park`.\n            let old = thread.inner.state.swap(EMPTY, SeqCst);\n            assert_eq!(old, NOTIFIED, \"park state changed unexpectedly\");\n            return;\n        } // should consume this notification, so prohibit spurious wakeups in next park.\n        Err(_) => panic!(\"inconsistent park_timeout state\"),\n    }\n\n    // Wait with a timeout, and if we spuriously wake up or otherwise wake up\n    // from a notification we just want to unconditionally set the state back to\n    // empty, either consuming a notification or un-flagging ourselves as\n    // parked.\n    let (_m, _result) = thread.inner.cvar.wait_timeout(m, dur).unwrap();\n    match thread.inner.state.swap(EMPTY, SeqCst) {\n        NOTIFIED => {} // got a notification, hurray!\n        PARKED => {} // no notification, alas\n        n => panic!(\"inconsistent park_timeout state: {}\", n),\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// ThreadId\n////////////////////////////////////////////////////////////////////////////////\n\n/// A unique identifier for a running thread.\n///\n/// A `ThreadId` is an opaque object that has a unique value for each thread\n/// that creates one. `ThreadId`s are not guaranteed to correspond to a thread's\n/// system-designated identifier. A `ThreadId` can be retrieved from the [`id`]\n/// method on a [`Thread`].\n///\n/// # Examples\n///\n/// ```\n/// use std::thread;\n///\n/// let other_thread = thread::spawn(|| {\n///     thread::current().id()\n/// });\n///\n/// let other_thread_id = other_thread.join().unwrap();\n/// assert!(thread::current().id() != other_thread_id);\n/// ```\n///\n/// [`id`]: ../../std/thread/struct.Thread.html#method.id\n/// [`Thread`]: ../../std/thread/struct.Thread.html\n#[stable(feature = \"thread_id\", since = \"1.19.0\")]\n#[derive(Eq, PartialEq, Clone, Copy, Hash, Debug)]\npub struct ThreadId(u64);\n\nimpl ThreadId {\n    // Generate a new unique thread ID.\n    fn new() -> ThreadId {\n        // We never call `GUARD.init()`, so it is UB to attempt to\n        // acquire this mutex reentrantly!\n        static GUARD: mutex::Mutex = mutex::Mutex::new();\n        static mut COUNTER: u64 = 0;\n\n        unsafe {\n            let _guard = GUARD.lock();\n\n            // If we somehow use up all our bits, panic so that we're not\n            // covering up subtle bugs of IDs being reused.\n            if COUNTER == ::u64::MAX {\n                panic!(\"failed to generate unique thread ID: bitspace exhausted\");\n            }\n\n            let id = COUNTER;\n            COUNTER += 1;\n\n            ThreadId(id)\n        }\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Thread\n////////////////////////////////////////////////////////////////////////////////\n\n/// The internal representation of a `Thread` handle\nstruct Inner {\n    name: Option<CString>,      // Guaranteed to be UTF-8\n    id: ThreadId,\n\n    // state for thread park/unpark\n    state: AtomicUsize,\n    lock: Mutex<()>,\n    cvar: Condvar,\n}\n\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n/// A handle to a thread.\n///\n/// Threads are represented via the `Thread` type, which you can get in one of\n/// two ways:\n///\n/// * By spawning a new thread, e.g. using the [`thread::spawn`][`spawn`]\n///   function, and calling [`thread`][`JoinHandle::thread`] on the\n///   [`JoinHandle`].\n/// * By requesting the current thread, using the [`thread::current`] function.\n///\n/// The [`thread::current`] function is available even for threads not spawned\n/// by the APIs of this module.\n///\n/// There is usually no need to create a `Thread` struct yourself, one\n/// should instead use a function like `spawn` to create new threads, see the\n/// docs of [`Builder`] and [`spawn`] for more details.\n///\n/// [`Builder`]: ../../std/thread/struct.Builder.html\n/// [`JoinHandle::thread`]: ../../std/thread/struct.JoinHandle.html#method.thread\n/// [`JoinHandle`]: ../../std/thread/struct.JoinHandle.html\n/// [`thread::current`]: ../../std/thread/fn.current.html\n/// [`spawn`]: ../../std/thread/fn.spawn.html\n\npub struct Thread {\n    inner: Arc<Inner>,\n}\n\nimpl Thread {\n    // Used only internally to construct a thread object without spawning\n    // Panics if the name contains nuls.\n    pub(crate) fn new(name: Option<String>) -> Thread {\n        let cname = name.map(|n| {\n            CString::new(n).expect(\"thread name may not contain interior null bytes\")\n        });\n        Thread {\n            inner: Arc::new(Inner {\n                name: cname,\n                id: ThreadId::new(),\n                state: AtomicUsize::new(EMPTY),\n                lock: Mutex::new(()),\n                cvar: Condvar::new(),\n            })\n        }\n    }\n\n    /// Atomically makes the handle's token available if it is not already.\n    ///\n    /// Every thread is equipped with some basic low-level blocking support, via\n    /// the [`park`][park] function and the `unpark()` method. These can be\n    /// used as a more CPU-efficient implementation of a spinlock.\n    ///\n    /// See the [park documentation][park] for more details.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    /// use std::time::Duration;\n    ///\n    /// let parked_thread = thread::Builder::new()\n    ///     .spawn(|| {\n    ///         println!(\"Parking thread\");\n    ///         thread::park();\n    ///         println!(\"Thread unparked\");\n    ///     })\n    ///     .unwrap();\n    ///\n    /// // Let some time pass for the thread to be spawned.\n    /// thread::sleep(Duration::from_millis(10));\n    ///\n    /// println!(\"Unpark the thread\");\n    /// parked_thread.thread().unpark();\n    ///\n    /// parked_thread.join().unwrap();\n    /// ```\n    ///\n    /// [park]: fn.park.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn unpark(&self) {\n        // To ensure the unparked thread will observe any writes we made\n        // before this call, we must perform a release operation that `park`\n        // can synchronize with. To do that we must write `NOTIFIED` even if\n        // `state` is already `NOTIFIED`. That is why this must be a swap\n        // rather than a compare-and-swap that returns if it reads `NOTIFIED`\n        // on failure.\n        match self.inner.state.swap(NOTIFIED, SeqCst) {\n            EMPTY => return, // no one was waiting\n            NOTIFIED => return, // already unparked\n            PARKED => {} // gotta go wake someone up\n            _ => panic!(\"inconsistent state in unpark\"),\n        }\n\n        // There is a period between when the parked thread sets `state` to\n        // `PARKED` (or last checked `state` in the case of a spurious wake\n        // up) and when it actually waits on `cvar`. If we were to notify\n        // during this period it would be ignored and then when the parked\n        // thread went to sleep it would never wake up. Fortunately, it has\n        // `lock` locked at this stage so we can acquire `lock` to wait until\n        // it is ready to receive the notification.\n        //\n        // Releasing `lock` before the call to `notify_one` means that when the\n        // parked thread wakes it doesn't get woken only to have to wait for us\n        // to release `lock`.\n        drop(self.inner.lock.lock().unwrap());\n        self.inner.cvar.notify_one()\n    }\n\n    /// Gets the thread's unique identifier.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let other_thread = thread::spawn(|| {\n    ///     thread::current().id()\n    /// });\n    ///\n    /// let other_thread_id = other_thread.join().unwrap();\n    /// assert!(thread::current().id() != other_thread_id);\n    /// ```\n    #[stable(feature = \"thread_id\", since = \"1.19.0\")]\n    pub fn id(&self) -> ThreadId {\n        self.inner.id\n    }\n\n    /// Gets the thread's name.\n    ///\n    /// For more information about named threads, see\n    /// [this module-level documentation][naming-threads].\n    ///\n    /// # Examples\n    ///\n    /// Threads by default have no name specified:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new();\n    ///\n    /// let handler = builder.spawn(|| {\n    ///     assert!(thread::current().name().is_none());\n    /// }).unwrap();\n    ///\n    /// handler.join().unwrap();\n    /// ```\n    ///\n    /// Thread with a specified name:\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new()\n    ///     .name(\"foo\".into());\n    ///\n    /// let handler = builder.spawn(|| {\n    ///     assert_eq!(thread::current().name(), Some(\"foo\"))\n    /// }).unwrap();\n    ///\n    /// handler.join().unwrap();\n    /// ```\n    ///\n    /// [naming-threads]: ./index.html#naming-threads\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn name(&self) -> Option<&str> {\n        self.cname().map(|s| unsafe { str::from_utf8_unchecked(s.to_bytes()) } )\n    }\n\n    fn cname(&self) -> Option<&CStr> {\n        self.inner.name.as_ref().map(|s| &**s)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for Thread {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Debug::fmt(&self.name(), f)\n    }\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// JoinHandle\n////////////////////////////////////////////////////////////////////////////////\n\n/// A specialized [`Result`] type for threads.\n///\n/// Indicates the manner in which a thread exited.\n///\n/// A thread that completes without panicking is considered to exit successfully.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::thread;\n/// use std::fs;\n///\n/// fn copy_in_thread() -> thread::Result<()> {\n///     thread::spawn(move || { fs::copy(\"foo.txt\", \"bar.txt\").unwrap(); }).join()\n/// }\n///\n/// fn main() {\n///     match copy_in_thread() {\n///         Ok(_) => println!(\"this is fine\"),\n///         Err(_) => println!(\"thread panicked\"),\n///     }\n/// }\n/// ```\n///\n/// [`Result`]: ../../std/result/enum.Result.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub type Result<T> = ::result::Result<T, Box<dyn Any + Send + 'static>>;\n\n// This packet is used to communicate the return value between the child thread\n// and the parent thread. Memory is shared through the `Arc` within and there's\n// no need for a mutex here because synchronization happens with `join()` (the\n// parent thread never reads this packet until the child has exited).\n//\n// This packet itself is then stored into a `JoinInner` which in turns is placed\n// in `JoinHandle` and `JoinGuard`. Due to the usage of `UnsafeCell` we need to\n// manually worry about impls like Send and Sync. The type `T` should\n// already always be Send (otherwise the thread could not have been created) and\n// this type is inherently Sync because no methods take &self. Regardless,\n// however, we add inheriting impls for Send/Sync to this type to ensure it's\n// Send/Sync and that future modifications will still appropriately classify it.\nstruct Packet<T>(Arc<UnsafeCell<Option<Result<T>>>>);\n\nunsafe impl<T: Send> Send for Packet<T> {}\nunsafe impl<T: Sync> Sync for Packet<T> {}\n\n/// Inner representation for JoinHandle\nstruct JoinInner<T> {\n    native: Option<imp::Thread>,\n    thread: Thread,\n    packet: Packet<T>,\n}\n\nimpl<T> JoinInner<T> {\n    fn join(&mut self) -> Result<T> {\n        self.native.take().unwrap().join();\n        unsafe {\n            (*self.packet.0.get()).take().unwrap()\n        }\n    }\n}\n\n/// An owned permission to join on a thread (block on its termination).\n///\n/// A `JoinHandle` *detaches* the associated thread when it is dropped, which\n/// means that there is no longer any handle to thread and no way to `join`\n/// on it.\n///\n/// Due to platform restrictions, it is not possible to [`Clone`] this\n/// handle: the ability to join a thread is a uniquely-owned permission.\n///\n/// This `struct` is created by the [`thread::spawn`] function and the\n/// [`thread::Builder::spawn`] method.\n///\n/// # Examples\n///\n/// Creation from [`thread::spawn`]:\n///\n/// ```\n/// use std::thread;\n///\n/// let join_handle: thread::JoinHandle<_> = thread::spawn(|| {\n///     // some work here\n/// });\n/// ```\n///\n/// Creation from [`thread::Builder::spawn`]:\n///\n/// ```\n/// use std::thread;\n///\n/// let builder = thread::Builder::new();\n///\n/// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {\n///     // some work here\n/// }).unwrap();\n/// ```\n///\n/// Child being detached and outliving its parent:\n///\n/// ```no_run\n/// use std::thread;\n/// use std::time::Duration;\n///\n/// let original_thread = thread::spawn(|| {\n///     let _detached_thread = thread::spawn(|| {\n///         // Here we sleep to make sure that the first thread returns before.\n///         thread::sleep(Duration::from_millis(10));\n///         // This will be called, even though the JoinHandle is dropped.\n///         println!(\"\u266b Still alive \u266b\");\n///     });\n/// });\n///\n/// original_thread.join().expect(\"The thread being joined has panicked\");\n/// println!(\"Original thread is joined.\");\n///\n/// // We make sure that the new thread has time to run, before the main\n/// // thread returns.\n///\n/// thread::sleep(Duration::from_millis(1000));\n/// ```\n///\n/// [`Clone`]: ../../std/clone/trait.Clone.html\n/// [`thread::spawn`]: fn.spawn.html\n/// [`thread::Builder::spawn`]: struct.Builder.html#method.spawn\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct JoinHandle<T>(JoinInner<T>);\n\n#[stable(feature = \"joinhandle_impl_send_sync\", since = \"1.29.0\")]\nunsafe impl<T> Send for JoinHandle<T> {}\n#[stable(feature = \"joinhandle_impl_send_sync\", since = \"1.29.0\")]\nunsafe impl<T> Sync for JoinHandle<T> {}\n\nimpl<T> JoinHandle<T> {\n    /// Extracts a handle to the underlying thread.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new();\n    ///\n    /// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {\n    ///     // some work here\n    /// }).unwrap();\n    ///\n    /// let thread = join_handle.thread();\n    /// println!(\"thread id: {:?}\", thread.id());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn thread(&self) -> &Thread {\n        &self.0.thread\n    }\n\n    /// Waits for the associated thread to finish.\n    ///\n    /// In terms of [atomic memory orderings],  the completion of the associated\n    /// thread synchronizes with this function returning. In other words, all\n    /// operations performed by that thread are ordered before all\n    /// operations that happen after `join` returns.\n    ///\n    /// If the child thread panics, [`Err`] is returned with the parameter given\n    /// to [`panic`].\n    ///\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    /// [`panic`]: ../../std/macro.panic.html\n    /// [atomic memory orderings]: ../../std/sync/atomic/index.html\n    ///\n    /// # Panics\n    ///\n    /// This function may panic on some platforms if a thread attempts to join\n    /// itself or otherwise may create a deadlock with joining threads.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::thread;\n    ///\n    /// let builder = thread::Builder::new();\n    ///\n    /// let join_handle: thread::JoinHandle<_> = builder.spawn(|| {\n    ///     // some work here\n    /// }).unwrap();\n    /// join_handle.join().expect(\"Couldn't join on the associated thread\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn join(mut self) -> Result<T> {\n        self.0.join()\n    }\n}\n\nimpl<T> AsInner<imp::Thread> for JoinHandle<T> {\n    fn as_inner(&self) -> &imp::Thread { self.0.native.as_ref().unwrap() }\n}\n\nimpl<T> IntoInner<imp::Thread> for JoinHandle<T> {\n    fn into_inner(self) -> imp::Thread { self.0.native.unwrap() }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<T> fmt::Debug for JoinHandle<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"JoinHandle { .. }\")\n    }\n}\n\nfn _assert_sync_and_send() {\n    fn _assert_both<T: Send + Sync>() {}\n    _assert_both::<JoinHandle<()>>();\n    _assert_both::<Thread>();\n}\n\n////////////////////////////////////////////////////////////////////////////////\n// Tests\n////////////////////////////////////////////////////////////////////////////////\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use any::Any;\n    use sync::mpsc::{channel, Sender};\n    use result;\n    use super::{Builder};\n    use thread;\n    use time::Duration;\n    use u32;\n\n    // !!! These tests are dangerous. If something is buggy, they will hang, !!!\n    // !!! instead of exiting cleanly. This might wedge the buildbots.       !!!\n\n    #[test]\n    fn test_unnamed_thread() {\n        thread::spawn(move|| {\n            assert!(thread::current().name().is_none());\n        }).join().ok().unwrap();\n    }\n\n    #[test]\n    fn test_named_thread() {\n        Builder::new().name(\"ada lovelace\".to_string()).spawn(move|| {\n            assert!(thread::current().name().unwrap() == \"ada lovelace\".to_string());\n        }).unwrap().join().unwrap();\n    }\n\n    #[test]\n    #[should_panic]\n    fn test_invalid_named_thread() {\n        let _ = Builder::new().name(\"ada l\\0velace\".to_string()).spawn(|| {});\n    }\n\n    #[test]\n    fn test_run_basic() {\n        let (tx, rx) = channel();\n        thread::spawn(move|| {\n            tx.send(()).unwrap();\n        });\n        rx.recv().unwrap();\n    }\n\n    #[test]\n    fn test_join_panic() {\n        match thread::spawn(move|| {\n            panic!()\n        }).join() {\n            result::Result::Err(_) => (),\n            result::Result::Ok(()) => panic!()\n        }\n    }\n\n    #[test]\n    fn test_spawn_sched() {\n        let (tx, rx) = channel();\n\n        fn f(i: i32, tx: Sender<()>) {\n            let tx = tx.clone();\n            thread::spawn(move|| {\n                if i == 0 {\n                    tx.send(()).unwrap();\n                } else {\n                    f(i - 1, tx);\n                }\n            });\n\n        }\n        f(10, tx);\n        rx.recv().unwrap();\n    }\n\n    #[test]\n    fn test_spawn_sched_childs_on_default_sched() {\n        let (tx, rx) = channel();\n\n        thread::spawn(move|| {\n            thread::spawn(move|| {\n                tx.send(()).unwrap();\n            });\n        });\n\n        rx.recv().unwrap();\n    }\n\n    fn avoid_copying_the_body<F>(spawnfn: F) where F: FnOnce(Box<dyn Fn() + Send>) {\n        let (tx, rx) = channel();\n\n        let x: Box<_> = box 1;\n        let x_in_parent = (&*x) as *const i32 as usize;\n\n        spawnfn(Box::new(move|| {\n            let x_in_child = (&*x) as *const i32 as usize;\n            tx.send(x_in_child).unwrap();\n        }));\n\n        let x_in_child = rx.recv().unwrap();\n        assert_eq!(x_in_parent, x_in_child);\n    }\n\n    #[test]\n    fn test_avoid_copying_the_body_spawn() {\n        avoid_copying_the_body(|v| {\n            thread::spawn(move || v());\n        });\n    }\n\n    #[test]\n    fn test_avoid_copying_the_body_thread_spawn() {\n        avoid_copying_the_body(|f| {\n            thread::spawn(move|| {\n                f();\n            });\n        })\n    }\n\n    #[test]\n    fn test_avoid_copying_the_body_join() {\n        avoid_copying_the_body(|f| {\n            let _ = thread::spawn(move|| {\n                f()\n            }).join();\n        })\n    }\n\n    #[test]\n    fn test_child_doesnt_ref_parent() {\n        // If the child refcounts the parent thread, this will stack overflow when\n        // climbing the thread tree to dereference each ancestor. (See #1789)\n        // (well, it would if the constant were 8000+ - I lowered it to be more\n        // valgrind-friendly. try this at home, instead..!)\n        const GENERATIONS: u32 = 16;\n        fn child_no(x: u32) -> Box<dyn Fn() + Send> {\n            return Box::new(move|| {\n                if x < GENERATIONS {\n                    thread::spawn(move|| child_no(x+1)());\n                }\n            });\n        }\n        thread::spawn(|| child_no(0)());\n    }\n\n    #[test]\n    fn test_simple_newsched_spawn() {\n        thread::spawn(move || {});\n    }\n\n    #[test]\n    fn test_try_panic_message_static_str() {\n        match thread::spawn(move|| {\n            panic!(\"static string\");\n        }).join() {\n            Err(e) => {\n                type T = &'static str;\n                assert!(e.is::<T>());\n                assert_eq!(*e.downcast::<T>().unwrap(), \"static string\");\n            }\n            Ok(()) => panic!()\n        }\n    }\n\n    #[test]\n    fn test_try_panic_message_owned_str() {\n        match thread::spawn(move|| {\n            panic!(\"owned string\".to_string());\n        }).join() {\n            Err(e) => {\n                type T = String;\n                assert!(e.is::<T>());\n                assert_eq!(*e.downcast::<T>().unwrap(), \"owned string\".to_string());\n            }\n            Ok(()) => panic!()\n        }\n    }\n\n    #[test]\n    fn test_try_panic_message_any() {\n        match thread::spawn(move|| {\n            panic!(box 413u16 as Box<dyn Any + Send>);\n        }).join() {\n            Err(e) => {\n                type T = Box<dyn Any + Send>;\n                assert!(e.is::<T>());\n                let any = e.downcast::<T>().unwrap();\n                assert!(any.is::<u16>());\n                assert_eq!(*any.downcast::<u16>().unwrap(), 413);\n            }\n            Ok(()) => panic!()\n        }\n    }\n\n    #[test]\n    fn test_try_panic_message_unit_struct() {\n        struct Juju;\n\n        match thread::spawn(move|| {\n            panic!(Juju)\n        }).join() {\n            Err(ref e) if e.is::<Juju>() => {}\n            Err(_) | Ok(()) => panic!()\n        }\n    }\n\n    #[test]\n    fn test_park_timeout_unpark_before() {\n        for _ in 0..10 {\n            thread::current().unpark();\n            thread::park_timeout(Duration::from_millis(u32::MAX as u64));\n        }\n    }\n\n    #[test]\n    fn test_park_timeout_unpark_not_called() {\n        for _ in 0..10 {\n            thread::park_timeout(Duration::from_millis(10));\n        }\n    }\n\n    #[test]\n    fn test_park_timeout_unpark_called_other_thread() {\n        for _ in 0..10 {\n            let th = thread::current();\n\n            let _guard = thread::spawn(move || {\n                super::sleep(Duration::from_millis(50));\n                th.unpark();\n            });\n\n            thread::park_timeout(Duration::from_millis(u32::MAX as u64));\n        }\n    }\n\n    #[test]\n    fn sleep_ms_smoke() {\n        thread::sleep(Duration::from_millis(2));\n    }\n\n    #[test]\n    fn test_thread_id_equal() {\n        assert!(thread::current().id() == thread::current().id());\n    }\n\n    #[test]\n    fn test_thread_id_not_equal() {\n        let spawned_id = thread::spawn(|| thread::current().id()).join().unwrap();\n        assert!(thread::current().id() != spawned_id);\n    }\n\n    // NOTE: the corresponding test for stderr is in run-pass/thread-stderr, due\n    // to the test harness apparently interfering with stderr configuration.\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Filesystem manipulation operations.\n//!\n//! This module contains basic methods to manipulate the contents of the local\n//! filesystem. All methods in this module represent cross-platform filesystem\n//! operations. Extra platform-specific functionality can be found in the\n//! extension traits of `std::os::$platform`.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse fmt;\nuse ffi::OsString;\nuse io::{self, SeekFrom, Seek, Read, Initializer, Write};\nuse path::{Path, PathBuf};\nuse sys::fs as fs_imp;\nuse sys_common::{AsInnerMut, FromInner, AsInner, IntoInner};\nuse time::SystemTime;\n\n/// A reference to an open file on the filesystem.\n///\n/// An instance of a `File` can be read and/or written depending on what options\n/// it was opened with. Files also implement [`Seek`] to alter the logical cursor\n/// that the file contains internally.\n///\n/// Files are automatically closed when they go out of scope.\n///\n/// # Examples\n///\n/// Create a new file and write bytes to it:\n///\n/// ```no_run\n/// use std::fs::File;\n/// use std::io::prelude::*;\n///\n/// fn main() -> std::io::Result<()> {\n///     let mut file = File::create(\"foo.txt\")?;\n///     file.write_all(b\"Hello, world!\")?;\n///     Ok(())\n/// }\n/// ```\n///\n/// Read the contents of a file into a [`String`]:\n///\n/// ```no_run\n/// use std::fs::File;\n/// use std::io::prelude::*;\n///\n/// fn main() -> std::io::Result<()> {\n///     let mut file = File::open(\"foo.txt\")?;\n///     let mut contents = String::new();\n///     file.read_to_string(&mut contents)?;\n///     assert_eq!(contents, \"Hello, world!\");\n///     Ok(())\n/// }\n/// ```\n///\n/// It can be more efficient to read the contents of a file with a buffered\n/// [`Read`]er. This can be accomplished with [`BufReader<R>`]:\n///\n/// ```no_run\n/// use std::fs::File;\n/// use std::io::BufReader;\n/// use std::io::prelude::*;\n///\n/// fn main() -> std::io::Result<()> {\n///     let file = File::open(\"foo.txt\")?;\n///     let mut buf_reader = BufReader::new(file);\n///     let mut contents = String::new();\n///     buf_reader.read_to_string(&mut contents)?;\n///     assert_eq!(contents, \"Hello, world!\");\n///     Ok(())\n/// }\n/// ```\n///\n/// Note that, although read and write methods require a `&mut File`, because\n/// of the interfaces for [`Read`] and [`Write`], the holder of a `&File` can\n/// still modify the file, either through methods that take `&File` or by\n/// retrieving the underlying OS object and modifying the file that way.\n/// Additionally, many operating systems allow concurrent modification of files\n/// by different processes. Avoid assuming that holding a `&File` means that the\n/// file will not change.\n///\n/// [`Seek`]: ../io/trait.Seek.html\n/// [`String`]: ../string/struct.String.html\n/// [`Read`]: ../io/trait.Read.html\n/// [`Write`]: ../io/trait.Write.html\n/// [`BufReader<R>`]: ../io/struct.BufReader.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct File {\n    inner: fs_imp::File,\n}\n\n/// Metadata information about a file.\n///\n/// This structure is returned from the [`metadata`] or\n/// [`symlink_metadata`] function or method and represents known\n/// metadata about a file such as its permissions, size, modification\n/// times, etc.\n///\n/// [`metadata`]: fn.metadata.html\n/// [`symlink_metadata`]: fn.symlink_metadata.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Clone)]\npub struct Metadata(fs_imp::FileAttr);\n\n/// Iterator over the entries in a directory.\n///\n/// This iterator is returned from the [`read_dir`] function of this module and\n/// will yield instances of [`io::Result`]`<`[`DirEntry`]`>`. Through a [`DirEntry`]\n/// information like the entry's path and possibly other metadata can be\n/// learned.\n///\n/// # Errors\n///\n/// This [`io::Result`] will be an [`Err`] if there's some sort of intermittent\n/// IO error during iteration.\n///\n/// [`read_dir`]: fn.read_dir.html\n/// [`DirEntry`]: struct.DirEntry.html\n/// [`io::Result`]: ../io/type.Result.html\n/// [`Err`]: ../result/enum.Result.html#variant.Err\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug)]\npub struct ReadDir(fs_imp::ReadDir);\n\n/// Entries returned by the [`ReadDir`] iterator.\n///\n/// [`ReadDir`]: struct.ReadDir.html\n///\n/// An instance of `DirEntry` represents an entry inside of a directory on the\n/// filesystem. Each entry can be inspected via methods to learn about the full\n/// path or possibly other metadata through per-platform extension traits.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct DirEntry(fs_imp::DirEntry);\n\n/// Options and flags which can be used to configure how a file is opened.\n///\n/// This builder exposes the ability to configure how a [`File`] is opened and\n/// what operations are permitted on the open file. The [`File::open`] and\n/// [`File::create`] methods are aliases for commonly used options using this\n/// builder.\n///\n/// [`File`]: struct.File.html\n/// [`File::open`]: struct.File.html#method.open\n/// [`File::create`]: struct.File.html#method.create\n///\n/// Generally speaking, when using `OpenOptions`, you'll first call [`new`],\n/// then chain calls to methods to set each option, then call [`open`],\n/// passing the path of the file you're trying to open. This will give you a\n/// [`io::Result`][result] with a [`File`][file] inside that you can further\n/// operate on.\n///\n/// [`new`]: struct.OpenOptions.html#method.new\n/// [`open`]: struct.OpenOptions.html#method.open\n/// [result]: ../io/type.Result.html\n/// [file]: struct.File.html\n///\n/// # Examples\n///\n/// Opening a file to read:\n///\n/// ```no_run\n/// use std::fs::OpenOptions;\n///\n/// let file = OpenOptions::new().read(true).open(\"foo.txt\");\n/// ```\n///\n/// Opening a file for both reading and writing, as well as creating it if it\n/// doesn't exist:\n///\n/// ```no_run\n/// use std::fs::OpenOptions;\n///\n/// let file = OpenOptions::new()\n///             .read(true)\n///             .write(true)\n///             .create(true)\n///             .open(\"foo.txt\");\n/// ```\n#[derive(Clone, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct OpenOptions(fs_imp::OpenOptions);\n\n/// Representation of the various permissions on a file.\n///\n/// This module only currently provides one bit of information, [`readonly`],\n/// which is exposed on all currently supported platforms. Unix-specific\n/// functionality, such as mode bits, is available through the\n/// `os::unix::PermissionsExt` trait.\n///\n/// [`readonly`]: struct.Permissions.html#method.readonly\n#[derive(Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Permissions(fs_imp::FilePermissions);\n\n/// A structure representing a type of file with accessors for each file type.\n/// It is returned by [`Metadata::file_type`] method.\n///\n/// [`Metadata::file_type`]: struct.Metadata.html#method.file_type\n#[stable(feature = \"file_type\", since = \"1.1.0\")]\n#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]\npub struct FileType(fs_imp::FileType);\n\n/// A builder used to create directories in various manners.\n///\n/// This builder also supports platform-specific options.\n#[stable(feature = \"dir_builder\", since = \"1.6.0\")]\n#[derive(Debug)]\npub struct DirBuilder {\n    inner: fs_imp::DirBuilder,\n    recursive: bool,\n}\n\n/// How large a buffer to pre-allocate before reading the entire file.\nfn initial_buffer_size(file: &File) -> usize {\n    // Allocate one extra byte so the buffer doesn't need to grow before the\n    // final `read` call at the end of the file.  Don't worry about `usize`\n    // overflow because reading will fail regardless in that case.\n    file.metadata().map(|m| m.len() as usize + 1).unwrap_or(0)\n}\n\n/// Read the entire contents of a file into a bytes vector.\n///\n/// This is a convenience function for using [`File::open`] and [`read_to_end`]\n/// with fewer imports and without an intermediate variable.  It pre-allocates a\n/// buffer based on the file size when available, so it is generally faster than\n/// reading into a vector created with `Vec::new()`.\n///\n/// [`File::open`]: struct.File.html#method.open\n/// [`read_to_end`]: ../io/trait.Read.html#method.read_to_end\n///\n/// # Errors\n///\n/// This function will return an error if `path` does not already exist.\n/// Other errors may also be returned according to [`OpenOptions::open`].\n///\n/// [`OpenOptions::open`]: struct.OpenOptions.html#method.open\n///\n/// It will also return an error if it encounters while reading an error\n/// of a kind other than [`ErrorKind::Interrupted`].\n///\n/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n/// use std::net::SocketAddr;\n///\n/// fn main() -> Result<(), Box<std::error::Error + 'static>> {\n///     let foo: SocketAddr = String::from_utf8_lossy(&fs::read(\"address.txt\")?).parse()?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"fs_read_write_bytes\", since = \"1.26.0\")]\npub fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {\n    let mut file = File::open(path)?;\n    let mut bytes = Vec::with_capacity(initial_buffer_size(&file));\n    file.read_to_end(&mut bytes)?;\n    Ok(bytes)\n}\n\n/// Read the entire contents of a file into a string.\n///\n/// This is a convenience function for using [`File::open`] and [`read_to_string`]\n/// with fewer imports and without an intermediate variable.  It pre-allocates a\n/// buffer based on the file size when available, so it is generally faster than\n/// reading into a string created with `String::new()`.\n///\n/// [`File::open`]: struct.File.html#method.open\n/// [`read_to_string`]: ../io/trait.Read.html#method.read_to_string\n///\n/// # Errors\n///\n/// This function will return an error if `path` does not already exist.\n/// Other errors may also be returned according to [`OpenOptions::open`].\n///\n/// [`OpenOptions::open`]: struct.OpenOptions.html#method.open\n///\n/// It will also return an error if it encounters while reading an error\n/// of a kind other than [`ErrorKind::Interrupted`],\n/// or if the contents of the file are not valid UTF-8.\n///\n/// [`ErrorKind::Interrupted`]: ../../std/io/enum.ErrorKind.html#variant.Interrupted\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n/// use std::net::SocketAddr;\n///\n/// fn main() -> Result<(), Box<std::error::Error + 'static>> {\n///     let foo: SocketAddr = fs::read_to_string(\"address.txt\")?.parse()?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"fs_read_write\", since = \"1.26.0\")]\npub fn read_to_string<P: AsRef<Path>>(path: P) -> io::Result<String> {\n    let mut file = File::open(path)?;\n    let mut string = String::with_capacity(initial_buffer_size(&file));\n    file.read_to_string(&mut string)?;\n    Ok(string)\n}\n\n/// Write a slice as the entire contents of a file.\n///\n/// This function will create a file if it does not exist,\n/// and will entirely replace its contents if it does.\n///\n/// This is a convenience function for using [`File::create`] and [`write_all`]\n/// with fewer imports.\n///\n/// [`File::create`]: struct.File.html#method.create\n/// [`write_all`]: ../io/trait.Write.html#method.write_all\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::write(\"foo.txt\", b\"Lorem ipsum\")?;\n///     fs::write(\"bar.txt\", \"dolor sit\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"fs_read_write_bytes\", since = \"1.26.0\")]\npub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> io::Result<()> {\n    File::create(path)?.write_all(contents.as_ref())\n}\n\nimpl File {\n    /// Attempts to open a file in read-only mode.\n    ///\n    /// See the [`OpenOptions::open`] method for more details.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if `path` does not already exist.\n    /// Other errors may also be returned according to [`OpenOptions::open`].\n    ///\n    /// [`OpenOptions::open`]: struct.OpenOptions.html#method.open\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<File> {\n        OpenOptions::new().read(true).open(path.as_ref())\n    }\n\n    /// Opens a file in write-only mode.\n    ///\n    /// This function will create a file if it does not exist,\n    /// and will truncate it if it does.\n    ///\n    /// See the [`OpenOptions::open`] function for more details.\n    ///\n    /// [`OpenOptions::open`]: struct.OpenOptions.html#method.open\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::create(\"foo.txt\")?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File> {\n        OpenOptions::new().write(true).create(true).truncate(true).open(path.as_ref())\n    }\n\n    /// Attempts to sync all OS-internal metadata to disk.\n    ///\n    /// This function will attempt to ensure that all in-core data reaches the\n    /// filesystem before returning.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::prelude::*;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::create(\"foo.txt\")?;\n    ///     f.write_all(b\"Hello, world!\")?;\n    ///\n    ///     f.sync_all()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn sync_all(&self) -> io::Result<()> {\n        self.inner.fsync()\n    }\n\n    /// This function is similar to [`sync_all`], except that it may not\n    /// synchronize file metadata to the filesystem.\n    ///\n    /// This is intended for use cases that must synchronize content, but don't\n    /// need the metadata on disk. The goal of this method is to reduce disk\n    /// operations.\n    ///\n    /// Note that some platforms may simply implement this in terms of\n    /// [`sync_all`].\n    ///\n    /// [`sync_all`]: struct.File.html#method.sync_all\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::prelude::*;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::create(\"foo.txt\")?;\n    ///     f.write_all(b\"Hello, world!\")?;\n    ///\n    ///     f.sync_data()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn sync_data(&self) -> io::Result<()> {\n        self.inner.datasync()\n    }\n\n    /// Truncates or extends the underlying file, updating the size of\n    /// this file to become `size`.\n    ///\n    /// If the `size` is less than the current file's size, then the file will\n    /// be shrunk. If it is greater than the current file's size, then the file\n    /// will be extended to `size` and have all of the intermediate data filled\n    /// in with 0s.\n    ///\n    /// The file's cursor isn't changed. In particular, if the cursor was at the\n    /// end and the file is shrunk using this operation, the cursor will now be\n    /// past the end.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if the file is not opened for writing.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::create(\"foo.txt\")?;\n    ///     f.set_len(10)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// Note that this method alters the content of the underlying file, even\n    /// though it takes `&self` rather than `&mut self`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set_len(&self, size: u64) -> io::Result<()> {\n        self.inner.truncate(size)\n    }\n\n    /// Queries metadata about the underlying file.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::open(\"foo.txt\")?;\n    ///     let metadata = f.metadata()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn metadata(&self) -> io::Result<Metadata> {\n        self.inner.file_attr().map(Metadata)\n    }\n\n    /// Create a new `File` instance that shares the same underlying file handle\n    /// as the existing `File` instance. Reads, writes, and seeks will affect\n    /// both `File` instances simultaneously.\n    ///\n    /// # Examples\n    ///\n    /// Create two handles for a file named `foo.txt`:\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut file = File::open(\"foo.txt\")?;\n    ///     let file_copy = file.try_clone()?;\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// Assuming there\u2019s a file named `foo.txt` with contents `abcdef\\n`, create\n    /// two handles, seek one of them, and read the remaining bytes from the\n    /// other handle:\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    /// use std::io::SeekFrom;\n    /// use std::io::prelude::*;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut file = File::open(\"foo.txt\")?;\n    ///     let mut file_copy = file.try_clone()?;\n    ///\n    ///     file.seek(SeekFrom::Start(3))?;\n    ///\n    ///     let mut contents = vec![];\n    ///     file_copy.read_to_end(&mut contents)?;\n    ///     assert_eq!(contents, b\"def\\n\");\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"file_try_clone\", since = \"1.9.0\")]\n    pub fn try_clone(&self) -> io::Result<File> {\n        Ok(File {\n            inner: self.inner.duplicate()?\n        })\n    }\n\n    /// Changes the permissions on the underlying file.\n    ///\n    /// # Platform-specific behavior\n    ///\n    /// This function currently corresponds to the `fchmod` function on Unix and\n    /// the `SetFileInformationByHandle` function on Windows. Note that, this\n    /// [may change in the future][changes].\n    ///\n    /// [changes]: ../io/index.html#platform-specific-behavior\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if the user lacks permission change\n    /// attributes on the underlying file. It may also return an error in other\n    /// os-specific unspecified cases.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// fn main() -> std::io::Result<()> {\n    ///     use std::fs::File;\n    ///\n    ///     let file = File::open(\"foo.txt\")?;\n    ///     let mut perms = file.metadata()?.permissions();\n    ///     perms.set_readonly(true);\n    ///     file.set_permissions(perms)?;\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// Note that this method alters the permissions of the underlying file,\n    /// even though it takes `&self` rather than `&mut self`.\n    #[stable(feature = \"set_permissions_atomic\", since = \"1.16.0\")]\n    pub fn set_permissions(&self, perm: Permissions) -> io::Result<()> {\n        self.inner.set_permissions(perm.0)\n    }\n}\n\nimpl AsInner<fs_imp::File> for File {\n    fn as_inner(&self) -> &fs_imp::File { &self.inner }\n}\nimpl FromInner<fs_imp::File> for File {\n    fn from_inner(f: fs_imp::File) -> File {\n        File { inner: f }\n    }\n}\nimpl IntoInner<fs_imp::File> for File {\n    fn into_inner(self) -> fs_imp::File {\n        self.inner\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for File {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.inner.fmt(f)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Read for File {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        self.inner.read(buf)\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Write for File {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.inner.write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Seek for File {\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {\n        self.inner.seek(pos)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Read for &'a File {\n    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {\n        self.inner.read(buf)\n    }\n\n    #[inline]\n    unsafe fn initializer(&self) -> Initializer {\n        Initializer::nop()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Write for &'a File {\n    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {\n        self.inner.write(buf)\n    }\n    fn flush(&mut self) -> io::Result<()> { self.inner.flush() }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> Seek for &'a File {\n    fn seek(&mut self, pos: SeekFrom) -> io::Result<u64> {\n        self.inner.seek(pos)\n    }\n}\n\nimpl OpenOptions {\n    /// Creates a blank new set of options ready for configuration.\n    ///\n    /// All options are initially set to `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let mut options = OpenOptions::new();\n    /// let file = options.read(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> OpenOptions {\n        OpenOptions(fs_imp::OpenOptions::new())\n    }\n\n    /// Sets the option for read access.\n    ///\n    /// This option, when true, will indicate that the file should be\n    /// `read`-able if opened.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().read(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn read(&mut self, read: bool) -> &mut OpenOptions {\n        self.0.read(read); self\n    }\n\n    /// Sets the option for write access.\n    ///\n    /// This option, when true, will indicate that the file should be\n    /// `write`-able if opened.\n    ///\n    /// If the file already exists, any write calls on it will overwrite its\n    /// contents, without truncating it.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().write(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn write(&mut self, write: bool) -> &mut OpenOptions {\n        self.0.write(write); self\n    }\n\n    /// Sets the option for the append mode.\n    ///\n    /// This option, when true, means that writes will append to a file instead\n    /// of overwriting previous contents.\n    /// Note that setting `.write(true).append(true)` has the same effect as\n    /// setting only `.append(true)`.\n    ///\n    /// For most filesystems, the operating system guarantees that all writes are\n    /// atomic: no writes get mangled because another process writes at the same\n    /// time.\n    ///\n    /// One maybe obvious note when using append-mode: make sure that all data\n    /// that belongs together is written to the file in one operation. This\n    /// can be done by concatenating strings before passing them to [`write()`],\n    /// or using a buffered writer (with a buffer of adequate size),\n    /// and calling [`flush()`] when the message is complete.\n    ///\n    /// If a file is opened with both read and append access, beware that after\n    /// opening, and after every write, the position for reading may be set at the\n    /// end of the file. So, before writing, save the current position (using\n    /// [`seek`]`(`[`SeekFrom`]`::`[`Current`]`(0))`), and restore it before the next read.\n    ///\n    /// ## Note\n    ///\n    /// This function doesn't create the file if it doesn't exist. Use the [`create`]\n    /// method to do so.\n    ///\n    /// [`write()`]: ../../std/fs/struct.File.html#method.write\n    /// [`flush()`]: ../../std/fs/struct.File.html#method.flush\n    /// [`seek`]: ../../std/fs/struct.File.html#method.seek\n    /// [`SeekFrom`]: ../../std/io/enum.SeekFrom.html\n    /// [`Current`]: ../../std/io/enum.SeekFrom.html#variant.Current\n    /// [`create`]: #method.create\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().append(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn append(&mut self, append: bool) -> &mut OpenOptions {\n        self.0.append(append); self\n    }\n\n    /// Sets the option for truncating a previous file.\n    ///\n    /// If a file is successfully opened with this option set it will truncate\n    /// the file to 0 length if it already exists.\n    ///\n    /// The file must be opened with write access for truncate to work.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().write(true).truncate(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn truncate(&mut self, truncate: bool) -> &mut OpenOptions {\n        self.0.truncate(truncate); self\n    }\n\n    /// Sets the option for creating a new file.\n    ///\n    /// This option indicates whether a new file will be created if the file\n    /// does not yet already exist.\n    ///\n    /// In order for the file to be created, [`write`] or [`append`] access must\n    /// be used.\n    ///\n    /// [`write`]: #method.write\n    /// [`append`]: #method.append\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().write(true).create(true).open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn create(&mut self, create: bool) -> &mut OpenOptions {\n        self.0.create(create); self\n    }\n\n    /// Sets the option to always create a new file.\n    ///\n    /// This option indicates whether a new file will be created.\n    /// No file is allowed to exist at the target location, also no (dangling)\n    /// symlink.\n    ///\n    /// This option is useful because it is atomic. Otherwise between checking\n    /// whether a file exists and creating a new one, the file may have been\n    /// created by another process (a TOCTOU race condition / attack).\n    ///\n    /// If `.create_new(true)` is set, [`.create()`] and [`.truncate()`] are\n    /// ignored.\n    ///\n    /// The file must be opened with write or append access in order to create\n    /// a new file.\n    ///\n    /// [`.create()`]: #method.create\n    /// [`.truncate()`]: #method.truncate\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().write(true)\n    ///                              .create_new(true)\n    ///                              .open(\"foo.txt\");\n    /// ```\n    #[stable(feature = \"expand_open_options2\", since = \"1.9.0\")]\n    pub fn create_new(&mut self, create_new: bool) -> &mut OpenOptions {\n        self.0.create_new(create_new); self\n    }\n\n    /// Opens a file at `path` with the options specified by `self`.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error under a number of different\n    /// circumstances. Some of these error conditions are listed here, together\n    /// with their [`ErrorKind`]. The mapping to [`ErrorKind`]s is not part of\n    /// the compatibility contract of the function, especially the `Other` kind\n    /// might change to more specific kinds in the future.\n    ///\n    /// * [`NotFound`]: The specified file does not exist and neither `create`\n    ///   or `create_new` is set.\n    /// * [`NotFound`]: One of the directory components of the file path does\n    ///   not exist.\n    /// * [`PermissionDenied`]: The user lacks permission to get the specified\n    ///   access rights for the file.\n    /// * [`PermissionDenied`]: The user lacks permission to open one of the\n    ///   directory components of the specified path.\n    /// * [`AlreadyExists`]: `create_new` was specified and the file already\n    ///   exists.\n    /// * [`InvalidInput`]: Invalid combinations of open options (truncate\n    ///   without write access, no access mode set, etc.).\n    /// * [`Other`]: One of the directory components of the specified file path\n    ///   was not, in fact, a directory.\n    /// * [`Other`]: Filesystem-level errors: full disk, write permission\n    ///   requested on a read-only file system, exceeded disk quota, too many\n    ///   open files, too long filename, too many symbolic links in the\n    ///   specified path (Unix-like systems only), etc.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::OpenOptions;\n    ///\n    /// let file = OpenOptions::new().open(\"foo.txt\");\n    /// ```\n    ///\n    /// [`ErrorKind`]: ../io/enum.ErrorKind.html\n    /// [`AlreadyExists`]: ../io/enum.ErrorKind.html#variant.AlreadyExists\n    /// [`InvalidInput`]: ../io/enum.ErrorKind.html#variant.InvalidInput\n    /// [`NotFound`]: ../io/enum.ErrorKind.html#variant.NotFound\n    /// [`Other`]: ../io/enum.ErrorKind.html#variant.Other\n    /// [`PermissionDenied`]: ../io/enum.ErrorKind.html#variant.PermissionDenied\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn open<P: AsRef<Path>>(&self, path: P) -> io::Result<File> {\n        self._open(path.as_ref())\n    }\n\n    fn _open(&self, path: &Path) -> io::Result<File> {\n        let inner = fs_imp::File::open(path, &self.0)?;\n        Ok(File { inner })\n    }\n}\n\nimpl AsInnerMut<fs_imp::OpenOptions> for OpenOptions {\n    fn as_inner_mut(&mut self) -> &mut fs_imp::OpenOptions { &mut self.0 }\n}\n\nimpl Metadata {\n    /// Returns the file type for this metadata.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// fn main() -> std::io::Result<()> {\n    ///     use std::fs;\n    ///\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     println!(\"{:?}\", metadata.file_type());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"file_type\", since = \"1.1.0\")]\n    pub fn file_type(&self) -> FileType {\n        FileType(self.0.file_type())\n    }\n\n    /// Returns whether this metadata is for a directory. The\n    /// result is mutually exclusive to the result of\n    /// [`is_file`], and will be false for symlink metadata\n    /// obtained from [`symlink_metadata`].\n    ///\n    /// [`is_file`]: struct.Metadata.html#method.is_file\n    /// [`symlink_metadata`]: fn.symlink_metadata.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// fn main() -> std::io::Result<()> {\n    ///     use std::fs;\n    ///\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     assert!(!metadata.is_dir());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_dir(&self) -> bool { self.file_type().is_dir() }\n\n    /// Returns whether this metadata is for a regular file. The\n    /// result is mutually exclusive to the result of\n    /// [`is_dir`], and will be false for symlink metadata\n    /// obtained from [`symlink_metadata`].\n    ///\n    /// [`is_dir`]: struct.Metadata.html#method.is_dir\n    /// [`symlink_metadata`]: fn.symlink_metadata.html\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     assert!(metadata.is_file());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_file(&self) -> bool { self.file_type().is_file() }\n\n    /// Returns the size of the file, in bytes, this metadata is for.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     assert_eq!(0, metadata.len());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn len(&self) -> u64 { self.0.size() }\n\n    /// Returns the permissions of the file this metadata is for.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     assert!(!metadata.permissions().readonly());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn permissions(&self) -> Permissions {\n        Permissions(self.0.perm())\n    }\n\n    /// Returns the last modification time listed in this metadata.\n    ///\n    /// The returned value corresponds to the `mtime` field of `stat` on Unix\n    /// platforms and the `ftLastWriteTime` field on Windows platforms.\n    ///\n    /// # Errors\n    ///\n    /// This field may not be available on all platforms, and will return an\n    /// `Err` on platforms where it is not available.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     if let Ok(time) = metadata.modified() {\n    ///         println!(\"{:?}\", time);\n    ///     } else {\n    ///         println!(\"Not supported on this platform\");\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"fs_time\", since = \"1.10.0\")]\n    pub fn modified(&self) -> io::Result<SystemTime> {\n        self.0.modified().map(FromInner::from_inner)\n    }\n\n    /// Returns the last access time of this metadata.\n    ///\n    /// The returned value corresponds to the `atime` field of `stat` on Unix\n    /// platforms and the `ftLastAccessTime` field on Windows platforms.\n    ///\n    /// Note that not all platforms will keep this field update in a file's\n    /// metadata, for example Windows has an option to disable updating this\n    /// time when files are accessed and Linux similarly has `noatime`.\n    ///\n    /// # Errors\n    ///\n    /// This field may not be available on all platforms, and will return an\n    /// `Err` on platforms where it is not available.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     if let Ok(time) = metadata.accessed() {\n    ///         println!(\"{:?}\", time);\n    ///     } else {\n    ///         println!(\"Not supported on this platform\");\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"fs_time\", since = \"1.10.0\")]\n    pub fn accessed(&self) -> io::Result<SystemTime> {\n        self.0.accessed().map(FromInner::from_inner)\n    }\n\n    /// Returns the creation time listed in this metadata.\n    ///\n    /// The returned value corresponds to the `birthtime` field of `stat` on\n    /// Unix platforms and the `ftCreationTime` field on Windows platforms.\n    ///\n    /// # Errors\n    ///\n    /// This field may not be available on all platforms, and will return an\n    /// `Err` on platforms where it is not available.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///\n    ///     if let Ok(time) = metadata.created() {\n    ///         println!(\"{:?}\", time);\n    ///     } else {\n    ///         println!(\"Not supported on this platform\");\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"fs_time\", since = \"1.10.0\")]\n    pub fn created(&self) -> io::Result<SystemTime> {\n        self.0.created().map(FromInner::from_inner)\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Metadata {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Metadata\")\n            .field(\"file_type\", &self.file_type())\n            .field(\"is_dir\", &self.is_dir())\n            .field(\"is_file\", &self.is_file())\n            .field(\"permissions\", &self.permissions())\n            .field(\"modified\", &self.modified())\n            .field(\"accessed\", &self.accessed())\n            .field(\"created\", &self.created())\n            .finish()\n    }\n}\n\nimpl AsInner<fs_imp::FileAttr> for Metadata {\n    fn as_inner(&self) -> &fs_imp::FileAttr { &self.0 }\n}\n\nimpl Permissions {\n    /// Returns whether these permissions describe a readonly (unwritable) file.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let mut f = File::create(\"foo.txt\")?;\n    ///     let metadata = f.metadata()?;\n    ///\n    ///     assert_eq!(false, metadata.permissions().readonly());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn readonly(&self) -> bool { self.0.readonly() }\n\n    /// Modifies the readonly flag for this set of permissions. If the\n    /// `readonly` argument is `true`, using the resulting `Permission` will\n    /// update file permissions to forbid writing. Conversely, if it's `false`,\n    /// using the resulting `Permission` will update file permissions to allow\n    /// writing.\n    ///\n    /// This operation does **not** modify the filesystem. To modify the\n    /// filesystem use the `fs::set_permissions` function.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::File;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let f = File::create(\"foo.txt\")?;\n    ///     let metadata = f.metadata()?;\n    ///     let mut permissions = metadata.permissions();\n    ///\n    ///     permissions.set_readonly(true);\n    ///\n    ///     // filesystem doesn't change\n    ///     assert_eq!(false, metadata.permissions().readonly());\n    ///\n    ///     // just this particular `permissions`.\n    ///     assert_eq!(true, permissions.readonly());\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn set_readonly(&mut self, readonly: bool) {\n        self.0.set_readonly(readonly)\n    }\n}\n\nimpl FileType {\n    /// Test whether this file type represents a directory. The\n    /// result is mutually exclusive to the results of\n    /// [`is_file`] and [`is_symlink`]; only zero or one of these\n    /// tests may pass.\n    ///\n    /// [`is_file`]: struct.FileType.html#method.is_file\n    /// [`is_symlink`]: struct.FileType.html#method.is_symlink\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// fn main() -> std::io::Result<()> {\n    ///     use std::fs;\n    ///\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///     let file_type = metadata.file_type();\n    ///\n    ///     assert_eq!(file_type.is_dir(), false);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"file_type\", since = \"1.1.0\")]\n    pub fn is_dir(&self) -> bool { self.0.is_dir() }\n\n    /// Test whether this file type represents a regular file.\n    /// The result is  mutually exclusive to the results of\n    /// [`is_dir`] and [`is_symlink`]; only zero or one of these\n    /// tests may pass.\n    ///\n    /// [`is_dir`]: struct.FileType.html#method.is_dir\n    /// [`is_symlink`]: struct.FileType.html#method.is_symlink\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// fn main() -> std::io::Result<()> {\n    ///     use std::fs;\n    ///\n    ///     let metadata = fs::metadata(\"foo.txt\")?;\n    ///     let file_type = metadata.file_type();\n    ///\n    ///     assert_eq!(file_type.is_file(), true);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"file_type\", since = \"1.1.0\")]\n    pub fn is_file(&self) -> bool { self.0.is_file() }\n\n    /// Test whether this file type represents a symbolic link.\n    /// The result is mutually exclusive to the results of\n    /// [`is_dir`] and [`is_file`]; only zero or one of these\n    /// tests may pass.\n    ///\n    /// The underlying [`Metadata`] struct needs to be retrieved\n    /// with the [`fs::symlink_metadata`] function and not the\n    /// [`fs::metadata`] function. The [`fs::metadata`] function\n    /// follows symbolic links, so [`is_symlink`] would always\n    /// return false for the target file.\n    ///\n    /// [`Metadata`]: struct.Metadata.html\n    /// [`fs::metadata`]: fn.metadata.html\n    /// [`fs::symlink_metadata`]: fn.symlink_metadata.html\n    /// [`is_dir`]: struct.FileType.html#method.is_dir\n    /// [`is_file`]: struct.FileType.html#method.is_file\n    /// [`is_symlink`]: struct.FileType.html#method.is_symlink\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     let metadata = fs::symlink_metadata(\"foo.txt\")?;\n    ///     let file_type = metadata.file_type();\n    ///\n    ///     assert_eq!(file_type.is_symlink(), false);\n    ///     Ok(())\n    /// }\n    /// ```\n    #[stable(feature = \"file_type\", since = \"1.1.0\")]\n    pub fn is_symlink(&self) -> bool { self.0.is_symlink() }\n}\n\nimpl AsInner<fs_imp::FileType> for FileType {\n    fn as_inner(&self) -> &fs_imp::FileType { &self.0 }\n}\n\nimpl FromInner<fs_imp::FilePermissions> for Permissions {\n    fn from_inner(f: fs_imp::FilePermissions) -> Permissions {\n        Permissions(f)\n    }\n}\n\nimpl AsInner<fs_imp::FilePermissions> for Permissions {\n    fn as_inner(&self) -> &fs_imp::FilePermissions { &self.0 }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for ReadDir {\n    type Item = io::Result<DirEntry>;\n\n    fn next(&mut self) -> Option<io::Result<DirEntry>> {\n        self.0.next().map(|entry| entry.map(DirEntry))\n    }\n}\n\nimpl DirEntry {\n    /// Returns the full path to the file that this entry represents.\n    ///\n    /// The full path is created by joining the original path to `read_dir`\n    /// with the filename of this entry.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs;\n    ///\n    /// fn main() -> std::io::Result<()> {\n    ///     for entry in fs::read_dir(\".\")? {\n    ///         let dir = entry?;\n    ///         println!(\"{:?}\", dir.path());\n    ///     }\n    ///     Ok(())\n    /// }\n    /// ```\n    ///\n    /// This prints output like:\n    ///\n    /// ```text\n    /// \"./whatever.txt\"\n    /// \"./foo.html\"\n    /// \"./hello_world.rs\"\n    /// ```\n    ///\n    /// The exact text, of course, depends on what files you have in `.`.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn path(&self) -> PathBuf { self.0.path() }\n\n    /// Return the metadata for the file that this entry points at.\n    ///\n    /// This function will not traverse symlinks if this entry points at a\n    /// symlink.\n    ///\n    /// # Platform-specific behavior\n    ///\n    /// On Windows this function is cheap to call (no extra system calls\n    /// needed), but on Unix platforms this function is the equivalent of\n    /// calling `symlink_metadata` on the path.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs;\n    ///\n    /// if let Ok(entries) = fs::read_dir(\".\") {\n    ///     for entry in entries {\n    ///         if let Ok(entry) = entry {\n    ///             // Here, `entry` is a `DirEntry`.\n    ///             if let Ok(metadata) = entry.metadata() {\n    ///                 // Now let's show our entry's permissions!\n    ///                 println!(\"{:?}: {:?}\", entry.path(), metadata.permissions());\n    ///             } else {\n    ///                 println!(\"Couldn't get metadata for {:?}\", entry.path());\n    ///             }\n    ///         }\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"dir_entry_ext\", since = \"1.1.0\")]\n    pub fn metadata(&self) -> io::Result<Metadata> {\n        self.0.metadata().map(Metadata)\n    }\n\n    /// Return the file type for the file that this entry points at.\n    ///\n    /// This function will not traverse symlinks if this entry points at a\n    /// symlink.\n    ///\n    /// # Platform-specific behavior\n    ///\n    /// On Windows and most Unix platforms this function is free (no extra\n    /// system calls needed), but some Unix platforms may require the equivalent\n    /// call to `symlink_metadata` to learn about the target file type.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs;\n    ///\n    /// if let Ok(entries) = fs::read_dir(\".\") {\n    ///     for entry in entries {\n    ///         if let Ok(entry) = entry {\n    ///             // Here, `entry` is a `DirEntry`.\n    ///             if let Ok(file_type) = entry.file_type() {\n    ///                 // Now let's show our entry's file type!\n    ///                 println!(\"{:?}: {:?}\", entry.path(), file_type);\n    ///             } else {\n    ///                 println!(\"Couldn't get file type for {:?}\", entry.path());\n    ///             }\n    ///         }\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"dir_entry_ext\", since = \"1.1.0\")]\n    pub fn file_type(&self) -> io::Result<FileType> {\n        self.0.file_type().map(FileType)\n    }\n\n    /// Returns the bare file name of this directory entry without any other\n    /// leading path component.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs;\n    ///\n    /// if let Ok(entries) = fs::read_dir(\".\") {\n    ///     for entry in entries {\n    ///         if let Ok(entry) = entry {\n    ///             // Here, `entry` is a `DirEntry`.\n    ///             println!(\"{:?}\", entry.file_name());\n    ///         }\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"dir_entry_ext\", since = \"1.1.0\")]\n    pub fn file_name(&self) -> OsString {\n        self.0.file_name()\n    }\n}\n\n#[stable(feature = \"dir_entry_debug\", since = \"1.13.0\")]\nimpl fmt::Debug for DirEntry {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"DirEntry\")\n            .field(&self.path())\n            .finish()\n    }\n}\n\nimpl AsInner<fs_imp::DirEntry> for DirEntry {\n    fn as_inner(&self) -> &fs_imp::DirEntry { &self.0 }\n}\n\n/// Removes a file from the filesystem.\n///\n/// Note that there is no\n/// guarantee that the file is immediately deleted (e.g. depending on\n/// platform, other open file descriptors may prevent immediate removal).\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `unlink` function on Unix\n/// and the `DeleteFile` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * `path` points to a directory.\n/// * The user lacks permissions to remove the file.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::remove_file(\"a.txt\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    fs_imp::unlink(path.as_ref())\n}\n\n/// Given a path, query the file system to get information about a file,\n/// directory, etc.\n///\n/// This function will traverse symbolic links to query information about the\n/// destination file.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `stat` function on Unix\n/// and the `GetFileAttributesEx` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The user lacks permissions to perform `metadata` call on `path`.\n/// * `path` does not exist.\n///\n/// # Examples\n///\n/// ```rust,no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     let attr = fs::metadata(\"/some/file/path.txt\")?;\n///     // inspect attr ...\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {\n    fs_imp::stat(path.as_ref()).map(Metadata)\n}\n\n/// Query the metadata about a file without following symlinks.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `lstat` function on Unix\n/// and the `GetFileAttributesEx` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The user lacks permissions to perform `metadata` call on `path`.\n/// * `path` does not exist.\n///\n/// # Examples\n///\n/// ```rust,no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     let attr = fs::symlink_metadata(\"/some/file/path.txt\")?;\n///     // inspect attr ...\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"symlink_metadata\", since = \"1.1.0\")]\npub fn symlink_metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {\n    fs_imp::lstat(path.as_ref()).map(Metadata)\n}\n\n/// Rename a file or directory to a new name, replacing the original file if\n/// `to` already exists.\n///\n/// This will not work if the new name is on a different mount point.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `rename` function on Unix\n/// and the `MoveFileEx` function with the `MOVEFILE_REPLACE_EXISTING` flag on Windows.\n///\n/// Because of this, the behavior when both `from` and `to` exist differs. On\n/// Unix, if `from` is a directory, `to` must also be an (empty) directory. If\n/// `from` is not a directory, `to` must also be not a directory. In contrast,\n/// on Windows, `from` can be anything, but `to` must *not* be a directory.\n///\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * `from` does not exist.\n/// * The user lacks permissions to view contents.\n/// * `from` and `to` are on separate filesystems.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::rename(\"a.txt\", \"b.txt\")?; // Rename a.txt to b.txt\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<()> {\n    fs_imp::rename(from.as_ref(), to.as_ref())\n}\n\n/// Copies the contents of one file to another. This function will also\n/// copy the permission bits of the original file to the destination file.\n///\n/// This function will **overwrite** the contents of `to`.\n///\n/// Note that if `from` and `to` both point to the same file, then the file\n/// will likely get truncated by this operation.\n///\n/// On success, the total number of bytes copied is returned and it is equal to\n/// the length of the `to` file as reported by `metadata`.\n///\n/// If you\u2019re wanting to copy the contents of one file to another and you\u2019re\n/// working with [`File`]s, see the [`io::copy`] function.\n///\n/// [`io::copy`]: ../io/fn.copy.html\n/// [`File`]: ./struct.File.html\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `open` function in Unix\n/// with `O_RDONLY` for `from` and `O_WRONLY`, `O_CREAT`, and `O_TRUNC` for `to`.\n/// `O_CLOEXEC` is set for returned file descriptors.\n/// On Windows, this function currently corresponds to `CopyFileEx`. Alternate\n/// NTFS streams are copied but only the size of the main stream is returned by\n/// this function.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The `from` path is not a file.\n/// * The `from` file does not exist.\n/// * The current process does not have the permission rights to access\n///   `from` or write `to`.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::copy(\"foo.txt\", \"bar.txt\")?;  // Copy foo.txt to bar.txt\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {\n    fs_imp::copy(from.as_ref(), to.as_ref())\n}\n\n/// Creates a new hard link on the filesystem.\n///\n/// The `dst` path will be a link pointing to the `src` path. Note that systems\n/// often require these two paths to both be located on the same filesystem.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `link` function on Unix\n/// and the `CreateHardLink` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The `src` path is not a file or doesn't exist.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::hard_link(\"a.txt\", \"b.txt\")?; // Hard link a.txt to b.txt\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> {\n    fs_imp::link(src.as_ref(), dst.as_ref())\n}\n\n/// Creates a new symbolic link on the filesystem.\n///\n/// The `dst` path will be a symbolic link pointing to the `src` path.\n/// On Windows, this will be a file symlink, not a directory symlink;\n/// for this reason, the platform-specific `std::os::unix::fs::symlink`\n/// and `std::os::windows::fs::{symlink_file, symlink_dir}` should be\n/// used instead to make the intent explicit.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::soft_link(\"a.txt\", \"b.txt\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_deprecated(since = \"1.1.0\",\n             reason = \"replaced with std::os::unix::fs::symlink and \\\n                       std::os::windows::fs::{symlink_file, symlink_dir}\")]\npub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()> {\n    fs_imp::symlink(src.as_ref(), dst.as_ref())\n}\n\n/// Reads a symbolic link, returning the file that the link points to.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `readlink` function on Unix\n/// and the `CreateFile` function with `FILE_FLAG_OPEN_REPARSE_POINT` and\n/// `FILE_FLAG_BACKUP_SEMANTICS` flags on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * `path` is not a symbolic link.\n/// * `path` does not exist.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     let path = fs::read_link(\"a.txt\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn read_link<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {\n    fs_imp::readlink(path.as_ref())\n}\n\n/// Returns the canonical, absolute form of a path with all intermediate\n/// components normalized and symbolic links resolved.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `realpath` function on Unix\n/// and the `CreateFile` and `GetFinalPathNameByHandle` functions on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// On Windows, this converts the path to use [extended length path][path]\n/// syntax, which allows your program to use longer path names, but means you\n/// can only join backslash-delimited paths to it, and it may be incompatible\n/// with other applications (if passed to the application on the command-line,\n/// or written to a file another application may read).\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n/// [path]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx#maxpath\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * `path` does not exist.\n/// * A component in path is not a directory.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     let path = fs::canonicalize(\"../a/../foo.txt\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"fs_canonicalize\", since = \"1.5.0\")]\npub fn canonicalize<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {\n    fs_imp::canonicalize(path.as_ref())\n}\n\n/// Creates a new, empty directory at the provided path\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `mkdir` function on Unix\n/// and the `CreateDirectory` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// **NOTE**: If a parent of the given path doesn't exist, this function will\n/// return an error. To create a directory and all its missing parents at the\n/// same time, use the [`create_dir_all`] function.\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * User lacks permissions to create directory at `path`.\n/// * A parent of the given path doesn't exist. (To create a directory and all\n///   its missing parents at the same time, use the [`create_dir_all`]\n///   function.)\n/// * `path` already exists.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::create_dir(\"/some/dir\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn create_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    DirBuilder::new().create(path.as_ref())\n}\n\n/// Recursively create a directory and all of its parent components if they\n/// are missing.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `mkdir` function on Unix\n/// and the `CreateDirectory` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * If any directory in the path specified by `path`\n/// does not already exist and it could not be created otherwise. The specific\n/// error conditions for when a directory is being created (after it is\n/// determined to not exist) are outlined by `fs::create_dir`.\n///\n/// Notable exception is made for situations where any of the directories\n/// specified in the `path` could not be created as it was being created concurrently.\n/// Such cases are considered to be successful. That is, calling `create_dir_all`\n/// concurrently from multiple threads or processes is guaranteed not to fail\n/// due to a race condition with itself.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::create_dir_all(\"/some/dir\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn create_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    DirBuilder::new().recursive(true).create(path.as_ref())\n}\n\n/// Removes an existing, empty directory.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `rmdir` function on Unix\n/// and the `RemoveDirectory` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The user lacks permissions to remove the directory at the provided `path`.\n/// * The directory isn't empty.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::remove_dir(\"/some/dir\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    fs_imp::rmdir(path.as_ref())\n}\n\n/// Removes a directory at this path, after removing all its contents. Use\n/// carefully!\n///\n/// This function does **not** follow symbolic links and it will simply remove the\n/// symbolic link itself.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to `opendir`, `lstat`, `rm` and `rmdir` functions on Unix\n/// and the `FindFirstFile`, `GetFileAttributesEx`, `DeleteFile`, and `RemoveDirectory` functions\n/// on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// See `file::remove_file` and `fs::remove_dir`.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     fs::remove_dir_all(\"/some/dir\")?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    fs_imp::remove_dir_all(path.as_ref())\n}\n\n/// Returns an iterator over the entries within a directory.\n///\n/// The iterator will yield instances of [`io::Result`]`<`[`DirEntry`]`>`.\n/// New errors may be encountered after an iterator is initially constructed.\n///\n/// [`io::Result`]: ../io/type.Result.html\n/// [`DirEntry`]: struct.DirEntry.html\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `opendir` function on Unix\n/// and the `FindFirstFile` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * The provided `path` doesn't exist.\n/// * The process lacks permissions to view the contents.\n/// * The `path` points at a non-directory file.\n///\n/// # Examples\n///\n/// ```\n/// use std::io;\n/// use std::fs::{self, DirEntry};\n/// use std::path::Path;\n///\n/// // one possible implementation of walking a directory only visiting files\n/// fn visit_dirs(dir: &Path, cb: &Fn(&DirEntry)) -> io::Result<()> {\n///     if dir.is_dir() {\n///         for entry in fs::read_dir(dir)? {\n///             let entry = entry?;\n///             let path = entry.path();\n///             if path.is_dir() {\n///                 visit_dirs(&path, cb)?;\n///             } else {\n///                 cb(&entry);\n///             }\n///         }\n///     }\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> {\n    fs_imp::readdir(path.as_ref()).map(ReadDir)\n}\n\n/// Changes the permissions found on a file or a directory.\n///\n/// # Platform-specific behavior\n///\n/// This function currently corresponds to the `chmod` function on Unix\n/// and the `SetFileAttributes` function on Windows.\n/// Note that, this [may change in the future][changes].\n///\n/// [changes]: ../io/index.html#platform-specific-behavior\n///\n/// # Errors\n///\n/// This function will return an error in the following situations, but is not\n/// limited to just these cases:\n///\n/// * `path` does not exist.\n/// * The user lacks the permission to change attributes of the file.\n///\n/// # Examples\n///\n/// ```no_run\n/// use std::fs;\n///\n/// fn main() -> std::io::Result<()> {\n///     let mut perms = fs::metadata(\"foo.txt\")?.permissions();\n///     perms.set_readonly(true);\n///     fs::set_permissions(\"foo.txt\", perms)?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"set_permissions\", since = \"1.1.0\")]\npub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions)\n                                       -> io::Result<()> {\n    fs_imp::set_perm(path.as_ref(), perm.0)\n}\n\nimpl DirBuilder {\n    /// Creates a new set of options with default mode/security settings for all\n    /// platforms and also non-recursive.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs::DirBuilder;\n    ///\n    /// let builder = DirBuilder::new();\n    /// ```\n    #[stable(feature = \"dir_builder\", since = \"1.6.0\")]\n    pub fn new() -> DirBuilder {\n        DirBuilder {\n            inner: fs_imp::DirBuilder::new(),\n            recursive: false,\n        }\n    }\n\n    /// Indicates that directories should be created recursively, creating all\n    /// parent directories. Parents that do not exist are created with the same\n    /// security and permissions settings.\n    ///\n    /// This option defaults to `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::fs::DirBuilder;\n    ///\n    /// let mut builder = DirBuilder::new();\n    /// builder.recursive(true);\n    /// ```\n    #[stable(feature = \"dir_builder\", since = \"1.6.0\")]\n    pub fn recursive(&mut self, recursive: bool) -> &mut Self {\n        self.recursive = recursive;\n        self\n    }\n\n    /// Create the specified directory with the options configured in this\n    /// builder.\n    ///\n    /// It is considered an error if the directory already exists unless\n    /// recursive mode is enabled.\n    ///\n    /// # Examples\n    ///\n    /// ```no_run\n    /// use std::fs::{self, DirBuilder};\n    ///\n    /// let path = \"/tmp/foo/bar/baz\";\n    /// DirBuilder::new()\n    ///     .recursive(true)\n    ///     .create(path).unwrap();\n    ///\n    /// assert!(fs::metadata(path).unwrap().is_dir());\n    /// ```\n    #[stable(feature = \"dir_builder\", since = \"1.6.0\")]\n    pub fn create<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {\n        self._create(path.as_ref())\n    }\n\n    fn _create(&self, path: &Path) -> io::Result<()> {\n        if self.recursive {\n            self.create_dir_all(path)\n        } else {\n            self.inner.mkdir(path)\n        }\n    }\n\n    fn create_dir_all(&self, path: &Path) -> io::Result<()> {\n        if path == Path::new(\"\") {\n            return Ok(())\n        }\n\n        match self.inner.mkdir(path) {\n            Ok(()) => return Ok(()),\n            Err(ref e) if e.kind() == io::ErrorKind::NotFound => {}\n            Err(_) if path.is_dir() => return Ok(()),\n            Err(e) => return Err(e),\n        }\n        match path.parent() {\n            Some(p) => try!(self.create_dir_all(p)),\n            None => return Err(io::Error::new(io::ErrorKind::Other, \"failed to create whole tree\")),\n        }\n        match self.inner.mkdir(path) {\n            Ok(()) => Ok(()),\n            Err(_) if path.is_dir() => Ok(()),\n            Err(e) => Err(e),\n        }\n    }\n}\n\nimpl AsInnerMut<fs_imp::DirBuilder> for DirBuilder {\n    fn as_inner_mut(&mut self) -> &mut fs_imp::DirBuilder {\n        &mut self.inner\n    }\n}\n\n#[cfg(all(test, not(any(target_os = \"cloudabi\", target_os = \"emscripten\"))))]\nmod tests {\n    use io::prelude::*;\n\n    use fs::{self, File, OpenOptions};\n    use io::{ErrorKind, SeekFrom};\n    use path::Path;\n    use rand::{StdRng, FromEntropy, RngCore};\n    use str;\n    use sys_common::io::test::{TempDir, tmpdir};\n    use thread;\n\n    #[cfg(windows)]\n    use os::windows::fs::{symlink_dir, symlink_file};\n    #[cfg(windows)]\n    use sys::fs::symlink_junction;\n    #[cfg(unix)]\n    use os::unix::fs::symlink as symlink_dir;\n    #[cfg(unix)]\n    use os::unix::fs::symlink as symlink_file;\n    #[cfg(unix)]\n    use os::unix::fs::symlink as symlink_junction;\n\n    macro_rules! check { ($e:expr) => (\n        match $e {\n            Ok(t) => t,\n            Err(e) => panic!(\"{} failed with: {}\", stringify!($e), e),\n        }\n    ) }\n\n    #[cfg(windows)]\n    macro_rules! error { ($e:expr, $s:expr) => (\n        match $e {\n            Ok(_) => panic!(\"Unexpected success. Should've been: {:?}\", $s),\n            Err(ref err) => assert!(err.raw_os_error() == Some($s),\n                                    format!(\"`{}` did not have a code of `{}`\", err, $s))\n        }\n    ) }\n\n    #[cfg(unix)]\n    macro_rules! error { ($e:expr, $s:expr) => ( error_contains!($e, $s) ) }\n\n    macro_rules! error_contains { ($e:expr, $s:expr) => (\n        match $e {\n            Ok(_) => panic!(\"Unexpected success. Should've been: {:?}\", $s),\n            Err(ref err) => assert!(err.to_string().contains($s),\n                                    format!(\"`{}` did not contain `{}`\", err, $s))\n        }\n    ) }\n\n    // Several test fail on windows if the user does not have permission to\n    // create symlinks (the `SeCreateSymbolicLinkPrivilege`). Instead of\n    // disabling these test on Windows, use this function to test whether we\n    // have permission, and return otherwise. This way, we still don't run these\n    // tests most of the time, but at least we do if the user has the right\n    // permissions.\n    pub fn got_symlink_permission(tmpdir: &TempDir) -> bool {\n        if cfg!(unix) { return true }\n        let link = tmpdir.join(\"some_hopefully_unique_link_name\");\n\n        match symlink_file(r\"nonexisting_target\", link) {\n            Ok(_) => true,\n            // ERROR_PRIVILEGE_NOT_HELD = 1314\n            Err(ref err) if err.raw_os_error() == Some(1314) => false,\n            Err(_) => true,\n        }\n    }\n\n    #[test]\n    fn file_test_io_smoke_test() {\n        let message = \"it's alright. have a good time\";\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_rt_io_file_test.txt\");\n        {\n            let mut write_stream = check!(File::create(filename));\n            check!(write_stream.write(message.as_bytes()));\n        }\n        {\n            let mut read_stream = check!(File::open(filename));\n            let mut read_buf = [0; 1028];\n            let read_str = match check!(read_stream.read(&mut read_buf)) {\n                0 => panic!(\"shouldn't happen\"),\n                n => str::from_utf8(&read_buf[..n]).unwrap().to_string()\n            };\n            assert_eq!(read_str, message);\n        }\n        check!(fs::remove_file(filename));\n    }\n\n    #[test]\n    fn invalid_path_raises() {\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_that_does_not_exist.txt\");\n        let result = File::open(filename);\n\n        #[cfg(unix)]\n        error!(result, \"No such file or directory\");\n        #[cfg(windows)]\n        error!(result, 2); // ERROR_FILE_NOT_FOUND\n    }\n\n    #[test]\n    fn file_test_iounlinking_invalid_path_should_raise_condition() {\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_another_file_that_does_not_exist.txt\");\n\n        let result = fs::remove_file(filename);\n\n        #[cfg(unix)]\n        error!(result, \"No such file or directory\");\n        #[cfg(windows)]\n        error!(result, 2); // ERROR_FILE_NOT_FOUND\n    }\n\n    #[test]\n    fn file_test_io_non_positional_read() {\n        let message: &str = \"ten-four\";\n        let mut read_mem = [0; 8];\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_rt_io_file_test_positional.txt\");\n        {\n            let mut rw_stream = check!(File::create(filename));\n            check!(rw_stream.write(message.as_bytes()));\n        }\n        {\n            let mut read_stream = check!(File::open(filename));\n            {\n                let read_buf = &mut read_mem[0..4];\n                check!(read_stream.read(read_buf));\n            }\n            {\n                let read_buf = &mut read_mem[4..8];\n                check!(read_stream.read(read_buf));\n            }\n        }\n        check!(fs::remove_file(filename));\n        let read_str = str::from_utf8(&read_mem).unwrap();\n        assert_eq!(read_str, message);\n    }\n\n    #[test]\n    fn file_test_io_seek_and_tell_smoke_test() {\n        let message = \"ten-four\";\n        let mut read_mem = [0; 4];\n        let set_cursor = 4 as u64;\n        let tell_pos_pre_read;\n        let tell_pos_post_read;\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_rt_io_file_test_seeking.txt\");\n        {\n            let mut rw_stream = check!(File::create(filename));\n            check!(rw_stream.write(message.as_bytes()));\n        }\n        {\n            let mut read_stream = check!(File::open(filename));\n            check!(read_stream.seek(SeekFrom::Start(set_cursor)));\n            tell_pos_pre_read = check!(read_stream.seek(SeekFrom::Current(0)));\n            check!(read_stream.read(&mut read_mem));\n            tell_pos_post_read = check!(read_stream.seek(SeekFrom::Current(0)));\n        }\n        check!(fs::remove_file(filename));\n        let read_str = str::from_utf8(&read_mem).unwrap();\n        assert_eq!(read_str, &message[4..8]);\n        assert_eq!(tell_pos_pre_read, set_cursor);\n        assert_eq!(tell_pos_post_read, message.len() as u64);\n    }\n\n    #[test]\n    fn file_test_io_seek_and_write() {\n        let initial_msg =   \"food-is-yummy\";\n        let overwrite_msg =    \"-the-bar!!\";\n        let final_msg =     \"foo-the-bar!!\";\n        let seek_idx = 3;\n        let mut read_mem = [0; 13];\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_rt_io_file_test_seek_and_write.txt\");\n        {\n            let mut rw_stream = check!(File::create(filename));\n            check!(rw_stream.write(initial_msg.as_bytes()));\n            check!(rw_stream.seek(SeekFrom::Start(seek_idx)));\n            check!(rw_stream.write(overwrite_msg.as_bytes()));\n        }\n        {\n            let mut read_stream = check!(File::open(filename));\n            check!(read_stream.read(&mut read_mem));\n        }\n        check!(fs::remove_file(filename));\n        let read_str = str::from_utf8(&read_mem).unwrap();\n        assert!(read_str == final_msg);\n    }\n\n    #[test]\n    fn file_test_io_seek_shakedown() {\n        //                   01234567890123\n        let initial_msg =   \"qwer-asdf-zxcv\";\n        let chunk_one: &str = \"qwer\";\n        let chunk_two: &str = \"asdf\";\n        let chunk_three: &str = \"zxcv\";\n        let mut read_mem = [0; 4];\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_rt_io_file_test_seek_shakedown.txt\");\n        {\n            let mut rw_stream = check!(File::create(filename));\n            check!(rw_stream.write(initial_msg.as_bytes()));\n        }\n        {\n            let mut read_stream = check!(File::open(filename));\n\n            check!(read_stream.seek(SeekFrom::End(-4)));\n            check!(read_stream.read(&mut read_mem));\n            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_three);\n\n            check!(read_stream.seek(SeekFrom::Current(-9)));\n            check!(read_stream.read(&mut read_mem));\n            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_two);\n\n            check!(read_stream.seek(SeekFrom::Start(0)));\n            check!(read_stream.read(&mut read_mem));\n            assert_eq!(str::from_utf8(&read_mem).unwrap(), chunk_one);\n        }\n        check!(fs::remove_file(filename));\n    }\n\n    #[test]\n    fn file_test_io_eof() {\n        let tmpdir = tmpdir();\n        let filename = tmpdir.join(\"file_rt_io_file_test_eof.txt\");\n        let mut buf = [0; 256];\n        {\n            let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();\n            let mut rw = check!(oo.open(&filename));\n            assert_eq!(check!(rw.read(&mut buf)), 0);\n            assert_eq!(check!(rw.read(&mut buf)), 0);\n        }\n        check!(fs::remove_file(&filename));\n    }\n\n    #[test]\n    #[cfg(unix)]\n    fn file_test_io_read_write_at() {\n        use os::unix::fs::FileExt;\n\n        let tmpdir = tmpdir();\n        let filename = tmpdir.join(\"file_rt_io_file_test_read_write_at.txt\");\n        let mut buf = [0; 256];\n        let write1 = \"asdf\";\n        let write2 = \"qwer-\";\n        let write3 = \"-zxcv\";\n        let content = \"qwer-asdf-zxcv\";\n        {\n            let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();\n            let mut rw = check!(oo.open(&filename));\n            assert_eq!(check!(rw.write_at(write1.as_bytes(), 5)), write1.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);\n            assert_eq!(check!(rw.read_at(&mut buf, 5)), write1.len());\n            assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);\n            assert_eq!(check!(rw.read_at(&mut buf[..write2.len()], 0)), write2.len());\n            assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok(\"\\0\\0\\0\\0\\0\"));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 0);\n            assert_eq!(check!(rw.write(write2.as_bytes())), write2.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);\n            assert_eq!(check!(rw.read(&mut buf)), write1.len());\n            assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(rw.read_at(&mut buf[..write2.len()], 0)), write2.len());\n            assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok(write2));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(rw.write_at(write3.as_bytes(), 9)), write3.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n        }\n        {\n            let mut read = check!(File::open(&filename));\n            assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 0);\n            assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);\n            assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(read.read(&mut buf)), write3.len());\n            assert_eq!(str::from_utf8(&buf[..write3.len()]), Ok(write3));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.read_at(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.read_at(&mut buf, 14)), 0);\n            assert_eq!(check!(read.read_at(&mut buf, 15)), 0);\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n        }\n        check!(fs::remove_file(&filename));\n    }\n\n    #[test]\n    #[cfg(unix)]\n    fn set_get_unix_permissions() {\n        use os::unix::fs::PermissionsExt;\n\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"set_get_unix_permissions\");\n        check!(fs::create_dir(filename));\n        let mask = 0o7777;\n\n        check!(fs::set_permissions(filename,\n                                   fs::Permissions::from_mode(0)));\n        let metadata0 = check!(fs::metadata(filename));\n        assert_eq!(mask & metadata0.permissions().mode(), 0);\n\n        check!(fs::set_permissions(filename,\n                                   fs::Permissions::from_mode(0o1777)));\n        let metadata1 = check!(fs::metadata(filename));\n        assert_eq!(mask & metadata1.permissions().mode(), 0o1777);\n    }\n\n    #[test]\n    #[cfg(windows)]\n    fn file_test_io_seek_read_write() {\n        use os::windows::fs::FileExt;\n\n        let tmpdir = tmpdir();\n        let filename = tmpdir.join(\"file_rt_io_file_test_seek_read_write.txt\");\n        let mut buf = [0; 256];\n        let write1 = \"asdf\";\n        let write2 = \"qwer-\";\n        let write3 = \"-zxcv\";\n        let content = \"qwer-asdf-zxcv\";\n        {\n            let oo = OpenOptions::new().create_new(true).write(true).read(true).clone();\n            let mut rw = check!(oo.open(&filename));\n            assert_eq!(check!(rw.seek_write(write1.as_bytes(), 5)), write1.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(rw.seek_read(&mut buf, 5)), write1.len());\n            assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(rw.seek(SeekFrom::Start(0))), 0);\n            assert_eq!(check!(rw.write(write2.as_bytes())), write2.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);\n            assert_eq!(check!(rw.read(&mut buf)), write1.len());\n            assert_eq!(str::from_utf8(&buf[..write1.len()]), Ok(write1));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 9);\n            assert_eq!(check!(rw.seek_read(&mut buf[..write2.len()], 0)), write2.len());\n            assert_eq!(str::from_utf8(&buf[..write2.len()]), Ok(write2));\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 5);\n            assert_eq!(check!(rw.seek_write(write3.as_bytes(), 9)), write3.len());\n            assert_eq!(check!(rw.seek(SeekFrom::Current(0))), 14);\n        }\n        {\n            let mut read = check!(File::open(&filename));\n            assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);\n            assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.seek(SeekFrom::End(-5))), 9);\n            assert_eq!(check!(read.read(&mut buf)), write3.len());\n            assert_eq!(str::from_utf8(&buf[..write3.len()]), Ok(write3));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.seek_read(&mut buf, 0)), content.len());\n            assert_eq!(str::from_utf8(&buf[..content.len()]), Ok(content));\n            assert_eq!(check!(read.seek(SeekFrom::Current(0))), 14);\n            assert_eq!(check!(read.seek_read(&mut buf, 14)), 0);\n            assert_eq!(check!(read.seek_read(&mut buf, 15)), 0);\n        }\n        check!(fs::remove_file(&filename));\n    }\n\n    #[test]\n    fn file_test_stat_is_correct_on_is_file() {\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_stat_correct_on_is_file.txt\");\n        {\n            let mut opts = OpenOptions::new();\n            let mut fs = check!(opts.read(true).write(true)\n                                    .create(true).open(filename));\n            let msg = \"hw\";\n            fs.write(msg.as_bytes()).unwrap();\n\n            let fstat_res = check!(fs.metadata());\n            assert!(fstat_res.is_file());\n        }\n        let stat_res_fn = check!(fs::metadata(filename));\n        assert!(stat_res_fn.is_file());\n        let stat_res_meth = check!(filename.metadata());\n        assert!(stat_res_meth.is_file());\n        check!(fs::remove_file(filename));\n    }\n\n    #[test]\n    fn file_test_stat_is_correct_on_is_dir() {\n        let tmpdir = tmpdir();\n        let filename = &tmpdir.join(\"file_stat_correct_on_is_dir\");\n        check!(fs::create_dir(filename));\n        let stat_res_fn = check!(fs::metadata(filename));\n        assert!(stat_res_fn.is_dir());\n        let stat_res_meth = check!(filename.metadata());\n        assert!(stat_res_meth.is_dir());\n        check!(fs::remove_dir(filename));\n    }\n\n    #[test]\n    fn file_test_fileinfo_false_when_checking_is_file_on_a_directory() {\n        let tmpdir = tmpdir();\n        let dir = &tmpdir.join(\"fileinfo_false_on_dir\");\n        check!(fs::create_dir(dir));\n        assert!(!dir.is_file());\n        check!(fs::remove_dir(dir));\n    }\n\n    #[test]\n    fn file_test_fileinfo_check_exists_before_and_after_file_creation() {\n        let tmpdir = tmpdir();\n        let file = &tmpdir.join(\"fileinfo_check_exists_b_and_a.txt\");\n        check!(check!(File::create(file)).write(b\"foo\"));\n        assert!(file.exists());\n        check!(fs::remove_file(file));\n        assert!(!file.exists());\n    }\n\n    #[test]\n    fn file_test_directoryinfo_check_exists_before_and_after_mkdir() {\n        let tmpdir = tmpdir();\n        let dir = &tmpdir.join(\"before_and_after_dir\");\n        assert!(!dir.exists());\n        check!(fs::create_dir(dir));\n        assert!(dir.exists());\n        assert!(dir.is_dir());\n        check!(fs::remove_dir(dir));\n        assert!(!dir.exists());\n    }\n\n    #[test]\n    fn file_test_directoryinfo_readdir() {\n        let tmpdir = tmpdir();\n        let dir = &tmpdir.join(\"di_readdir\");\n        check!(fs::create_dir(dir));\n        let prefix = \"foo\";\n        for n in 0..3 {\n            let f = dir.join(&format!(\"{}.txt\", n));\n            let mut w = check!(File::create(&f));\n            let msg_str = format!(\"{}{}\", prefix, n.to_string());\n            let msg = msg_str.as_bytes();\n            check!(w.write(msg));\n        }\n        let files = check!(fs::read_dir(dir));\n        let mut mem = [0; 4];\n        for f in files {\n            let f = f.unwrap().path();\n            {\n                let n = f.file_stem().unwrap();\n                check!(check!(File::open(&f)).read(&mut mem));\n                let read_str = str::from_utf8(&mem).unwrap();\n                let expected = format!(\"{}{}\", prefix, n.to_str().unwrap());\n                assert_eq!(expected, read_str);\n            }\n            check!(fs::remove_file(&f));\n        }\n        check!(fs::remove_dir(dir));\n    }\n\n    #[test]\n    fn file_create_new_already_exists_error() {\n        let tmpdir = tmpdir();\n        let file = &tmpdir.join(\"file_create_new_error_exists\");\n        check!(fs::File::create(file));\n        let e = fs::OpenOptions::new().write(true).create_new(true).open(file).unwrap_err();\n        assert_eq!(e.kind(), ErrorKind::AlreadyExists);\n    }\n\n    #[test]\n    fn mkdir_path_already_exists_error() {\n        let tmpdir = tmpdir();\n        let dir = &tmpdir.join(\"mkdir_error_twice\");\n        check!(fs::create_dir(dir));\n        let e = fs::create_dir(dir).unwrap_err();\n        assert_eq!(e.kind(), ErrorKind::AlreadyExists);\n    }\n\n    #[test]\n    fn recursive_mkdir() {\n        let tmpdir = tmpdir();\n        let dir = tmpdir.join(\"d1/d2\");\n        check!(fs::create_dir_all(&dir));\n        assert!(dir.is_dir())\n    }\n\n    #[test]\n    fn recursive_mkdir_failure() {\n        let tmpdir = tmpdir();\n        let dir = tmpdir.join(\"d1\");\n        let file = dir.join(\"f1\");\n\n        check!(fs::create_dir_all(&dir));\n        check!(File::create(&file));\n\n        let result = fs::create_dir_all(&file);\n\n        assert!(result.is_err());\n    }\n\n    #[test]\n    fn concurrent_recursive_mkdir() {\n        for _ in 0..100 {\n            let dir = tmpdir();\n            let mut dir = dir.join(\"a\");\n            for _ in 0..40 {\n                dir = dir.join(\"a\");\n            }\n            let mut join = vec!();\n            for _ in 0..8 {\n                let dir = dir.clone();\n                join.push(thread::spawn(move || {\n                    check!(fs::create_dir_all(&dir));\n                }))\n            }\n\n            // No `Display` on result of `join()`\n            join.drain(..).map(|join| join.join().unwrap()).count();\n        }\n    }\n\n    #[test]\n    fn recursive_mkdir_slash() {\n        check!(fs::create_dir_all(Path::new(\"/\")));\n    }\n\n    #[test]\n    fn recursive_mkdir_dot() {\n        check!(fs::create_dir_all(Path::new(\".\")));\n    }\n\n    #[test]\n    fn recursive_mkdir_empty() {\n        check!(fs::create_dir_all(Path::new(\"\")));\n    }\n\n    #[test]\n    fn recursive_rmdir() {\n        let tmpdir = tmpdir();\n        let d1 = tmpdir.join(\"d1\");\n        let dt = d1.join(\"t\");\n        let dtt = dt.join(\"t\");\n        let d2 = tmpdir.join(\"d2\");\n        let canary = d2.join(\"do_not_delete\");\n        check!(fs::create_dir_all(&dtt));\n        check!(fs::create_dir_all(&d2));\n        check!(check!(File::create(&canary)).write(b\"foo\"));\n        check!(symlink_junction(&d2, &dt.join(\"d2\")));\n        let _ = symlink_file(&canary, &d1.join(\"canary\"));\n        check!(fs::remove_dir_all(&d1));\n\n        assert!(!d1.is_dir());\n        assert!(canary.exists());\n    }\n\n    #[test]\n    fn recursive_rmdir_of_symlink() {\n        // test we do not recursively delete a symlink but only dirs.\n        let tmpdir = tmpdir();\n        let link = tmpdir.join(\"d1\");\n        let dir = tmpdir.join(\"d2\");\n        let canary = dir.join(\"do_not_delete\");\n        check!(fs::create_dir_all(&dir));\n        check!(check!(File::create(&canary)).write(b\"foo\"));\n        check!(symlink_junction(&dir, &link));\n        check!(fs::remove_dir_all(&link));\n\n        assert!(!link.is_dir());\n        assert!(canary.exists());\n    }\n\n    #[test]\n    // only Windows makes a distinction between file and directory symlinks.\n    #[cfg(windows)]\n    fn recursive_rmdir_of_file_symlink() {\n        let tmpdir = tmpdir();\n        if !got_symlink_permission(&tmpdir) { return };\n\n        let f1 = tmpdir.join(\"f1\");\n        let f2 = tmpdir.join(\"f2\");\n        check!(check!(File::create(&f1)).write(b\"foo\"));\n        check!(symlink_file(&f1, &f2));\n        match fs::remove_dir_all(&f2) {\n            Ok(..) => panic!(\"wanted a failure\"),\n            Err(..) => {}\n        }\n    }\n\n    #[test]\n    fn unicode_path_is_dir() {\n        assert!(Path::new(\".\").is_dir());\n        assert!(!Path::new(\"test/stdtest/fs.rs\").is_dir());\n\n        let tmpdir = tmpdir();\n\n        let mut dirpath = tmpdir.path().to_path_buf();\n        dirpath.push(\"test-\uac00\u4e00\u30fc\u4f60\u597d\");\n        check!(fs::create_dir(&dirpath));\n        assert!(dirpath.is_dir());\n\n        let mut filepath = dirpath;\n        filepath.push(\"unicode-file-\\u{ac00}\\u{4e00}\\u{30fc}\\u{4f60}\\u{597d}.rs\");\n        check!(File::create(&filepath)); // ignore return; touch only\n        assert!(!filepath.is_dir());\n        assert!(filepath.exists());\n    }\n\n    #[test]\n    fn unicode_path_exists() {\n        assert!(Path::new(\".\").exists());\n        assert!(!Path::new(\"test/nonexistent-bogus-path\").exists());\n\n        let tmpdir = tmpdir();\n        let unicode = tmpdir.path();\n        let unicode = unicode.join(\"test-\uac01\u4e01\u30fc\u518d\u89c1\");\n        check!(fs::create_dir(&unicode));\n        assert!(unicode.exists());\n        assert!(!Path::new(\"test/unicode-bogus-path-\uac01\u4e01\u30fc\u518d\u89c1\").exists());\n    }\n\n    #[test]\n    fn copy_file_does_not_exist() {\n        let from = Path::new(\"test/nonexistent-bogus-path\");\n        let to = Path::new(\"test/other-bogus-path\");\n\n        match fs::copy(&from, &to) {\n            Ok(..) => panic!(),\n            Err(..) => {\n                assert!(!from.exists());\n                assert!(!to.exists());\n            }\n        }\n    }\n\n    #[test]\n    fn copy_src_does_not_exist() {\n        let tmpdir = tmpdir();\n        let from = Path::new(\"test/nonexistent-bogus-path\");\n        let to = tmpdir.join(\"out.txt\");\n        check!(check!(File::create(&to)).write(b\"hello\"));\n        assert!(fs::copy(&from, &to).is_err());\n        assert!(!from.exists());\n        let mut v = Vec::new();\n        check!(check!(File::open(&to)).read_to_end(&mut v));\n        assert_eq!(v, b\"hello\");\n    }\n\n    #[test]\n    fn copy_file_ok() {\n        let tmpdir = tmpdir();\n        let input = tmpdir.join(\"in.txt\");\n        let out = tmpdir.join(\"out.txt\");\n\n        check!(check!(File::create(&input)).write(b\"hello\"));\n        check!(fs::copy(&input, &out));\n        let mut v = Vec::new();\n        check!(check!(File::open(&out)).read_to_end(&mut v));\n        assert_eq!(v, b\"hello\");\n\n        assert_eq!(check!(input.metadata()).permissions(),\n                   check!(out.metadata()).permissions());\n    }\n\n    #[test]\n    fn copy_file_dst_dir() {\n        let tmpdir = tmpdir();\n        let out = tmpdir.join(\"out\");\n\n        check!(File::create(&out));\n        match fs::copy(&*out, tmpdir.path()) {\n            Ok(..) => panic!(), Err(..) => {}\n        }\n    }\n\n    #[test]\n    fn copy_file_dst_exists() {\n        let tmpdir = tmpdir();\n        let input = tmpdir.join(\"in\");\n        let output = tmpdir.join(\"out\");\n\n        check!(check!(File::create(&input)).write(\"foo\".as_bytes()));\n        check!(check!(File::create(&output)).write(\"bar\".as_bytes()));\n        check!(fs::copy(&input, &output));\n\n        let mut v = Vec::new();\n        check!(check!(File::open(&output)).read_to_end(&mut v));\n        assert_eq!(v, b\"foo\".to_vec());\n    }\n\n    #[test]\n    fn copy_file_src_dir() {\n        let tmpdir = tmpdir();\n        let out = tmpdir.join(\"out\");\n\n        match fs::copy(tmpdir.path(), &out) {\n            Ok(..) => panic!(), Err(..) => {}\n        }\n        assert!(!out.exists());\n    }\n\n    #[test]\n    fn copy_file_preserves_perm_bits() {\n        let tmpdir = tmpdir();\n        let input = tmpdir.join(\"in.txt\");\n        let out = tmpdir.join(\"out.txt\");\n\n        let attr = check!(check!(File::create(&input)).metadata());\n        let mut p = attr.permissions();\n        p.set_readonly(true);\n        check!(fs::set_permissions(&input, p));\n        check!(fs::copy(&input, &out));\n        assert!(check!(out.metadata()).permissions().readonly());\n        check!(fs::set_permissions(&input, attr.permissions()));\n        check!(fs::set_permissions(&out, attr.permissions()));\n    }\n\n    #[test]\n    #[cfg(windows)]\n    fn copy_file_preserves_streams() {\n        let tmp = tmpdir();\n        check!(check!(File::create(tmp.join(\"in.txt:bunny\"))).write(\"carrot\".as_bytes()));\n        assert_eq!(check!(fs::copy(tmp.join(\"in.txt\"), tmp.join(\"out.txt\"))), 0);\n        assert_eq!(check!(tmp.join(\"out.txt\").metadata()).len(), 0);\n        let mut v = Vec::new();\n        check!(check!(File::open(tmp.join(\"out.txt:bunny\"))).read_to_end(&mut v));\n        assert_eq!(v, b\"carrot\".to_vec());\n    }\n\n    #[test]\n    fn copy_file_returns_metadata_len() {\n        let tmp = tmpdir();\n        let in_path = tmp.join(\"in.txt\");\n        let out_path = tmp.join(\"out.txt\");\n        check!(check!(File::create(&in_path)).write(b\"lettuce\"));\n        #[cfg(windows)]\n        check!(check!(File::create(tmp.join(\"in.txt:bunny\"))).write(b\"carrot\"));\n        let copied_len = check!(fs::copy(&in_path, &out_path));\n        assert_eq!(check!(out_path.metadata()).len(), copied_len);\n    }\n\n    #[test]\n    fn symlinks_work() {\n        let tmpdir = tmpdir();\n        if !got_symlink_permission(&tmpdir) { return };\n\n        let input = tmpdir.join(\"in.txt\");\n        let out = tmpdir.join(\"out.txt\");\n\n        check!(check!(File::create(&input)).write(\"foobar\".as_bytes()));\n        check!(symlink_file(&input, &out));\n        assert!(check!(out.symlink_metadata()).file_type().is_symlink());\n        assert_eq!(check!(fs::metadata(&out)).len(),\n                   check!(fs::metadata(&input)).len());\n        let mut v = Vec::new();\n        check!(check!(File::open(&out)).read_to_end(&mut v));\n        assert_eq!(v, b\"foobar\".to_vec());\n    }\n\n    #[test]\n    fn symlink_noexist() {\n        // Symlinks can point to things that don't exist\n        let tmpdir = tmpdir();\n        if !got_symlink_permission(&tmpdir) { return };\n\n        // Use a relative path for testing. Symlinks get normalized by Windows,\n        // so we may not get the same path back for absolute paths\n        check!(symlink_file(&\"foo\", &tmpdir.join(\"bar\")));\n        assert_eq!(check!(fs::read_link(&tmpdir.join(\"bar\"))).to_str().unwrap(),\n                   \"foo\");\n    }\n\n    #[test]\n    fn read_link() {\n        if cfg!(windows) {\n            // directory symlink\n            assert_eq!(check!(fs::read_link(r\"C:\\Users\\All Users\")).to_str().unwrap(),\n                       r\"C:\\ProgramData\");\n            // junction\n            assert_eq!(check!(fs::read_link(r\"C:\\Users\\Default User\")).to_str().unwrap(),\n                       r\"C:\\Users\\Default\");\n            // junction with special permissions\n            assert_eq!(check!(fs::read_link(r\"C:\\Documents and Settings\\\")).to_str().unwrap(),\n                       r\"C:\\Users\");\n        }\n        let tmpdir = tmpdir();\n        let link = tmpdir.join(\"link\");\n        if !got_symlink_permission(&tmpdir) { return };\n        check!(symlink_file(&\"foo\", &link));\n        assert_eq!(check!(fs::read_link(&link)).to_str().unwrap(), \"foo\");\n    }\n\n    #[test]\n    fn readlink_not_symlink() {\n        let tmpdir = tmpdir();\n        match fs::read_link(tmpdir.path()) {\n            Ok(..) => panic!(\"wanted a failure\"),\n            Err(..) => {}\n        }\n    }\n\n    #[test]\n    fn links_work() {\n        let tmpdir = tmpdir();\n        let input = tmpdir.join(\"in.txt\");\n        let out = tmpdir.join(\"out.txt\");\n\n        check!(check!(File::create(&input)).write(\"foobar\".as_bytes()));\n        check!(fs::hard_link(&input, &out));\n        assert_eq!(check!(fs::metadata(&out)).len(),\n                   check!(fs::metadata(&input)).len());\n        assert_eq!(check!(fs::metadata(&out)).len(),\n                   check!(input.metadata()).len());\n        let mut v = Vec::new();\n        check!(check!(File::open(&out)).read_to_end(&mut v));\n        assert_eq!(v, b\"foobar\".to_vec());\n\n        // can't link to yourself\n        match fs::hard_link(&input, &input) {\n            Ok(..) => panic!(\"wanted a failure\"),\n            Err(..) => {}\n        }\n        // can't link to something that doesn't exist\n        match fs::hard_link(&tmpdir.join(\"foo\"), &tmpdir.join(\"bar\")) {\n            Ok(..) => panic!(\"wanted a failure\"),\n            Err(..) => {}\n        }\n    }\n\n    #[test]\n    fn chmod_works() {\n        let tmpdir = tmpdir();\n        let file = tmpdir.join(\"in.txt\");\n\n        check!(File::create(&file));\n        let attr = check!(fs::metadata(&file));\n        assert!(!attr.permissions().readonly());\n        let mut p = attr.permissions();\n        p.set_readonly(true);\n        check!(fs::set_permissions(&file, p.clone()));\n        let attr = check!(fs::metadata(&file));\n        assert!(attr.permissions().readonly());\n\n        match fs::set_permissions(&tmpdir.join(\"foo\"), p.clone()) {\n            Ok(..) => panic!(\"wanted an error\"),\n            Err(..) => {}\n        }\n\n        p.set_readonly(false);\n        check!(fs::set_permissions(&file, p));\n    }\n\n    #[test]\n    fn fchmod_works() {\n        let tmpdir = tmpdir();\n        let path = tmpdir.join(\"in.txt\");\n\n        let file = check!(File::create(&path));\n        let attr = check!(fs::metadata(&path));\n        assert!(!attr.permissions().readonly());\n        let mut p = attr.permissions();\n        p.set_readonly(true);\n        check!(file.set_permissions(p.clone()));\n        let attr = check!(fs::metadata(&path));\n        assert!(attr.permissions().readonly());\n\n        p.set_readonly(false);\n        check!(file.set_permissions(p));\n    }\n\n    #[test]\n    fn sync_doesnt_kill_anything() {\n        let tmpdir = tmpdir();\n        let path = tmpdir.join(\"in.txt\");\n\n        let mut file = check!(File::create(&path));\n        check!(file.sync_all());\n        check!(file.sync_data());\n        check!(file.write(b\"foo\"));\n        check!(file.sync_all());\n        check!(file.sync_data());\n    }\n\n    #[test]\n    fn truncate_works() {\n        let tmpdir = tmpdir();\n        let path = tmpdir.join(\"in.txt\");\n\n        let mut file = check!(File::create(&path));\n        check!(file.write(b\"foo\"));\n        check!(file.sync_all());\n\n        // Do some simple things with truncation\n        assert_eq!(check!(file.metadata()).len(), 3);\n        check!(file.set_len(10));\n        assert_eq!(check!(file.metadata()).len(), 10);\n        check!(file.write(b\"bar\"));\n        check!(file.sync_all());\n        assert_eq!(check!(file.metadata()).len(), 10);\n\n        let mut v = Vec::new();\n        check!(check!(File::open(&path)).read_to_end(&mut v));\n        assert_eq!(v, b\"foobar\\0\\0\\0\\0\".to_vec());\n\n        // Truncate to a smaller length, don't seek, and then write something.\n        // Ensure that the intermediate zeroes are all filled in (we have `seek`ed\n        // past the end of the file).\n        check!(file.set_len(2));\n        assert_eq!(check!(file.metadata()).len(), 2);\n        check!(file.write(b\"wut\"));\n        check!(file.sync_all());\n        assert_eq!(check!(file.metadata()).len(), 9);\n        let mut v = Vec::new();\n        check!(check!(File::open(&path)).read_to_end(&mut v));\n        assert_eq!(v, b\"fo\\0\\0\\0\\0wut\".to_vec());\n    }\n\n    #[test]\n    fn open_flavors() {\n        use fs::OpenOptions as OO;\n        fn c<T: Clone>(t: &T) -> T { t.clone() }\n\n        let tmpdir = tmpdir();\n\n        let mut r = OO::new(); r.read(true);\n        let mut w = OO::new(); w.write(true);\n        let mut rw = OO::new(); rw.read(true).write(true);\n        let mut a = OO::new(); a.append(true);\n        let mut ra = OO::new(); ra.read(true).append(true);\n\n        #[cfg(windows)]\n        let invalid_options = 87; // ERROR_INVALID_PARAMETER\n        #[cfg(unix)]\n        let invalid_options = \"Invalid argument\";\n\n        // Test various combinations of creation modes and access modes.\n        //\n        // Allowed:\n        // creation mode           | read  | write | read-write | append | read-append |\n        // :-----------------------|:-----:|:-----:|:----------:|:------:|:-----------:|\n        // not set (open existing) |   X   |   X   |     X      |   X    |      X      |\n        // create                  |       |   X   |     X      |   X    |      X      |\n        // truncate                |       |   X   |     X      |        |             |\n        // create and truncate     |       |   X   |     X      |        |             |\n        // create_new              |       |   X   |     X      |   X    |      X      |\n        //\n        // tested in reverse order, so 'create_new' creates the file, and 'open existing' opens it.\n\n        // write-only\n        check!(c(&w).create_new(true).open(&tmpdir.join(\"a\")));\n        check!(c(&w).create(true).truncate(true).open(&tmpdir.join(\"a\")));\n        check!(c(&w).truncate(true).open(&tmpdir.join(\"a\")));\n        check!(c(&w).create(true).open(&tmpdir.join(\"a\")));\n        check!(c(&w).open(&tmpdir.join(\"a\")));\n\n        // read-only\n        error!(c(&r).create_new(true).open(&tmpdir.join(\"b\")), invalid_options);\n        error!(c(&r).create(true).truncate(true).open(&tmpdir.join(\"b\")), invalid_options);\n        error!(c(&r).truncate(true).open(&tmpdir.join(\"b\")), invalid_options);\n        error!(c(&r).create(true).open(&tmpdir.join(\"b\")), invalid_options);\n        check!(c(&r).open(&tmpdir.join(\"a\"))); // try opening the file created with write_only\n\n        // read-write\n        check!(c(&rw).create_new(true).open(&tmpdir.join(\"c\")));\n        check!(c(&rw).create(true).truncate(true).open(&tmpdir.join(\"c\")));\n        check!(c(&rw).truncate(true).open(&tmpdir.join(\"c\")));\n        check!(c(&rw).create(true).open(&tmpdir.join(\"c\")));\n        check!(c(&rw).open(&tmpdir.join(\"c\")));\n\n        // append\n        check!(c(&a).create_new(true).open(&tmpdir.join(\"d\")));\n        error!(c(&a).create(true).truncate(true).open(&tmpdir.join(\"d\")), invalid_options);\n        error!(c(&a).truncate(true).open(&tmpdir.join(\"d\")), invalid_options);\n        check!(c(&a).create(true).open(&tmpdir.join(\"d\")));\n        check!(c(&a).open(&tmpdir.join(\"d\")));\n\n        // read-append\n        check!(c(&ra).create_new(true).open(&tmpdir.join(\"e\")));\n        error!(c(&ra).create(true).truncate(true).open(&tmpdir.join(\"e\")), invalid_options);\n        error!(c(&ra).truncate(true).open(&tmpdir.join(\"e\")), invalid_options);\n        check!(c(&ra).create(true).open(&tmpdir.join(\"e\")));\n        check!(c(&ra).open(&tmpdir.join(\"e\")));\n\n        // Test opening a file without setting an access mode\n        let mut blank = OO::new();\n         error!(blank.create(true).open(&tmpdir.join(\"f\")), invalid_options);\n\n        // Test write works\n        check!(check!(File::create(&tmpdir.join(\"h\"))).write(\"foobar\".as_bytes()));\n\n        // Test write fails for read-only\n        check!(r.open(&tmpdir.join(\"h\")));\n        {\n            let mut f = check!(r.open(&tmpdir.join(\"h\")));\n            assert!(f.write(\"wut\".as_bytes()).is_err());\n        }\n\n        // Test write overwrites\n        {\n            let mut f = check!(c(&w).open(&tmpdir.join(\"h\")));\n            check!(f.write(\"baz\".as_bytes()));\n        }\n        {\n            let mut f = check!(c(&r).open(&tmpdir.join(\"h\")));\n            let mut b = vec![0; 6];\n            check!(f.read(&mut b));\n            assert_eq!(b, \"bazbar\".as_bytes());\n        }\n\n        // Test truncate works\n        {\n            let mut f = check!(c(&w).truncate(true).open(&tmpdir.join(\"h\")));\n            check!(f.write(\"foo\".as_bytes()));\n        }\n        assert_eq!(check!(fs::metadata(&tmpdir.join(\"h\"))).len(), 3);\n\n        // Test append works\n        assert_eq!(check!(fs::metadata(&tmpdir.join(\"h\"))).len(), 3);\n        {\n            let mut f = check!(c(&a).open(&tmpdir.join(\"h\")));\n            check!(f.write(\"bar\".as_bytes()));\n        }\n        assert_eq!(check!(fs::metadata(&tmpdir.join(\"h\"))).len(), 6);\n\n        // Test .append(true) equals .write(true).append(true)\n        {\n            let mut f = check!(c(&w).append(true).open(&tmpdir.join(\"h\")));\n            check!(f.write(\"baz\".as_bytes()));\n        }\n        assert_eq!(check!(fs::metadata(&tmpdir.join(\"h\"))).len(), 9);\n    }\n\n    #[test]\n    fn _assert_send_sync() {\n        fn _assert_send_sync<T: Send + Sync>() {}\n        _assert_send_sync::<OpenOptions>();\n    }\n\n    #[test]\n    fn binary_file() {\n        let mut bytes = [0; 1024];\n        StdRng::from_entropy().fill_bytes(&mut bytes);\n\n        let tmpdir = tmpdir();\n\n        check!(check!(File::create(&tmpdir.join(\"test\"))).write(&bytes));\n        let mut v = Vec::new();\n        check!(check!(File::open(&tmpdir.join(\"test\"))).read_to_end(&mut v));\n        assert!(v == &bytes[..]);\n    }\n\n    #[test]\n    fn write_then_read() {\n        let mut bytes = [0; 1024];\n        StdRng::from_entropy().fill_bytes(&mut bytes);\n\n        let tmpdir = tmpdir();\n\n        check!(fs::write(&tmpdir.join(\"test\"), &bytes[..]));\n        let v = check!(fs::read(&tmpdir.join(\"test\")));\n        assert!(v == &bytes[..]);\n\n        check!(fs::write(&tmpdir.join(\"not-utf8\"), &[0xFF]));\n        error_contains!(fs::read_to_string(&tmpdir.join(\"not-utf8\")),\n                        \"stream did not contain valid UTF-8\");\n\n        let s = \"\ud800\udc41\ud800\udc13\ud800\udc20\ud800\udc34\ud800\udc0d\";\n        check!(fs::write(&tmpdir.join(\"utf8\"), s.as_bytes()));\n        let string = check!(fs::read_to_string(&tmpdir.join(\"utf8\")));\n        assert_eq!(string, s);\n    }\n\n    #[test]\n    fn file_try_clone() {\n        let tmpdir = tmpdir();\n\n        let mut f1 = check!(OpenOptions::new()\n                                       .read(true)\n                                       .write(true)\n                                       .create(true)\n                                       .open(&tmpdir.join(\"test\")));\n        let mut f2 = check!(f1.try_clone());\n\n        check!(f1.write_all(b\"hello world\"));\n        check!(f1.seek(SeekFrom::Start(2)));\n\n        let mut buf = vec![];\n        check!(f2.read_to_end(&mut buf));\n        assert_eq!(buf, b\"llo world\");\n        drop(f2);\n\n        check!(f1.write_all(b\"!\"));\n    }\n\n    #[test]\n    #[cfg(not(windows))]\n    fn unlink_readonly() {\n        let tmpdir = tmpdir();\n        let path = tmpdir.join(\"file\");\n        check!(File::create(&path));\n        let mut perm = check!(fs::metadata(&path)).permissions();\n        perm.set_readonly(true);\n        check!(fs::set_permissions(&path, perm));\n        check!(fs::remove_file(&path));\n    }\n\n    #[test]\n    fn mkdir_trailing_slash() {\n        let tmpdir = tmpdir();\n        let path = tmpdir.join(\"file\");\n        check!(fs::create_dir_all(&path.join(\"a/\")));\n    }\n\n    #[test]\n    fn canonicalize_works_simple() {\n        let tmpdir = tmpdir();\n        let tmpdir = fs::canonicalize(tmpdir.path()).unwrap();\n        let file = tmpdir.join(\"test\");\n        File::create(&file).unwrap();\n        assert_eq!(fs::canonicalize(&file).unwrap(), file);\n    }\n\n    #[test]\n    fn realpath_works() {\n        let tmpdir = tmpdir();\n        if !got_symlink_permission(&tmpdir) { return };\n\n        let tmpdir = fs::canonicalize(tmpdir.path()).unwrap();\n        let file = tmpdir.join(\"test\");\n        let dir = tmpdir.join(\"test2\");\n        let link = dir.join(\"link\");\n        let linkdir = tmpdir.join(\"test3\");\n\n        File::create(&file).unwrap();\n        fs::create_dir(&dir).unwrap();\n        symlink_file(&file, &link).unwrap();\n        symlink_dir(&dir, &linkdir).unwrap();\n\n        assert!(link.symlink_metadata().unwrap().file_type().is_symlink());\n\n        assert_eq!(fs::canonicalize(&tmpdir).unwrap(), tmpdir);\n        assert_eq!(fs::canonicalize(&file).unwrap(), file);\n        assert_eq!(fs::canonicalize(&link).unwrap(), file);\n        assert_eq!(fs::canonicalize(&linkdir).unwrap(), dir);\n        assert_eq!(fs::canonicalize(&linkdir.join(\"link\")).unwrap(), file);\n    }\n\n    #[test]\n    fn realpath_works_tricky() {\n        let tmpdir = tmpdir();\n        if !got_symlink_permission(&tmpdir) { return };\n\n        let tmpdir = fs::canonicalize(tmpdir.path()).unwrap();\n        let a = tmpdir.join(\"a\");\n        let b = a.join(\"b\");\n        let c = b.join(\"c\");\n        let d = a.join(\"d\");\n        let e = d.join(\"e\");\n        let f = a.join(\"f\");\n\n        fs::create_dir_all(&b).unwrap();\n        fs::create_dir_all(&d).unwrap();\n        File::create(&f).unwrap();\n        if cfg!(not(windows)) {\n            symlink_dir(\"../d/e\", &c).unwrap();\n            symlink_file(\"../f\", &e).unwrap();\n        }\n        if cfg!(windows) {\n            symlink_dir(r\"..\\d\\e\", &c).unwrap();\n            symlink_file(r\"..\\f\", &e).unwrap();\n        }\n\n        assert_eq!(fs::canonicalize(&c).unwrap(), f);\n        assert_eq!(fs::canonicalize(&e).unwrap(), f);\n    }\n\n    #[test]\n    fn dir_entry_methods() {\n        let tmpdir = tmpdir();\n\n        fs::create_dir_all(&tmpdir.join(\"a\")).unwrap();\n        File::create(&tmpdir.join(\"b\")).unwrap();\n\n        for file in tmpdir.path().read_dir().unwrap().map(|f| f.unwrap()) {\n            let fname = file.file_name();\n            match fname.to_str() {\n                Some(\"a\") => {\n                    assert!(file.file_type().unwrap().is_dir());\n                    assert!(file.metadata().unwrap().is_dir());\n                }\n                Some(\"b\") => {\n                    assert!(file.file_type().unwrap().is_file());\n                    assert!(file.metadata().unwrap().is_file());\n                }\n                f => panic!(\"unknown file name: {:?}\", f),\n            }\n        }\n    }\n\n    #[test]\n    fn dir_entry_debug() {\n        let tmpdir = tmpdir();\n        File::create(&tmpdir.join(\"b\")).unwrap();\n        let mut read_dir = tmpdir.path().read_dir().unwrap();\n        let dir_entry = read_dir.next().unwrap().unwrap();\n        let actual = format!(\"{:?}\", dir_entry);\n        let expected = format!(\"DirEntry({:?})\", dir_entry.0.path());\n        assert_eq!(actual, expected);\n    }\n\n    #[test]\n    fn read_dir_not_found() {\n        let res = fs::read_dir(\"/path/that/does/not/exist\");\n        assert_eq!(res.err().unwrap().kind(), ErrorKind::NotFound);\n    }\n\n    #[test]\n    fn create_dir_all_with_junctions() {\n        let tmpdir = tmpdir();\n        let target = tmpdir.join(\"target\");\n\n        let junction = tmpdir.join(\"junction\");\n        let b = junction.join(\"a/b\");\n\n        let link = tmpdir.join(\"link\");\n        let d = link.join(\"c/d\");\n\n        fs::create_dir(&target).unwrap();\n\n        check!(symlink_junction(&target, &junction));\n        check!(fs::create_dir_all(&b));\n        // the junction itself is not a directory, but `is_dir()` on a Path\n        // follows links\n        assert!(junction.is_dir());\n        assert!(b.exists());\n\n        if !got_symlink_permission(&tmpdir) { return };\n        check!(symlink_dir(&target, &link));\n        check!(fs::create_dir_all(&d));\n        assert!(link.is_dir());\n        assert!(d.exists());\n    }\n\n    #[test]\n    fn metadata_access_times() {\n        let tmpdir = tmpdir();\n\n        let b = tmpdir.join(\"b\");\n        File::create(&b).unwrap();\n\n        let a = check!(fs::metadata(&tmpdir.path()));\n        let b = check!(fs::metadata(&b));\n\n        assert_eq!(check!(a.accessed()), check!(a.accessed()));\n        assert_eq!(check!(a.modified()), check!(a.modified()));\n        assert_eq!(check!(b.accessed()), check!(b.modified()));\n\n        if cfg!(target_os = \"macos\") || cfg!(target_os = \"windows\") {\n            check!(a.created());\n            check!(b.created());\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse cell::UnsafeCell;\nuse fmt;\nuse mem;\nuse ops::{Deref, DerefMut};\nuse ptr;\nuse sys_common::mutex as sys;\nuse sys_common::poison::{self, TryLockError, TryLockResult, LockResult};\n\n/// A mutual exclusion primitive useful for protecting shared data\n///\n/// This mutex will block threads waiting for the lock to become available. The\n/// mutex can also be statically initialized or created via a [`new`]\n/// constructor. Each mutex has a type parameter which represents the data that\n/// it is protecting. The data can only be accessed through the RAII guards\n/// returned from [`lock`] and [`try_lock`], which guarantees that the data is only\n/// ever accessed when the mutex is locked.\n///\n/// # Poisoning\n///\n/// The mutexes in this module implement a strategy called \"poisoning\" where a\n/// mutex is considered poisoned whenever a thread panics while holding the\n/// mutex. Once a mutex is poisoned, all other threads are unable to access the\n/// data by default as it is likely tainted (some invariant is not being\n/// upheld).\n///\n/// For a mutex, this means that the [`lock`] and [`try_lock`] methods return a\n/// [`Result`] which indicates whether a mutex has been poisoned or not. Most\n/// usage of a mutex will simply [`unwrap()`] these results, propagating panics\n/// among threads to ensure that a possibly invalid invariant is not witnessed.\n///\n/// A poisoned mutex, however, does not prevent all access to the underlying\n/// data. The [`PoisonError`] type has an [`into_inner`] method which will return\n/// the guard that would have otherwise been returned on a successful lock. This\n/// allows access to the data, despite the lock being poisoned.\n///\n/// [`new`]: #method.new\n/// [`lock`]: #method.lock\n/// [`try_lock`]: #method.try_lock\n/// [`Result`]: ../../std/result/enum.Result.html\n/// [`unwrap()`]: ../../std/result/enum.Result.html#method.unwrap\n/// [`PoisonError`]: ../../std/sync/struct.PoisonError.html\n/// [`into_inner`]: ../../std/sync/struct.PoisonError.html#method.into_inner\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::{Arc, Mutex};\n/// use std::thread;\n/// use std::sync::mpsc::channel;\n///\n/// const N: usize = 10;\n///\n/// // Spawn a few threads to increment a shared variable (non-atomically), and\n/// // let the main thread know once all increments are done.\n/// //\n/// // Here we're using an Arc to share memory among threads, and the data inside\n/// // the Arc is protected with a mutex.\n/// let data = Arc::new(Mutex::new(0));\n///\n/// let (tx, rx) = channel();\n/// for _ in 0..N {\n///     let (data, tx) = (data.clone(), tx.clone());\n///     thread::spawn(move || {\n///         // The shared state can only be accessed once the lock is held.\n///         // Our non-atomic increment is safe because we're the only thread\n///         // which can access the shared state when the lock is held.\n///         //\n///         // We unwrap() the return value to assert that we are not expecting\n///         // threads to ever fail while holding the lock.\n///         let mut data = data.lock().unwrap();\n///         *data += 1;\n///         if *data == N {\n///             tx.send(()).unwrap();\n///         }\n///         // the lock is unlocked here when `data` goes out of scope.\n///     });\n/// }\n///\n/// rx.recv().unwrap();\n/// ```\n///\n/// To recover from a poisoned mutex:\n///\n/// ```\n/// use std::sync::{Arc, Mutex};\n/// use std::thread;\n///\n/// let lock = Arc::new(Mutex::new(0_u32));\n/// let lock2 = lock.clone();\n///\n/// let _ = thread::spawn(move || -> () {\n///     // This thread will acquire the mutex first, unwrapping the result of\n///     // `lock` because the lock has not been poisoned.\n///     let _guard = lock2.lock().unwrap();\n///\n///     // This panic while holding the lock (`_guard` is in scope) will poison\n///     // the mutex.\n///     panic!();\n/// }).join();\n///\n/// // The lock is poisoned by this point, but the returned result can be\n/// // pattern matched on to return the underlying guard on both branches.\n/// let mut guard = match lock.lock() {\n///     Ok(guard) => guard,\n///     Err(poisoned) => poisoned.into_inner(),\n/// };\n///\n/// *guard += 1;\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Mutex<T: ?Sized> {\n    // Note that this mutex is in a *box*, not inlined into the struct itself.\n    // Once a native mutex has been used once, its address can never change (it\n    // can't be moved). This mutex type can be safely moved at any time, so to\n    // ensure that the native mutex is used correctly we box the inner mutex to\n    // give it a constant address.\n    inner: Box<sys::Mutex>,\n    poison: poison::Flag,\n    data: UnsafeCell<T>,\n}\n\n// these are the only places where `T: Send` matters; all other\n// functionality works fine on a single thread.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized + Send> Send for Mutex<T> { }\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<T: ?Sized + Send> Sync for Mutex<T> { }\n\n/// An RAII implementation of a \"scoped lock\" of a mutex. When this structure is\n/// dropped (falls out of scope), the lock will be unlocked.\n///\n/// The data protected by the mutex can be accessed through this guard via its\n/// [`Deref`] and [`DerefMut`] implementations.\n///\n/// This structure is created by the [`lock`] and [`try_lock`] methods on\n/// [`Mutex`].\n///\n/// [`Deref`]: ../../std/ops/trait.Deref.html\n/// [`DerefMut`]: ../../std/ops/trait.DerefMut.html\n/// [`lock`]: struct.Mutex.html#method.lock\n/// [`try_lock`]: struct.Mutex.html#method.try_lock\n/// [`Mutex`]: struct.Mutex.html\n#[must_use = \"if unused the Mutex will immediately unlock\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct MutexGuard<'a, T: ?Sized + 'a> {\n    // funny underscores due to how Deref/DerefMut currently work (they\n    // disregard field privacy).\n    __lock: &'a Mutex<T>,\n    __poison: poison::Guard,\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: ?Sized> !Send for MutexGuard<'a, T> { }\n#[stable(feature = \"mutexguard\", since = \"1.19.0\")]\nunsafe impl<'a, T: ?Sized + Sync> Sync for MutexGuard<'a, T> { }\n\nimpl<T> Mutex<T> {\n    /// Creates a new mutex in an unlocked state ready for use.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Mutex;\n    ///\n    /// let mutex = Mutex::new(0);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(t: T) -> Mutex<T> {\n        let mut m = Mutex {\n            inner: box sys::Mutex::new(),\n            poison: poison::Flag::new(),\n            data: UnsafeCell::new(t),\n        };\n        unsafe {\n            m.inner.init();\n        }\n        m\n    }\n}\n\nimpl<T: ?Sized> Mutex<T> {\n    /// Acquires a mutex, blocking the current thread until it is able to do so.\n    ///\n    /// This function will block the local thread until it is available to acquire\n    /// the mutex. Upon returning, the thread is the only thread with the lock\n    /// held. An RAII guard is returned to allow scoped unlock of the lock. When\n    /// the guard goes out of scope, the mutex will be unlocked.\n    ///\n    /// The exact behavior on locking a mutex in the thread which already holds\n    /// the lock is left unspecified. However, this function will not return on\n    /// the second call (it might panic or deadlock, for example).\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return an error once the mutex is acquired.\n    ///\n    /// # Panics\n    ///\n    /// This function might panic when called if the lock is already held by\n    /// the current thread.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex};\n    /// use std::thread;\n    ///\n    /// let mutex = Arc::new(Mutex::new(0));\n    /// let c_mutex = mutex.clone();\n    ///\n    /// thread::spawn(move || {\n    ///     *c_mutex.lock().unwrap() = 10;\n    /// }).join().expect(\"thread::spawn failed\");\n    /// assert_eq!(*mutex.lock().unwrap(), 10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn lock(&self) -> LockResult<MutexGuard<T>> {\n        unsafe {\n            self.inner.raw_lock();\n            MutexGuard::new(self)\n        }\n    }\n\n    /// Attempts to acquire this lock.\n    ///\n    /// If the lock could not be acquired at this time, then [`Err`] is returned.\n    /// Otherwise, an RAII guard is returned. The lock will be unlocked when the\n    /// guard is dropped.\n    ///\n    /// This function does not block.\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return failure if the mutex would otherwise be\n    /// acquired.\n    ///\n    /// [`Err`]: ../../std/result/enum.Result.html#variant.Err\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex};\n    /// use std::thread;\n    ///\n    /// let mutex = Arc::new(Mutex::new(0));\n    /// let c_mutex = mutex.clone();\n    ///\n    /// thread::spawn(move || {\n    ///     let mut lock = c_mutex.try_lock();\n    ///     if let Ok(ref mut mutex) = lock {\n    ///         **mutex = 10;\n    ///     } else {\n    ///         println!(\"try_lock failed\");\n    ///     }\n    /// }).join().expect(\"thread::spawn failed\");\n    /// assert_eq!(*mutex.lock().unwrap(), 10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn try_lock(&self) -> TryLockResult<MutexGuard<T>> {\n        unsafe {\n            if self.inner.try_lock() {\n                Ok(MutexGuard::new(self)?)\n            } else {\n                Err(TryLockError::WouldBlock)\n            }\n        }\n    }\n\n    /// Determines whether the mutex is poisoned.\n    ///\n    /// If another thread is active, the mutex can still become poisoned at any\n    /// time. You should not trust a `false` value for program correctness\n    /// without additional synchronization.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex};\n    /// use std::thread;\n    ///\n    /// let mutex = Arc::new(Mutex::new(0));\n    /// let c_mutex = mutex.clone();\n    ///\n    /// let _ = thread::spawn(move || {\n    ///     let _lock = c_mutex.lock().unwrap();\n    ///     panic!(); // the mutex gets poisoned\n    /// }).join();\n    /// assert_eq!(mutex.is_poisoned(), true);\n    /// ```\n    #[inline]\n    #[stable(feature = \"sync_poison\", since = \"1.2.0\")]\n    pub fn is_poisoned(&self) -> bool {\n        self.poison.get()\n    }\n\n    /// Consumes this mutex, returning the underlying data.\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return an error instead.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Mutex;\n    ///\n    /// let mutex = Mutex::new(0);\n    /// assert_eq!(mutex.into_inner().unwrap(), 0);\n    /// ```\n    #[stable(feature = \"mutex_into_inner\", since = \"1.6.0\")]\n    pub fn into_inner(self) -> LockResult<T> where T: Sized {\n        // We know statically that there are no outstanding references to\n        // `self` so there's no need to lock the inner mutex.\n        //\n        // To get the inner value, we'd like to call `data.into_inner()`,\n        // but because `Mutex` impl-s `Drop`, we can't move out of it, so\n        // we'll have to destructure it manually instead.\n        unsafe {\n            // Like `let Mutex { inner, poison, data } = self`.\n            let (inner, poison, data) = {\n                let Mutex { ref inner, ref poison, ref data } = self;\n                (ptr::read(inner), ptr::read(poison), ptr::read(data))\n            };\n            mem::forget(self);\n            inner.destroy();  // Keep in sync with the `Drop` impl.\n            drop(inner);\n\n            poison::map_result(poison.borrow(), |_| data.into_inner())\n        }\n    }\n\n    /// Returns a mutable reference to the underlying data.\n    ///\n    /// Since this call borrows the `Mutex` mutably, no actual locking needs to\n    /// take place---the mutable borrow statically guarantees no locks exist.\n    ///\n    /// # Errors\n    ///\n    /// If another user of this mutex panicked while holding the mutex, then\n    /// this call will return an error instead.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Mutex;\n    ///\n    /// let mut mutex = Mutex::new(0);\n    /// *mutex.get_mut().unwrap() = 10;\n    /// assert_eq!(*mutex.lock().unwrap(), 10);\n    /// ```\n    #[stable(feature = \"mutex_get_mut\", since = \"1.6.0\")]\n    pub fn get_mut(&mut self) -> LockResult<&mut T> {\n        // We know statically that there are no other references to `self`, so\n        // there's no need to lock the inner mutex.\n        let data = unsafe { &mut *self.data.get() };\n        poison::map_result(self.poison.borrow(), |_| data )\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl<#[may_dangle] T: ?Sized> Drop for Mutex<T> {\n    fn drop(&mut self) {\n        // This is actually safe b/c we know that there is no further usage of\n        // this mutex (it's up to the user to arrange for a mutex to get\n        // dropped, that's not our job)\n        //\n        // IMPORTANT: This code must be kept in sync with `Mutex::into_inner`.\n        unsafe { self.inner.destroy() }\n    }\n}\n\n#[stable(feature = \"mutex_from\", since = \"1.24.0\")]\nimpl<T> From<T> for Mutex<T> {\n    /// Creates a new mutex in an unlocked state ready for use.\n    /// This is equivalent to [`Mutex::new`].\n    fn from(t: T) -> Self {\n        Mutex::new(t)\n    }\n}\n\n#[stable(feature = \"mutex_default\", since = \"1.10.0\")]\nimpl<T: ?Sized + Default> Default for Mutex<T> {\n    /// Creates a `Mutex<T>`, with the `Default` value for T.\n    fn default() -> Mutex<T> {\n        Mutex::new(Default::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<T: ?Sized + fmt::Debug> fmt::Debug for Mutex<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match self.try_lock() {\n            Ok(guard) => f.debug_struct(\"Mutex\").field(\"data\", &&*guard).finish(),\n            Err(TryLockError::Poisoned(err)) => {\n                f.debug_struct(\"Mutex\").field(\"data\", &&**err.get_ref()).finish()\n            },\n            Err(TryLockError::WouldBlock) => {\n                struct LockedPlaceholder;\n                impl fmt::Debug for LockedPlaceholder {\n                    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(\"<locked>\") }\n                }\n\n                f.debug_struct(\"Mutex\").field(\"data\", &LockedPlaceholder).finish()\n            }\n        }\n    }\n}\n\nimpl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {\n    unsafe fn new(lock: &'mutex Mutex<T>) -> LockResult<MutexGuard<'mutex, T>> {\n        poison::map_result(lock.poison.borrow(), |guard| {\n            MutexGuard {\n                __lock: lock,\n                __poison: guard,\n            }\n        })\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'mutex, T: ?Sized> Deref for MutexGuard<'mutex, T> {\n    type Target = T;\n\n    fn deref(&self) -> &T {\n        unsafe { &*self.__lock.data.get() }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'mutex, T: ?Sized> DerefMut for MutexGuard<'mutex, T> {\n    fn deref_mut(&mut self) -> &mut T {\n        unsafe { &mut *self.__lock.data.get() }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: ?Sized> Drop for MutexGuard<'a, T> {\n    #[inline]\n    fn drop(&mut self) {\n        unsafe {\n            self.__lock.poison.done(&self.__poison);\n            self.__lock.inner.raw_unlock();\n        }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'a, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"MutexGuard\")\n            .field(\"lock\", &self.__lock)\n            .finish()\n    }\n}\n\n#[stable(feature = \"std_guard_impls\", since = \"1.20.0\")]\nimpl<'a, T: ?Sized + fmt::Display> fmt::Display for MutexGuard<'a, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        (**self).fmt(f)\n    }\n}\n\npub fn guard_lock<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a sys::Mutex {\n    &guard.__lock.inner\n}\n\npub fn guard_poison<'a, T: ?Sized>(guard: &MutexGuard<'a, T>) -> &'a poison::Flag {\n    &guard.__lock.poison\n}\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use sync::mpsc::channel;\n    use sync::{Arc, Mutex, Condvar};\n    use sync::atomic::{AtomicUsize, Ordering};\n    use thread;\n\n    struct Packet<T>(Arc<(Mutex<T>, Condvar)>);\n\n    #[derive(Eq, PartialEq, Debug)]\n    struct NonCopy(i32);\n\n    #[test]\n    fn smoke() {\n        let m = Mutex::new(());\n        drop(m.lock().unwrap());\n        drop(m.lock().unwrap());\n    }\n\n    #[test]\n    fn lots_and_lots() {\n        const J: u32 = 1000;\n        const K: u32 = 3;\n\n        let m = Arc::new(Mutex::new(0));\n\n        fn inc(m: &Mutex<u32>) {\n            for _ in 0..J {\n                *m.lock().unwrap() += 1;\n            }\n        }\n\n        let (tx, rx) = channel();\n        for _ in 0..K {\n            let tx2 = tx.clone();\n            let m2 = m.clone();\n            thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); });\n            let tx2 = tx.clone();\n            let m2 = m.clone();\n            thread::spawn(move|| { inc(&m2); tx2.send(()).unwrap(); });\n        }\n\n        drop(tx);\n        for _ in 0..2 * K {\n            rx.recv().unwrap();\n        }\n        assert_eq!(*m.lock().unwrap(), J * K * 2);\n    }\n\n    #[test]\n    fn try_lock() {\n        let m = Mutex::new(());\n        *m.try_lock().unwrap() = ();\n    }\n\n    #[test]\n    fn test_into_inner() {\n        let m = Mutex::new(NonCopy(10));\n        assert_eq!(m.into_inner().unwrap(), NonCopy(10));\n    }\n\n    #[test]\n    fn test_into_inner_drop() {\n        struct Foo(Arc<AtomicUsize>);\n        impl Drop for Foo {\n            fn drop(&mut self) {\n                self.0.fetch_add(1, Ordering::SeqCst);\n            }\n        }\n        let num_drops = Arc::new(AtomicUsize::new(0));\n        let m = Mutex::new(Foo(num_drops.clone()));\n        assert_eq!(num_drops.load(Ordering::SeqCst), 0);\n        {\n            let _inner = m.into_inner().unwrap();\n            assert_eq!(num_drops.load(Ordering::SeqCst), 0);\n        }\n        assert_eq!(num_drops.load(Ordering::SeqCst), 1);\n    }\n\n    #[test]\n    fn test_into_inner_poison() {\n        let m = Arc::new(Mutex::new(NonCopy(10)));\n        let m2 = m.clone();\n        let _ = thread::spawn(move || {\n            let _lock = m2.lock().unwrap();\n            panic!(\"test panic in inner thread to poison mutex\");\n        }).join();\n\n        assert!(m.is_poisoned());\n        match Arc::try_unwrap(m).unwrap().into_inner() {\n            Err(e) => assert_eq!(e.into_inner(), NonCopy(10)),\n            Ok(x) => panic!(\"into_inner of poisoned Mutex is Ok: {:?}\", x),\n        }\n    }\n\n    #[test]\n    fn test_get_mut() {\n        let mut m = Mutex::new(NonCopy(10));\n        *m.get_mut().unwrap() = NonCopy(20);\n        assert_eq!(m.into_inner().unwrap(), NonCopy(20));\n    }\n\n    #[test]\n    fn test_get_mut_poison() {\n        let m = Arc::new(Mutex::new(NonCopy(10)));\n        let m2 = m.clone();\n        let _ = thread::spawn(move || {\n            let _lock = m2.lock().unwrap();\n            panic!(\"test panic in inner thread to poison mutex\");\n        }).join();\n\n        assert!(m.is_poisoned());\n        match Arc::try_unwrap(m).unwrap().get_mut() {\n            Err(e) => assert_eq!(*e.into_inner(), NonCopy(10)),\n            Ok(x) => panic!(\"get_mut of poisoned Mutex is Ok: {:?}\", x),\n        }\n    }\n\n    #[test]\n    fn test_mutex_arc_condvar() {\n        let packet = Packet(Arc::new((Mutex::new(false), Condvar::new())));\n        let packet2 = Packet(packet.0.clone());\n        let (tx, rx) = channel();\n        let _t = thread::spawn(move|| {\n            // wait until parent gets in\n            rx.recv().unwrap();\n            let &(ref lock, ref cvar) = &*packet2.0;\n            let mut lock = lock.lock().unwrap();\n            *lock = true;\n            cvar.notify_one();\n        });\n\n        let &(ref lock, ref cvar) = &*packet.0;\n        let mut lock = lock.lock().unwrap();\n        tx.send(()).unwrap();\n        assert!(!*lock);\n        while !*lock {\n            lock = cvar.wait(lock).unwrap();\n        }\n    }\n\n    #[test]\n    fn test_arc_condvar_poison() {\n        let packet = Packet(Arc::new((Mutex::new(1), Condvar::new())));\n        let packet2 = Packet(packet.0.clone());\n        let (tx, rx) = channel();\n\n        let _t = thread::spawn(move || -> () {\n            rx.recv().unwrap();\n            let &(ref lock, ref cvar) = &*packet2.0;\n            let _g = lock.lock().unwrap();\n            cvar.notify_one();\n            // Parent should fail when it wakes up.\n            panic!();\n        });\n\n        let &(ref lock, ref cvar) = &*packet.0;\n        let mut lock = lock.lock().unwrap();\n        tx.send(()).unwrap();\n        while *lock == 1 {\n            match cvar.wait(lock) {\n                Ok(l) => {\n                    lock = l;\n                    assert_eq!(*lock, 1);\n                }\n                Err(..) => break,\n            }\n        }\n    }\n\n    #[test]\n    fn test_mutex_arc_poison() {\n        let arc = Arc::new(Mutex::new(1));\n        assert!(!arc.is_poisoned());\n        let arc2 = arc.clone();\n        let _ = thread::spawn(move|| {\n            let lock = arc2.lock().unwrap();\n            assert_eq!(*lock, 2);\n        }).join();\n        assert!(arc.lock().is_err());\n        assert!(arc.is_poisoned());\n    }\n\n    #[test]\n    fn test_mutex_arc_nested() {\n        // Tests nested mutexes and access\n        // to underlying data.\n        let arc = Arc::new(Mutex::new(1));\n        let arc2 = Arc::new(Mutex::new(arc));\n        let (tx, rx) = channel();\n        let _t = thread::spawn(move|| {\n            let lock = arc2.lock().unwrap();\n            let lock2 = lock.lock().unwrap();\n            assert_eq!(*lock2, 1);\n            tx.send(()).unwrap();\n        });\n        rx.recv().unwrap();\n    }\n\n    #[test]\n    fn test_mutex_arc_access_in_unwind() {\n        let arc = Arc::new(Mutex::new(1));\n        let arc2 = arc.clone();\n        let _ = thread::spawn(move|| -> () {\n            struct Unwinder {\n                i: Arc<Mutex<i32>>,\n            }\n            impl Drop for Unwinder {\n                fn drop(&mut self) {\n                    *self.i.lock().unwrap() += 1;\n                }\n            }\n            let _u = Unwinder { i: arc2 };\n            panic!();\n        }).join();\n        let lock = arc.lock().unwrap();\n        assert_eq!(*lock, 2);\n    }\n\n    #[test]\n    fn test_mutex_unsized() {\n        let mutex: &Mutex<[i32]> = &Mutex::new([1, 2, 3]);\n        {\n            let b = &mut *mutex.lock().unwrap();\n            b[0] = 4;\n            b[2] = 5;\n        }\n        let comp: &[i32] = &[4, 2, 5];\n        assert_eq!(&*mutex.lock().unwrap(), comp);\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A \"once initialization\" primitive\n//!\n//! This primitive is meant to be used to run one-time initialization. An\n//! example use case would be for initializing an FFI library.\n\n// A \"once\" is a relatively simple primitive, and it's also typically provided\n// by the OS as well (see `pthread_once` or `InitOnceExecuteOnce`). The OS\n// primitives, however, tend to have surprising restrictions, such as the Unix\n// one doesn't allow an argument to be passed to the function.\n//\n// As a result, we end up implementing it ourselves in the standard library.\n// This also gives us the opportunity to optimize the implementation a bit which\n// should help the fast path on call sites. Consequently, let's explain how this\n// primitive works now!\n//\n// So to recap, the guarantees of a Once are that it will call the\n// initialization closure at most once, and it will never return until the one\n// that's running has finished running. This means that we need some form of\n// blocking here while the custom callback is running at the very least.\n// Additionally, we add on the restriction of **poisoning**. Whenever an\n// initialization closure panics, the Once enters a \"poisoned\" state which means\n// that all future calls will immediately panic as well.\n//\n// So to implement this, one might first reach for a `Mutex`, but those cannot\n// be put into a `static`. It also gets a lot harder with poisoning to figure\n// out when the mutex needs to be deallocated because it's not after the closure\n// finishes, but after the first successful closure finishes.\n//\n// All in all, this is instead implemented with atomics and lock-free\n// operations! Whee! Each `Once` has one word of atomic state, and this state is\n// CAS'd on to determine what to do. There are four possible state of a `Once`:\n//\n// * Incomplete - no initialization has run yet, and no thread is currently\n//                using the Once.\n// * Poisoned - some thread has previously attempted to initialize the Once, but\n//              it panicked, so the Once is now poisoned. There are no other\n//              threads currently accessing this Once.\n// * Running - some thread is currently attempting to run initialization. It may\n//             succeed, so all future threads need to wait for it to finish.\n//             Note that this state is accompanied with a payload, described\n//             below.\n// * Complete - initialization has completed and all future calls should finish\n//              immediately.\n//\n// With 4 states we need 2 bits to encode this, and we use the remaining bits\n// in the word we have allocated as a queue of threads waiting for the thread\n// responsible for entering the RUNNING state. This queue is just a linked list\n// of Waiter nodes which is monotonically increasing in size. Each node is\n// allocated on the stack, and whenever the running closure finishes it will\n// consume the entire queue and notify all waiters they should try again.\n//\n// You'll find a few more details in the implementation, but that's the gist of\n// it!\n\nuse fmt;\nuse marker;\nuse ptr;\nuse sync::atomic::{AtomicUsize, AtomicBool, Ordering};\nuse thread::{self, Thread};\n\n/// A synchronization primitive which can be used to run a one-time global\n/// initialization. Useful for one-time initialization for FFI or related\n/// functionality. This type can only be constructed with the [`ONCE_INIT`]\n/// value or the equivalent [`Once::new`] constructor.\n///\n/// [`ONCE_INIT`]: constant.ONCE_INIT.html\n/// [`Once::new`]: struct.Once.html#method.new\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::Once;\n///\n/// static START: Once = Once::new();\n///\n/// START.call_once(|| {\n///     // run initialization here\n/// });\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Once {\n    // This `state` word is actually an encoded version of just a pointer to a\n    // `Waiter`, so we add the `PhantomData` appropriately.\n    state: AtomicUsize,\n    _marker: marker::PhantomData<*mut Waiter>,\n}\n\n// The `PhantomData` of a raw pointer removes these two auto traits, but we\n// enforce both below in the implementation so this should be safe to add.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl Sync for Once {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nunsafe impl Send for Once {}\n\n/// State yielded to [`call_once_force`]\u2019s closure parameter. The state can be\n/// used to query the poison status of the [`Once`].\n///\n/// [`call_once_force`]: struct.Once.html#method.call_once_force\n/// [`Once`]: struct.Once.html\n#[unstable(feature = \"once_poison\", issue = \"33577\")]\n#[derive(Debug)]\npub struct OnceState {\n    poisoned: bool,\n}\n\n/// Initialization value for static [`Once`] values.\n///\n/// [`Once`]: struct.Once.html\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::{Once, ONCE_INIT};\n///\n/// static START: Once = ONCE_INIT;\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const ONCE_INIT: Once = Once::new();\n\n// Four states that a Once can be in, encoded into the lower bits of `state` in\n// the Once structure.\nconst INCOMPLETE: usize = 0x0;\nconst POISONED: usize = 0x1;\nconst RUNNING: usize = 0x2;\nconst COMPLETE: usize = 0x3;\n\n// Mask to learn about the state. All other bits are the queue of waiters if\n// this is in the RUNNING state.\nconst STATE_MASK: usize = 0x3;\n\n// Representation of a node in the linked list of waiters in the RUNNING state.\nstruct Waiter {\n    thread: Option<Thread>,\n    signaled: AtomicBool,\n    next: *mut Waiter,\n}\n\n// Helper struct used to clean up after a closure call with a `Drop`\n// implementation to also run on panic.\nstruct Finish<'a> {\n    panicked: bool,\n    me: &'a Once,\n}\n\nimpl Once {\n    /// Creates a new `Once` value.\n    #[stable(feature = \"once_new\", since = \"1.2.0\")]\n    pub const fn new() -> Once {\n        Once {\n            state: AtomicUsize::new(INCOMPLETE),\n            _marker: marker::PhantomData,\n        }\n    }\n\n    /// Performs an initialization routine once and only once. The given closure\n    /// will be executed if this is the first time `call_once` has been called,\n    /// and otherwise the routine will *not* be invoked.\n    ///\n    /// This method will block the calling thread if another initialization\n    /// routine is currently running.\n    ///\n    /// When this function returns, it is guaranteed that some initialization\n    /// has run and completed (it may not be the closure specified). It is also\n    /// guaranteed that any memory writes performed by the executed closure can\n    /// be reliably observed by other threads at this point (there is a\n    /// happens-before relation between the closure and code executing after the\n    /// return).\n    ///\n    /// If the given closure recursively invokes `call_once` on the same `Once`\n    /// instance the exact behavior is not specified, allowed outcomes are\n    /// a panic or a deadlock.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Once;\n    ///\n    /// static mut VAL: usize = 0;\n    /// static INIT: Once = Once::new();\n    ///\n    /// // Accessing a `static mut` is unsafe much of the time, but if we do so\n    /// // in a synchronized fashion (e.g. write once or read all) then we're\n    /// // good to go!\n    /// //\n    /// // This function will only call `expensive_computation` once, and will\n    /// // otherwise always return the value returned from the first invocation.\n    /// fn get_cached_val() -> usize {\n    ///     unsafe {\n    ///         INIT.call_once(|| {\n    ///             VAL = expensive_computation();\n    ///         });\n    ///         VAL\n    ///     }\n    /// }\n    ///\n    /// fn expensive_computation() -> usize {\n    ///     // ...\n    /// # 2\n    /// }\n    /// ```\n    ///\n    /// # Panics\n    ///\n    /// The closure `f` will only be executed once if this is called\n    /// concurrently amongst many threads. If that closure panics, however, then\n    /// it will *poison* this `Once` instance, causing all future invocations of\n    /// `call_once` to also panic.\n    ///\n    /// This is similar to [poisoning with mutexes][poison].\n    ///\n    /// [poison]: struct.Mutex.html#poisoning\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn call_once<F>(&self, f: F) where F: FnOnce() {\n        // Fast path check\n        if self.is_completed() {\n            return;\n        }\n\n        let mut f = Some(f);\n        self.call_inner(false, &mut |_| f.take().unwrap()());\n    }\n\n    /// Performs the same function as [`call_once`] except ignores poisoning.\n    ///\n    /// Unlike [`call_once`], if this `Once` has been poisoned (i.e. a previous\n    /// call to `call_once` or `call_once_force` caused a panic), calling\n    /// `call_once_force` will still invoke the closure `f` and will _not_\n    /// result in an immediate panic. If `f` panics, the `Once` will remain\n    /// in a poison state. If `f` does _not_ panic, the `Once` will no\n    /// longer be in a poison state and all future calls to `call_once` or\n    /// `call_one_force` will no-op.\n    ///\n    /// The closure `f` is yielded a [`OnceState`] structure which can be used\n    /// to query the poison status of the `Once`.\n    ///\n    /// [`call_once`]: struct.Once.html#method.call_once\n    /// [`OnceState`]: struct.OnceState.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(once_poison)]\n    ///\n    /// use std::sync::Once;\n    /// use std::thread;\n    ///\n    /// static INIT: Once = Once::new();\n    ///\n    /// // poison the once\n    /// let handle = thread::spawn(|| {\n    ///     INIT.call_once(|| panic!());\n    /// });\n    /// assert!(handle.join().is_err());\n    ///\n    /// // poisoning propagates\n    /// let handle = thread::spawn(|| {\n    ///     INIT.call_once(|| {});\n    /// });\n    /// assert!(handle.join().is_err());\n    ///\n    /// // call_once_force will still run and reset the poisoned state\n    /// INIT.call_once_force(|state| {\n    ///     assert!(state.poisoned());\n    /// });\n    ///\n    /// // once any success happens, we stop propagating the poison\n    /// INIT.call_once(|| {});\n    /// ```\n    #[unstable(feature = \"once_poison\", issue = \"33577\")]\n    pub fn call_once_force<F>(&self, f: F) where F: FnOnce(&OnceState) {\n        // Fast path check\n        if self.is_completed() {\n            return;\n        }\n\n        let mut f = Some(f);\n        self.call_inner(true, &mut |p| {\n            f.take().unwrap()(&OnceState { poisoned: p })\n        });\n    }\n\n    /// Returns true if some `call_once` call has completed\n    /// successfully. Specifically, `is_completed` will return false in\n    /// the following situations:\n    ///   * `call_once` was not called at all,\n    ///   * `call_once` was called, but has not yet completed,\n    ///   * the `Once` instance is poisoned\n    ///\n    /// It is also possible that immediately after `is_completed`\n    /// returns false, some other thread finishes executing\n    /// `call_once`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(once_is_completed)]\n    /// use std::sync::Once;\n    ///\n    /// static INIT: Once = Once::new();\n    ///\n    /// assert_eq!(INIT.is_completed(), false);\n    /// INIT.call_once(|| {\n    ///     assert_eq!(INIT.is_completed(), false);\n    /// });\n    /// assert_eq!(INIT.is_completed(), true);\n    /// ```\n    ///\n    /// ```\n    /// #![feature(once_is_completed)]\n    /// use std::sync::Once;\n    /// use std::thread;\n    ///\n    /// static INIT: Once = Once::new();\n    ///\n    /// assert_eq!(INIT.is_completed(), false);\n    /// let handle = thread::spawn(|| {\n    ///     INIT.call_once(|| panic!());\n    /// });\n    /// assert!(handle.join().is_err());\n    /// assert_eq!(INIT.is_completed(), false);\n    /// ```\n    #[unstable(feature = \"once_is_completed\", issue = \"54890\")]\n    #[inline]\n    pub fn is_completed(&self) -> bool {\n        // An `Acquire` load is enough because that makes all the initialization\n        // operations visible to us, and, this being a fast path, weaker\n        // ordering helps with performance. This `Acquire` synchronizes with\n        // `SeqCst` operations on the slow path.\n        self.state.load(Ordering::Acquire) == COMPLETE\n    }\n\n    // This is a non-generic function to reduce the monomorphization cost of\n    // using `call_once` (this isn't exactly a trivial or small implementation).\n    //\n    // Additionally, this is tagged with `#[cold]` as it should indeed be cold\n    // and it helps let LLVM know that calls to this function should be off the\n    // fast path. Essentially, this should help generate more straight line code\n    // in LLVM.\n    //\n    // Finally, this takes an `FnMut` instead of a `FnOnce` because there's\n    // currently no way to take an `FnOnce` and call it via virtual dispatch\n    // without some allocation overhead.\n    #[cold]\n    fn call_inner(&self,\n                  ignore_poisoning: bool,\n                  init: &mut dyn FnMut(bool)) {\n\n        // This cold path uses SeqCst consistently because the\n        // performance difference really does not matter there, and\n        // SeqCst minimizes the chances of something going wrong.\n        let mut state = self.state.load(Ordering::SeqCst);\n\n        'outer: loop {\n            match state {\n                // If we're complete, then there's nothing to do, we just\n                // jettison out as we shouldn't run the closure.\n                COMPLETE => return,\n\n                // If we're poisoned and we're not in a mode to ignore\n                // poisoning, then we panic here to propagate the poison.\n                POISONED if !ignore_poisoning => {\n                    panic!(\"Once instance has previously been poisoned\");\n                }\n\n                // Otherwise if we see a poisoned or otherwise incomplete state\n                // we will attempt to move ourselves into the RUNNING state. If\n                // we succeed, then the queue of waiters starts at null (all 0\n                // bits).\n                POISONED |\n                INCOMPLETE => {\n                    let old = self.state.compare_and_swap(state, RUNNING,\n                                                          Ordering::SeqCst);\n                    if old != state {\n                        state = old;\n                        continue\n                    }\n\n                    // Run the initialization routine, letting it know if we're\n                    // poisoned or not. The `Finish` struct is then dropped, and\n                    // the `Drop` implementation here is responsible for waking\n                    // up other waiters both in the normal return and panicking\n                    // case.\n                    let mut complete = Finish {\n                        panicked: true,\n                        me: self,\n                    };\n                    init(state == POISONED);\n                    complete.panicked = false;\n                    return\n                }\n\n                // All other values we find should correspond to the RUNNING\n                // state with an encoded waiter list in the more significant\n                // bits. We attempt to enqueue ourselves by moving us to the\n                // head of the list and bail out if we ever see a state that's\n                // not RUNNING.\n                _ => {\n                    assert!(state & STATE_MASK == RUNNING);\n                    let mut node = Waiter {\n                        thread: Some(thread::current()),\n                        signaled: AtomicBool::new(false),\n                        next: ptr::null_mut(),\n                    };\n                    let me = &mut node as *mut Waiter as usize;\n                    assert!(me & STATE_MASK == 0);\n\n                    while state & STATE_MASK == RUNNING {\n                        node.next = (state & !STATE_MASK) as *mut Waiter;\n                        let old = self.state.compare_and_swap(state,\n                                                              me | RUNNING,\n                                                              Ordering::SeqCst);\n                        if old != state {\n                            state = old;\n                            continue\n                        }\n\n                        // Once we've enqueued ourselves, wait in a loop.\n                        // Afterwards reload the state and continue with what we\n                        // were doing from before.\n                        while !node.signaled.load(Ordering::SeqCst) {\n                            thread::park();\n                        }\n                        state = self.state.load(Ordering::SeqCst);\n                        continue 'outer\n                    }\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Once {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Once { .. }\")\n    }\n}\n\nimpl<'a> Drop for Finish<'a> {\n    fn drop(&mut self) {\n        // Swap out our state with however we finished. We should only ever see\n        // an old state which was RUNNING.\n        let queue = if self.panicked {\n            self.me.state.swap(POISONED, Ordering::SeqCst)\n        } else {\n            self.me.state.swap(COMPLETE, Ordering::SeqCst)\n        };\n        assert_eq!(queue & STATE_MASK, RUNNING);\n\n        // Decode the RUNNING to a list of waiters, then walk that entire list\n        // and wake them up. Note that it is crucial that after we store `true`\n        // in the node it can be free'd! As a result we load the `thread` to\n        // signal ahead of time and then unpark it after the store.\n        unsafe {\n            let mut queue = (queue & !STATE_MASK) as *mut Waiter;\n            while !queue.is_null() {\n                let next = (*queue).next;\n                let thread = (*queue).thread.take().unwrap();\n                (*queue).signaled.store(true, Ordering::SeqCst);\n                thread.unpark();\n                queue = next;\n            }\n        }\n    }\n}\n\nimpl OnceState {\n    /// Returns whether the associated [`Once`] was poisoned prior to the\n    /// invocation of the closure passed to [`call_once_force`].\n    ///\n    /// [`call_once_force`]: struct.Once.html#method.call_once_force\n    /// [`Once`]: struct.Once.html\n    ///\n    /// # Examples\n    ///\n    /// A poisoned `Once`:\n    ///\n    /// ```\n    /// #![feature(once_poison)]\n    ///\n    /// use std::sync::Once;\n    /// use std::thread;\n    ///\n    /// static INIT: Once = Once::new();\n    ///\n    /// // poison the once\n    /// let handle = thread::spawn(|| {\n    ///     INIT.call_once(|| panic!());\n    /// });\n    /// assert!(handle.join().is_err());\n    ///\n    /// INIT.call_once_force(|state| {\n    ///     assert!(state.poisoned());\n    /// });\n    /// ```\n    ///\n    /// An unpoisoned `Once`:\n    ///\n    /// ```\n    /// #![feature(once_poison)]\n    ///\n    /// use std::sync::Once;\n    ///\n    /// static INIT: Once = Once::new();\n    ///\n    /// INIT.call_once_force(|state| {\n    ///     assert!(!state.poisoned());\n    /// });\n    #[unstable(feature = \"once_poison\", issue = \"33577\")]\n    pub fn poisoned(&self) -> bool {\n        self.poisoned\n    }\n}\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use panic;\n    use sync::mpsc::channel;\n    use thread;\n    use super::Once;\n\n    #[test]\n    fn smoke_once() {\n        static O: Once = Once::new();\n        let mut a = 0;\n        O.call_once(|| a += 1);\n        assert_eq!(a, 1);\n        O.call_once(|| a += 1);\n        assert_eq!(a, 1);\n    }\n\n    #[test]\n    fn stampede_once() {\n        static O: Once = Once::new();\n        static mut RUN: bool = false;\n\n        let (tx, rx) = channel();\n        for _ in 0..10 {\n            let tx = tx.clone();\n            thread::spawn(move|| {\n                for _ in 0..4 { thread::yield_now() }\n                unsafe {\n                    O.call_once(|| {\n                        assert!(!RUN);\n                        RUN = true;\n                    });\n                    assert!(RUN);\n                }\n                tx.send(()).unwrap();\n            });\n        }\n\n        unsafe {\n            O.call_once(|| {\n                assert!(!RUN);\n                RUN = true;\n            });\n            assert!(RUN);\n        }\n\n        for _ in 0..10 {\n            rx.recv().unwrap();\n        }\n    }\n\n    #[test]\n    fn poison_bad() {\n        static O: Once = Once::new();\n\n        // poison the once\n        let t = panic::catch_unwind(|| {\n            O.call_once(|| panic!());\n        });\n        assert!(t.is_err());\n\n        // poisoning propagates\n        let t = panic::catch_unwind(|| {\n            O.call_once(|| {});\n        });\n        assert!(t.is_err());\n\n        // we can subvert poisoning, however\n        let mut called = false;\n        O.call_once_force(|p| {\n            called = true;\n            assert!(p.poisoned())\n        });\n        assert!(called);\n\n        // once any success happens, we stop propagating the poison\n        O.call_once(|| {});\n    }\n\n    #[test]\n    fn wait_for_force_to_finish() {\n        static O: Once = Once::new();\n\n        // poison the once\n        let t = panic::catch_unwind(|| {\n            O.call_once(|| panic!());\n        });\n        assert!(t.is_err());\n\n        // make sure someone's waiting inside the once via a force\n        let (tx1, rx1) = channel();\n        let (tx2, rx2) = channel();\n        let t1 = thread::spawn(move || {\n            O.call_once_force(|p| {\n                assert!(p.poisoned());\n                tx1.send(()).unwrap();\n                rx2.recv().unwrap();\n            });\n        });\n\n        rx1.recv().unwrap();\n\n        // put another waiter on the once\n        let t2 = thread::spawn(|| {\n            let mut called = false;\n            O.call_once(|| {\n                called = true;\n            });\n            assert!(!called);\n        });\n\n        tx2.send(()).unwrap();\n\n        assert!(t1.join().is_ok());\n        assert!(t2.join().is_ok());\n\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse sync::atomic::{AtomicUsize, Ordering};\nuse sync::{mutex, MutexGuard, PoisonError};\nuse sys_common::condvar as sys;\nuse sys_common::mutex as sys_mutex;\nuse sys_common::poison::{self, LockResult};\nuse time::{Duration, Instant};\n\n/// A type indicating whether a timed wait on a condition variable returned\n/// due to a time out or not.\n///\n/// It is returned by the [`wait_timeout`] method.\n///\n/// [`wait_timeout`]: struct.Condvar.html#method.wait_timeout\n#[derive(Debug, PartialEq, Eq, Copy, Clone)]\n#[stable(feature = \"wait_timeout\", since = \"1.5.0\")]\npub struct WaitTimeoutResult(bool);\n\nimpl WaitTimeoutResult {\n    /// Returns whether the wait was known to have timed out.\n    ///\n    /// # Examples\n    ///\n    /// This example spawns a thread which will update the boolean value and\n    /// then wait 100 milliseconds before notifying the condvar.\n    ///\n    /// The main thread will wait with a timeout on the condvar and then leave\n    /// once the boolean has been updated and notified.\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    /// use std::time::Duration;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///\n    ///     // Let's wait 20 milliseconds before notifying the condvar.\n    ///     thread::sleep(Duration::from_millis(20));\n    ///\n    ///     let mut started = lock.lock().unwrap();\n    ///     // We update the boolean value.\n    ///     *started = true;\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// loop {\n    ///     // Let's put a timeout on the condvar's wait.\n    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();\n    ///     // 10 milliseconds have passed, or maybe the value changed!\n    ///     started = result.0;\n    ///     if *started == true {\n    ///         // We received the notification and the value has been updated, we can leave.\n    ///         break\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"wait_timeout\", since = \"1.5.0\")]\n    pub fn timed_out(&self) -> bool {\n        self.0\n    }\n}\n\n/// A Condition Variable\n///\n/// Condition variables represent the ability to block a thread such that it\n/// consumes no CPU time while waiting for an event to occur. Condition\n/// variables are typically associated with a boolean predicate (a condition)\n/// and a mutex. The predicate is always verified inside of the mutex before\n/// determining that a thread must block.\n///\n/// Functions in this module will block the current **thread** of execution and\n/// are bindings to system-provided condition variables where possible. Note\n/// that this module places one additional restriction over the system condition\n/// variables: each condvar can be used with precisely one mutex at runtime. Any\n/// attempt to use multiple mutexes on the same condition variable will result\n/// in a runtime panic. If this is not desired, then the unsafe primitives in\n/// `sys` do not have this restriction but may result in undefined behavior.\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::{Arc, Mutex, Condvar};\n/// use std::thread;\n///\n/// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n/// let pair2 = pair.clone();\n///\n/// // Inside of our lock, spawn a new thread, and then wait for it to start.\n/// thread::spawn(move|| {\n///     let &(ref lock, ref cvar) = &*pair2;\n///     let mut started = lock.lock().unwrap();\n///     *started = true;\n///     // We notify the condvar that the value has changed.\n///     cvar.notify_one();\n/// });\n///\n/// // Wait for the thread to start up.\n/// let &(ref lock, ref cvar) = &*pair;\n/// let mut started = lock.lock().unwrap();\n/// while !*started {\n///     started = cvar.wait(started).unwrap();\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Condvar {\n    inner: Box<sys::Condvar>,\n    mutex: AtomicUsize,\n}\n\nimpl Condvar {\n    /// Creates a new condition variable which is ready to be waited on and\n    /// notified.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Condvar;\n    ///\n    /// let condvar = Condvar::new();\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> Condvar {\n        let mut c = Condvar {\n            inner: box sys::Condvar::new(),\n            mutex: AtomicUsize::new(0),\n        };\n        unsafe {\n            c.inner.init();\n        }\n        c\n    }\n\n    /// Blocks the current thread until this condition variable receives a\n    /// notification.\n    ///\n    /// This function will atomically unlock the mutex specified (represented by\n    /// `guard`) and block the current thread. This means that any calls\n    /// to [`notify_one`] or [`notify_all`] which happen logically after the\n    /// mutex is unlocked are candidates to wake this thread up. When this\n    /// function call returns, the lock specified will have been re-acquired.\n    ///\n    /// Note that this function is susceptible to spurious wakeups. Condition\n    /// variables normally have a boolean predicate associated with them, and\n    /// the predicate must always be checked each time this function returns to\n    /// protect against spurious wakeups.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if the mutex being waited on is\n    /// poisoned when this thread re-acquires the lock. For more information,\n    /// see information about [poisoning] on the [`Mutex`] type.\n    ///\n    /// # Panics\n    ///\n    /// This function will [`panic!`] if it is used with more than one mutex\n    /// over time. Each condition variable is dynamically bound to exactly one\n    /// mutex to ensure defined behavior across platforms. If this functionality\n    /// is not desired, then unsafe primitives in `sys` are provided.\n    ///\n    /// [`notify_one`]: #method.notify_one\n    /// [`notify_all`]: #method.notify_all\n    /// [poisoning]: ../sync/struct.Mutex.html#poisoning\n    /// [`Mutex`]: ../sync/struct.Mutex.html\n    /// [`panic!`]: ../../std/macro.panic.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// // As long as the value inside the `Mutex` is false, we wait.\n    /// while !*started {\n    ///     started = cvar.wait(started).unwrap();\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn wait<'a, T>(&self, guard: MutexGuard<'a, T>)\n                       -> LockResult<MutexGuard<'a, T>> {\n        let poisoned = unsafe {\n            let lock = mutex::guard_lock(&guard);\n            self.verify(lock);\n            self.inner.wait(lock);\n            mutex::guard_poison(&guard).get()\n        };\n        if poisoned {\n            Err(PoisonError::new(guard))\n        } else {\n            Ok(guard)\n        }\n    }\n\n    /// Blocks the current thread until this condition variable receives a\n    /// notification and the required condition is met. Spurious wakeups are\n    /// ignored and this function will only return once the condition has been\n    /// met.\n    ///\n    /// This function will atomically unlock the mutex specified (represented by\n    /// `guard`) and block the current thread. This means that any calls\n    /// to [`notify_one`] or [`notify_all`] which happen logically after the\n    /// mutex is unlocked are candidates to wake this thread up. When this\n    /// function call returns, the lock specified will have been re-acquired.\n    ///\n    /// # Errors\n    ///\n    /// This function will return an error if the mutex being waited on is\n    /// poisoned when this thread re-acquires the lock. For more information,\n    /// see information about [poisoning] on the [`Mutex`] type.\n    ///\n    /// [`notify_one`]: #method.notify_one\n    /// [`notify_all`]: #method.notify_all\n    /// [poisoning]: ../sync/struct.Mutex.html#poisoning\n    /// [`Mutex`]: ../sync/struct.Mutex.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(wait_until)]\n    ///\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// // As long as the value inside the `Mutex` is false, we wait.\n    /// let _guard = cvar.wait_until(lock.lock().unwrap(), |started| { *started }).unwrap();\n    /// ```\n    #[unstable(feature = \"wait_until\", issue = \"47960\")]\n    pub fn wait_until<'a, T, F>(&self, mut guard: MutexGuard<'a, T>,\n                                mut condition: F)\n                                -> LockResult<MutexGuard<'a, T>>\n                                where F: FnMut(&mut T) -> bool {\n        while !condition(&mut *guard) {\n            guard = self.wait(guard)?;\n        }\n        Ok(guard)\n    }\n\n\n    /// Waits on this condition variable for a notification, timing out after a\n    /// specified duration.\n    ///\n    /// The semantics of this function are equivalent to [`wait`]\n    /// except that the thread will be blocked for roughly no longer\n    /// than `ms` milliseconds. This method should not be used for\n    /// precise timing due to anomalies such as preemption or platform\n    /// differences that may not cause the maximum amount of time\n    /// waited to be precisely `ms`.\n    ///\n    /// Note that the best effort is made to ensure that the time waited is\n    /// measured with a monotonic clock, and not affected by the changes made to\n    /// the system time.\n    ///\n    /// The returned boolean is `false` only if the timeout is known\n    /// to have elapsed.\n    ///\n    /// Like [`wait`], the lock specified will be re-acquired when this function\n    /// returns, regardless of whether the timeout elapsed or not.\n    ///\n    /// [`wait`]: #method.wait\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// // As long as the value inside the `Mutex` is false, we wait.\n    /// loop {\n    ///     let result = cvar.wait_timeout_ms(started, 10).unwrap();\n    ///     // 10 milliseconds have passed, or maybe the value changed!\n    ///     started = result.0;\n    ///     if *started == true {\n    ///         // We received the notification and the value has been updated, we can leave.\n    ///         break\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.6.0\", reason = \"replaced by `std::sync::Condvar::wait_timeout`\")]\n    pub fn wait_timeout_ms<'a, T>(&self, guard: MutexGuard<'a, T>, ms: u32)\n                                  -> LockResult<(MutexGuard<'a, T>, bool)> {\n        let res = self.wait_timeout(guard, Duration::from_millis(ms as u64));\n        poison::map_result(res, |(a, b)| {\n            (a, !b.timed_out())\n        })\n    }\n\n    /// Waits on this condition variable for a notification, timing out after a\n    /// specified duration.\n    ///\n    /// The semantics of this function are equivalent to [`wait`] except that\n    /// the thread will be blocked for roughly no longer than `dur`. This\n    /// method should not be used for precise timing due to anomalies such as\n    /// preemption or platform differences that may not cause the maximum\n    /// amount of time waited to be precisely `dur`.\n    ///\n    /// Note that the best effort is made to ensure that the time waited is\n    /// measured with a monotonic clock, and not affected by the changes made to\n    /// the system time.  This function is susceptible to spurious wakeups.\n    /// Condition variables normally have a boolean predicate associated with\n    /// them, and the predicate must always be checked each time this function\n    /// returns to protect against spurious wakeups.  Additionally, it is\n    /// typically desirable for the time-out to not exceed some duration in\n    /// spite of spurious wakes, thus the sleep-duration is decremented by the\n    /// amount slept.  Alternatively, use the `wait_timeout_until` method\n    /// to wait until a condition is met with a total time-out regardless\n    /// of spurious wakes.\n    ///\n    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is\n    /// known to have elapsed.\n    ///\n    /// Like [`wait`], the lock specified will be re-acquired when this function\n    /// returns, regardless of whether the timeout elapsed or not.\n    ///\n    /// [`wait`]: #method.wait\n    /// [`wait_timeout_until`]: #method.wait_timeout_until\n    /// [`WaitTimeoutResult`]: struct.WaitTimeoutResult.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    /// use std::time::Duration;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // wait for the thread to start up\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// // as long as the value inside the `Mutex` is false, we wait\n    /// loop {\n    ///     let result = cvar.wait_timeout(started, Duration::from_millis(10)).unwrap();\n    ///     // 10 milliseconds have passed, or maybe the value changed!\n    ///     started = result.0;\n    ///     if *started == true {\n    ///         // We received the notification and the value has been updated, we can leave.\n    ///         break\n    ///     }\n    /// }\n    /// ```\n    #[stable(feature = \"wait_timeout\", since = \"1.5.0\")]\n    pub fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>,\n                               dur: Duration)\n                               -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)> {\n        let (poisoned, result) = unsafe {\n            let lock = mutex::guard_lock(&guard);\n            self.verify(lock);\n            let success = self.inner.wait_timeout(lock, dur);\n            (mutex::guard_poison(&guard).get(), WaitTimeoutResult(!success))\n        };\n        if poisoned {\n            Err(PoisonError::new((guard, result)))\n        } else {\n            Ok((guard, result))\n        }\n    }\n\n    /// Waits on this condition variable for a notification, timing out after a\n    /// specified duration.  Spurious wakes will not cause this function to\n    /// return.\n    ///\n    /// The semantics of this function are equivalent to [`wait_until`] except\n    /// that the thread will be blocked for roughly no longer than `dur`. This\n    /// method should not be used for precise timing due to anomalies such as\n    /// preemption or platform differences that may not cause the maximum\n    /// amount of time waited to be precisely `dur`.\n    ///\n    /// Note that the best effort is made to ensure that the time waited is\n    /// measured with a monotonic clock, and not affected by the changes made to\n    /// the system time.\n    ///\n    /// The returned [`WaitTimeoutResult`] value indicates if the timeout is\n    /// known to have elapsed without the condition being met.\n    ///\n    /// Like [`wait_until`], the lock specified will be re-acquired when this\n    /// function returns, regardless of whether the timeout elapsed or not.\n    ///\n    /// [`wait_until`]: #method.wait_until\n    /// [`wait_timeout`]: #method.wait_timeout\n    /// [`WaitTimeoutResult`]: struct.WaitTimeoutResult.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(wait_timeout_until)]\n    ///\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    /// use std::time::Duration;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // wait for the thread to start up\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let result = cvar.wait_timeout_until(\n    ///     lock.lock().unwrap(),\n    ///     Duration::from_millis(100),\n    ///     |&mut started| started,\n    /// ).unwrap();\n    /// if result.1.timed_out() {\n    ///     // timed-out without the condition ever evaluating to true.\n    /// }\n    /// // access the locked mutex via result.0\n    /// ```\n    #[unstable(feature = \"wait_timeout_until\", issue = \"47960\")]\n    pub fn wait_timeout_until<'a, T, F>(&self, mut guard: MutexGuard<'a, T>,\n                                        dur: Duration, mut condition: F)\n                                        -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)>\n                                        where F: FnMut(&mut T) -> bool {\n        let start = Instant::now();\n        loop {\n            if condition(&mut *guard) {\n                return Ok((guard, WaitTimeoutResult(false)));\n            }\n            let timeout = match dur.checked_sub(start.elapsed()) {\n                Some(timeout) => timeout,\n                None => return Ok((guard, WaitTimeoutResult(true))),\n            };\n            guard = self.wait_timeout(guard, timeout)?.0;\n        }\n    }\n\n    /// Wakes up one blocked thread on this condvar.\n    ///\n    /// If there is a blocked thread on this condition variable, then it will\n    /// be woken up from its call to [`wait`] or [`wait_timeout`]. Calls to\n    /// `notify_one` are not buffered in any way.\n    ///\n    /// To wake up all threads, see [`notify_all`].\n    ///\n    /// [`wait`]: #method.wait\n    /// [`wait_timeout`]: #method.wait_timeout\n    /// [`notify_all`]: #method.notify_all\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_one();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// // As long as the value inside the `Mutex` is false, we wait.\n    /// while !*started {\n    ///     started = cvar.wait(started).unwrap();\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn notify_one(&self) {\n        unsafe { self.inner.notify_one() }\n    }\n\n    /// Wakes up all blocked threads on this condvar.\n    ///\n    /// This method will ensure that any current waiters on the condition\n    /// variable are awoken. Calls to `notify_all()` are not buffered in any\n    /// way.\n    ///\n    /// To wake up only one thread, see [`notify_one`].\n    ///\n    /// [`notify_one`]: #method.notify_one\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Mutex, Condvar};\n    /// use std::thread;\n    ///\n    /// let pair = Arc::new((Mutex::new(false), Condvar::new()));\n    /// let pair2 = pair.clone();\n    ///\n    /// thread::spawn(move|| {\n    ///     let &(ref lock, ref cvar) = &*pair2;\n    ///     let mut started = lock.lock().unwrap();\n    ///     *started = true;\n    ///     // We notify the condvar that the value has changed.\n    ///     cvar.notify_all();\n    /// });\n    ///\n    /// // Wait for the thread to start up.\n    /// let &(ref lock, ref cvar) = &*pair;\n    /// let mut started = lock.lock().unwrap();\n    /// // As long as the value inside the `Mutex` is false, we wait.\n    /// while !*started {\n    ///     started = cvar.wait(started).unwrap();\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn notify_all(&self) {\n        unsafe { self.inner.notify_all() }\n    }\n\n    fn verify(&self, mutex: &sys_mutex::Mutex) {\n        let addr = mutex as *const _ as usize;\n        match self.mutex.compare_and_swap(0, addr, Ordering::SeqCst) {\n            // If we got out 0, then we have successfully bound the mutex to\n            // this cvar.\n            0 => {}\n\n            // If we get out a value that's the same as `addr`, then someone\n            // already beat us to the punch.\n            n if n == addr => {}\n\n            // Anything else and we're using more than one mutex on this cvar,\n            // which is currently disallowed.\n            _ => panic!(\"attempted to use a condition variable with two \\\n                         mutexes\"),\n        }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Condvar {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Condvar { .. }\")\n    }\n}\n\n#[stable(feature = \"condvar_default\", since = \"1.10.0\")]\nimpl Default for Condvar {\n    /// Creates a `Condvar` which is ready to be waited on and notified.\n    fn default() -> Condvar {\n        Condvar::new()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Drop for Condvar {\n    fn drop(&mut self) {\n        unsafe { self.inner.destroy() }\n    }\n}\n\n#[cfg(test)]\nmod tests {\n    /// #![feature(wait_until)]\n    use sync::mpsc::channel;\n    use sync::{Condvar, Mutex, Arc};\n    use sync::atomic::{AtomicBool, Ordering};\n    use thread;\n    use time::Duration;\n    use u64;\n\n    #[test]\n    fn smoke() {\n        let c = Condvar::new();\n        c.notify_one();\n        c.notify_all();\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn notify_one() {\n        let m = Arc::new(Mutex::new(()));\n        let m2 = m.clone();\n        let c = Arc::new(Condvar::new());\n        let c2 = c.clone();\n\n        let g = m.lock().unwrap();\n        let _t = thread::spawn(move|| {\n            let _g = m2.lock().unwrap();\n            c2.notify_one();\n        });\n        let g = c.wait(g).unwrap();\n        drop(g);\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn notify_all() {\n        const N: usize = 10;\n\n        let data = Arc::new((Mutex::new(0), Condvar::new()));\n        let (tx, rx) = channel();\n        for _ in 0..N {\n            let data = data.clone();\n            let tx = tx.clone();\n            thread::spawn(move|| {\n                let &(ref lock, ref cond) = &*data;\n                let mut cnt = lock.lock().unwrap();\n                *cnt += 1;\n                if *cnt == N {\n                    tx.send(()).unwrap();\n                }\n                while *cnt != 0 {\n                    cnt = cond.wait(cnt).unwrap();\n                }\n                tx.send(()).unwrap();\n            });\n        }\n        drop(tx);\n\n        let &(ref lock, ref cond) = &*data;\n        rx.recv().unwrap();\n        let mut cnt = lock.lock().unwrap();\n        *cnt = 0;\n        cond.notify_all();\n        drop(cnt);\n\n        for _ in 0..N {\n            rx.recv().unwrap();\n        }\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_until() {\n        let pair = Arc::new((Mutex::new(false), Condvar::new()));\n        let pair2 = pair.clone();\n\n        // Inside of our lock, spawn a new thread, and then wait for it to start.\n        thread::spawn(move|| {\n            let &(ref lock, ref cvar) = &*pair2;\n            let mut started = lock.lock().unwrap();\n            *started = true;\n            // We notify the condvar that the value has changed.\n            cvar.notify_one();\n        });\n\n        // Wait for the thread to start up.\n        let &(ref lock, ref cvar) = &*pair;\n        let guard = cvar.wait_until(lock.lock().unwrap(), |started| {\n            *started\n        });\n        assert!(*guard.unwrap());\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_timeout_wait() {\n        let m = Arc::new(Mutex::new(()));\n        let c = Arc::new(Condvar::new());\n\n        loop {\n            let g = m.lock().unwrap();\n            let (_g, no_timeout) = c.wait_timeout(g, Duration::from_millis(1)).unwrap();\n            // spurious wakeups mean this isn't necessarily true\n            // so execute test again, if not timeout\n            if !no_timeout.timed_out() {\n                continue;\n            }\n\n            break;\n        }\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_timeout_until_wait() {\n        let m = Arc::new(Mutex::new(()));\n        let c = Arc::new(Condvar::new());\n\n        let g = m.lock().unwrap();\n        let (_g, wait) = c.wait_timeout_until(g, Duration::from_millis(1), |_| { false }).unwrap();\n        // no spurious wakeups. ensure it timed-out\n        assert!(wait.timed_out());\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_timeout_until_instant_satisfy() {\n        let m = Arc::new(Mutex::new(()));\n        let c = Arc::new(Condvar::new());\n\n        let g = m.lock().unwrap();\n        let (_g, wait) = c.wait_timeout_until(g, Duration::from_millis(0), |_| { true }).unwrap();\n        // ensure it didn't time-out even if we were not given any time.\n        assert!(!wait.timed_out());\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_timeout_until_wake() {\n        let pair = Arc::new((Mutex::new(false), Condvar::new()));\n        let pair_copy = pair.clone();\n\n        let &(ref m, ref c) = &*pair;\n        let g = m.lock().unwrap();\n        let _t = thread::spawn(move || {\n            let &(ref lock, ref cvar) = &*pair_copy;\n            let mut started = lock.lock().unwrap();\n            thread::sleep(Duration::from_millis(1));\n            *started = true;\n            cvar.notify_one();\n        });\n        let (g2, wait) = c.wait_timeout_until(g, Duration::from_millis(u64::MAX), |&mut notified| {\n            notified\n        }).unwrap();\n        // ensure it didn't time-out even if we were not given any time.\n        assert!(!wait.timed_out());\n        assert!(*g2);\n    }\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn wait_timeout_wake() {\n        let m = Arc::new(Mutex::new(()));\n        let c = Arc::new(Condvar::new());\n\n        loop {\n            let g = m.lock().unwrap();\n\n            let c2 = c.clone();\n            let m2 = m.clone();\n\n            let notified = Arc::new(AtomicBool::new(false));\n            let notified_copy = notified.clone();\n\n            let t = thread::spawn(move || {\n                let _g = m2.lock().unwrap();\n                thread::sleep(Duration::from_millis(1));\n                notified_copy.store(true, Ordering::SeqCst);\n                c2.notify_one();\n            });\n            let (g, timeout_res) = c.wait_timeout(g, Duration::from_millis(u64::MAX)).unwrap();\n            assert!(!timeout_res.timed_out());\n            // spurious wakeups mean this isn't necessarily true\n            // so execute test again, if not notified\n            if !notified.load(Ordering::SeqCst) {\n                t.join().unwrap();\n                continue;\n            }\n            drop(g);\n\n            t.join().unwrap();\n\n            break;\n        }\n    }\n\n    #[test]\n    #[should_panic]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn two_mutexes() {\n        let m = Arc::new(Mutex::new(()));\n        let m2 = m.clone();\n        let c = Arc::new(Condvar::new());\n        let c2 = c.clone();\n\n        let mut g = m.lock().unwrap();\n        let _t = thread::spawn(move|| {\n            let _g = m2.lock().unwrap();\n            c2.notify_one();\n        });\n        g = c.wait(g).unwrap();\n        drop(g);\n\n        let m = Mutex::new(());\n        let _ = c.wait(m.lock().unwrap()).unwrap();\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Generic support for building blocking abstractions.\n\nuse thread::{self, Thread};\nuse sync::atomic::{AtomicBool, Ordering};\nuse sync::Arc;\nuse mem;\nuse time::Instant;\n\nstruct Inner {\n    thread: Thread,\n    woken: AtomicBool,\n}\n\nunsafe impl Send for Inner {}\nunsafe impl Sync for Inner {}\n\n#[derive(Clone)]\npub struct SignalToken {\n    inner: Arc<Inner>,\n}\n\npub struct WaitToken {\n    inner: Arc<Inner>,\n}\n\nimpl !Send for WaitToken {}\n\nimpl !Sync for WaitToken {}\n\npub fn tokens() -> (WaitToken, SignalToken) {\n    let inner = Arc::new(Inner {\n        thread: thread::current(),\n        woken: AtomicBool::new(false),\n    });\n    let wait_token = WaitToken {\n        inner: inner.clone(),\n    };\n    let signal_token = SignalToken {\n        inner,\n    };\n    (wait_token, signal_token)\n}\n\nimpl SignalToken {\n    pub fn signal(&self) -> bool {\n        let wake = !self.inner.woken.compare_and_swap(false, true, Ordering::SeqCst);\n        if wake {\n            self.inner.thread.unpark();\n        }\n        wake\n    }\n\n    /// Convert to an unsafe usize value. Useful for storing in a pipe's state\n    /// flag.\n    #[inline]\n    pub unsafe fn cast_to_usize(self) -> usize {\n        mem::transmute(self.inner)\n    }\n\n    /// Convert from an unsafe usize value. Useful for retrieving a pipe's state\n    /// flag.\n    #[inline]\n    pub unsafe fn cast_from_usize(signal_ptr: usize) -> SignalToken {\n        SignalToken { inner: mem::transmute(signal_ptr) }\n    }\n}\n\nimpl WaitToken {\n    pub fn wait(self) {\n        while !self.inner.woken.load(Ordering::SeqCst) {\n            thread::park()\n        }\n    }\n\n    /// Returns true if we wake up normally, false otherwise.\n    pub fn wait_max_until(self, end: Instant) -> bool {\n        while !self.inner.woken.load(Ordering::SeqCst) {\n            let now = Instant::now();\n            if now >= end {\n                return false;\n            }\n            thread::park_timeout(end - now)\n        }\n        true\n    }\n}\n","// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Selection over an array of receivers\n//!\n//! This module contains the implementation machinery necessary for selecting\n//! over a number of receivers. One large goal of this module is to provide an\n//! efficient interface to selecting over any receiver of any type.\n//!\n//! This is achieved through an architecture of a \"receiver set\" in which\n//! receivers are added to a set and then the entire set is waited on at once.\n//! The set can be waited on multiple times to prevent re-adding each receiver\n//! to the set.\n//!\n//! Usage of this module is currently encouraged to go through the use of the\n//! `select!` macro. This macro allows naturally binding of variables to the\n//! received values of receivers in a much more natural syntax then usage of the\n//! `Select` structure directly.\n//!\n//! # Examples\n//!\n//! ```rust\n//! #![feature(mpsc_select)]\n//!\n//! use std::sync::mpsc::channel;\n//!\n//! let (tx1, rx1) = channel();\n//! let (tx2, rx2) = channel();\n//!\n//! tx1.send(1).unwrap();\n//! tx2.send(2).unwrap();\n//!\n//! select! {\n//!     val = rx1.recv() => {\n//!         assert_eq!(val.unwrap(), 1);\n//!     },\n//!     val = rx2.recv() => {\n//!         assert_eq!(val.unwrap(), 2);\n//!     }\n//! }\n//! ```\n\n#![allow(dead_code)]\n#![unstable(feature = \"mpsc_select\",\n            reason = \"This implementation, while likely sufficient, is unsafe and \\\n                      likely to be error prone. At some point in the future this \\\n                      module will likely be replaced, and it is currently \\\n                      unknown how much API breakage that will cause. The ability \\\n                      to select over a number of channels will remain forever, \\\n                      but no guarantees beyond this are being made\",\n            issue = \"27800\")]\n\n\nuse fmt;\n\nuse core::cell::{Cell, UnsafeCell};\nuse core::marker;\nuse core::ptr;\nuse core::usize;\n\nuse sync::mpsc::{Receiver, RecvError};\nuse sync::mpsc::blocking::{self, SignalToken};\n\n/// The \"receiver set\" of the select interface. This structure is used to manage\n/// a set of receivers which are being selected over.\npub struct Select {\n    inner: UnsafeCell<SelectInner>,\n    next_id: Cell<usize>,\n}\n\nstruct SelectInner {\n    head: *mut Handle<'static, ()>,\n    tail: *mut Handle<'static, ()>,\n}\n\nimpl !marker::Send for Select {}\n\n/// A handle to a receiver which is currently a member of a `Select` set of\n/// receivers.  This handle is used to keep the receiver in the set as well as\n/// interact with the underlying receiver.\npub struct Handle<'rx, T:Send+'rx> {\n    /// The ID of this handle, used to compare against the return value of\n    /// `Select::wait()`\n    id: usize,\n    selector: *mut SelectInner,\n    next: *mut Handle<'static, ()>,\n    prev: *mut Handle<'static, ()>,\n    added: bool,\n    packet: &'rx (dyn Packet+'rx),\n\n    // due to our fun transmutes, we be sure to place this at the end. (nothing\n    // previous relies on T)\n    rx: &'rx Receiver<T>,\n}\n\nstruct Packets { cur: *mut Handle<'static, ()> }\n\n#[doc(hidden)]\n#[derive(PartialEq, Eq)]\npub enum StartResult {\n    Installed,\n    Abort,\n}\n\n#[doc(hidden)]\npub trait Packet {\n    fn can_recv(&self) -> bool;\n    fn start_selection(&self, token: SignalToken) -> StartResult;\n    fn abort_selection(&self) -> bool;\n}\n\nimpl Select {\n    /// Creates a new selection structure. This set is initially empty.\n    ///\n    /// Usage of this struct directly can sometimes be burdensome, and usage is much easier through\n    /// the `select!` macro.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(mpsc_select)]\n    ///\n    /// use std::sync::mpsc::Select;\n    ///\n    /// let select = Select::new();\n    /// ```\n    pub fn new() -> Select {\n        Select {\n            inner: UnsafeCell::new(SelectInner {\n                head: ptr::null_mut(),\n                tail: ptr::null_mut(),\n            }),\n            next_id: Cell::new(1),\n        }\n    }\n\n    /// Creates a new handle into this receiver set for a new receiver. Note\n    /// that this does *not* add the receiver to the receiver set, for that you\n    /// must call the `add` method on the handle itself.\n    pub fn handle<'a, T: Send>(&'a self, rx: &'a Receiver<T>) -> Handle<'a, T> {\n        let id = self.next_id.get();\n        self.next_id.set(id + 1);\n        Handle {\n            id,\n            selector: self.inner.get(),\n            next: ptr::null_mut(),\n            prev: ptr::null_mut(),\n            added: false,\n            rx,\n            packet: rx,\n        }\n    }\n\n    /// Waits for an event on this receiver set. The returned value is *not* an\n    /// index, but rather an id. This id can be queried against any active\n    /// `Handle` structures (each one has an `id` method). The handle with\n    /// the matching `id` will have some sort of event available on it. The\n    /// event could either be that data is available or the corresponding\n    /// channel has been closed.\n    pub fn wait(&self) -> usize {\n        self.wait2(true)\n    }\n\n    /// Helper method for skipping the preflight checks during testing\n    fn wait2(&self, do_preflight_checks: bool) -> usize {\n        // Note that this is currently an inefficient implementation. We in\n        // theory have knowledge about all receivers in the set ahead of time,\n        // so this method shouldn't really have to iterate over all of them yet\n        // again. The idea with this \"receiver set\" interface is to get the\n        // interface right this time around, and later this implementation can\n        // be optimized.\n        //\n        // This implementation can be summarized by:\n        //\n        //      fn select(receivers) {\n        //          if any receiver ready { return ready index }\n        //          deschedule {\n        //              block on all receivers\n        //          }\n        //          unblock on all receivers\n        //          return ready index\n        //      }\n        //\n        // Most notably, the iterations over all of the receivers shouldn't be\n        // necessary.\n        unsafe {\n            // Stage 1: preflight checks. Look for any packets ready to receive\n            if do_preflight_checks {\n                for handle in self.iter() {\n                    if (*handle).packet.can_recv() {\n                        return (*handle).id();\n                    }\n                }\n            }\n\n            // Stage 2: begin the blocking process\n            //\n            // Create a number of signal tokens, and install each one\n            // sequentially until one fails. If one fails, then abort the\n            // selection on the already-installed tokens.\n            let (wait_token, signal_token) = blocking::tokens();\n            for (i, handle) in self.iter().enumerate() {\n                match (*handle).packet.start_selection(signal_token.clone()) {\n                    StartResult::Installed => {}\n                    StartResult::Abort => {\n                        // Go back and abort the already-begun selections\n                        for handle in self.iter().take(i) {\n                            (*handle).packet.abort_selection();\n                        }\n                        return (*handle).id;\n                    }\n                }\n            }\n\n            // Stage 3: no messages available, actually block\n            wait_token.wait();\n\n            // Stage 4: there *must* be message available; find it.\n            //\n            // Abort the selection process on each receiver. If the abort\n            // process returns `true`, then that means that the receiver is\n            // ready to receive some data. Note that this also means that the\n            // receiver may have yet to have fully read the `to_wake` field and\n            // woken us up (although the wakeup is guaranteed to fail).\n            //\n            // This situation happens in the window of where a sender invokes\n            // increment(), sees -1, and then decides to wake up the thread. After\n            // all this is done, the sending thread will set `selecting` to\n            // `false`. Until this is done, we cannot return. If we were to\n            // return, then a sender could wake up a receiver which has gone\n            // back to sleep after this call to `select`.\n            //\n            // Note that it is a \"fairly small window\" in which an increment()\n            // views that it should wake a thread up until the `selecting` bit\n            // is set to false. For now, the implementation currently just spins\n            // in a yield loop. This is very distasteful, but this\n            // implementation is already nowhere near what it should ideally be.\n            // A rewrite should focus on avoiding a yield loop, and for now this\n            // implementation is tying us over to a more efficient \"don't\n            // iterate over everything every time\" implementation.\n            let mut ready_id = usize::MAX;\n            for handle in self.iter() {\n                if (*handle).packet.abort_selection() {\n                    ready_id = (*handle).id;\n                }\n            }\n\n            // We must have found a ready receiver\n            assert!(ready_id != usize::MAX);\n            return ready_id;\n        }\n    }\n\n    fn iter(&self) -> Packets { Packets { cur: unsafe { &*self.inner.get() }.head } }\n}\n\nimpl<'rx, T: Send> Handle<'rx, T> {\n    /// Retrieves the id of this handle.\n    #[inline]\n    pub fn id(&self) -> usize { self.id }\n\n    /// Blocks to receive a value on the underlying receiver, returning `Some` on\n    /// success or `None` if the channel disconnects. This function has the same\n    /// semantics as `Receiver.recv`\n    pub fn recv(&mut self) -> Result<T, RecvError> { self.rx.recv() }\n\n    /// Adds this handle to the receiver set that the handle was created from. This\n    /// method can be called multiple times, but it has no effect if `add` was\n    /// called previously.\n    ///\n    /// This method is unsafe because it requires that the `Handle` is not moved\n    /// while it is added to the `Select` set.\n    pub unsafe fn add(&mut self) {\n        if self.added { return }\n        let selector = &mut *self.selector;\n        let me = self as *mut Handle<'rx, T> as *mut Handle<'static, ()>;\n\n        if selector.head.is_null() {\n            selector.head = me;\n            selector.tail = me;\n        } else {\n            (*me).prev = selector.tail;\n            assert!((*me).next.is_null());\n            (*selector.tail).next = me;\n            selector.tail = me;\n        }\n        self.added = true;\n    }\n\n    /// Removes this handle from the `Select` set. This method is unsafe because\n    /// it has no guarantee that the `Handle` was not moved since `add` was\n    /// called.\n    pub unsafe fn remove(&mut self) {\n        if !self.added { return }\n\n        let selector = &mut *self.selector;\n        let me = self as *mut Handle<'rx, T> as *mut Handle<'static, ()>;\n\n        if self.prev.is_null() {\n            assert_eq!(selector.head, me);\n            selector.head = self.next;\n        } else {\n            (*self.prev).next = self.next;\n        }\n        if self.next.is_null() {\n            assert_eq!(selector.tail, me);\n            selector.tail = self.prev;\n        } else {\n            (*self.next).prev = self.prev;\n        }\n\n        self.next = ptr::null_mut();\n        self.prev = ptr::null_mut();\n\n        self.added = false;\n    }\n}\n\nimpl Drop for Select {\n    fn drop(&mut self) {\n        unsafe {\n            assert!((&*self.inner.get()).head.is_null());\n            assert!((&*self.inner.get()).tail.is_null());\n        }\n    }\n}\n\nimpl<'rx, T: Send> Drop for Handle<'rx, T> {\n    fn drop(&mut self) {\n        unsafe { self.remove() }\n    }\n}\n\nimpl Iterator for Packets {\n    type Item = *mut Handle<'static, ()>;\n\n    fn next(&mut self) -> Option<*mut Handle<'static, ()>> {\n        if self.cur.is_null() {\n            None\n        } else {\n            let ret = Some(self.cur);\n            unsafe { self.cur = (*self.cur).next; }\n            ret\n        }\n    }\n}\n\nimpl fmt::Debug for Select {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Select\").finish()\n    }\n}\n\nimpl<'rx, T:Send+'rx> fmt::Debug for Handle<'rx, T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Handle\").finish()\n    }\n}\n\n#[allow(unused_imports)]\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use thread;\n    use sync::mpsc::*;\n\n    // Don't use the libstd version so we can pull in the right Select structure\n    // (std::comm points at the wrong one)\n    macro_rules! select {\n        (\n            $($name:pat = $rx:ident.$meth:ident() => $code:expr),+\n        ) => ({\n            let sel = Select::new();\n            $( let mut $rx = sel.handle(&$rx); )+\n            unsafe {\n                $( $rx.add(); )+\n            }\n            let ret = sel.wait();\n            $( if ret == $rx.id() { let $name = $rx.$meth(); $code } else )+\n            { unreachable!() }\n        })\n    }\n\n    #[test]\n    fn smoke() {\n        let (tx1, rx1) = channel::<i32>();\n        let (tx2, rx2) = channel::<i32>();\n        tx1.send(1).unwrap();\n        select! {\n            foo = rx1.recv() => { assert_eq!(foo.unwrap(), 1); },\n            _bar = rx2.recv() => { panic!() }\n        }\n        tx2.send(2).unwrap();\n        select! {\n            _foo = rx1.recv() => { panic!() },\n            bar = rx2.recv() => { assert_eq!(bar.unwrap(), 2) }\n        }\n        drop(tx1);\n        select! {\n            foo = rx1.recv() => { assert!(foo.is_err()); },\n            _bar = rx2.recv() => { panic!() }\n        }\n        drop(tx2);\n        select! {\n            bar = rx2.recv() => { assert!(bar.is_err()); }\n        }\n    }\n\n    #[test]\n    fn smoke2() {\n        let (_tx1, rx1) = channel::<i32>();\n        let (_tx2, rx2) = channel::<i32>();\n        let (_tx3, rx3) = channel::<i32>();\n        let (_tx4, rx4) = channel::<i32>();\n        let (tx5, rx5) = channel::<i32>();\n        tx5.send(4).unwrap();\n        select! {\n            _foo = rx1.recv() => { panic!(\"1\") },\n            _foo = rx2.recv() => { panic!(\"2\") },\n            _foo = rx3.recv() => { panic!(\"3\") },\n            _foo = rx4.recv() => { panic!(\"4\") },\n            foo = rx5.recv() => { assert_eq!(foo.unwrap(), 4); }\n        }\n    }\n\n    #[test]\n    fn closed() {\n        let (_tx1, rx1) = channel::<i32>();\n        let (tx2, rx2) = channel::<i32>();\n        drop(tx2);\n\n        select! {\n            _a1 = rx1.recv() => { panic!() },\n            a2 = rx2.recv() => { assert!(a2.is_err()); }\n        }\n    }\n\n    #[test]\n    fn unblocks() {\n        let (tx1, rx1) = channel::<i32>();\n        let (_tx2, rx2) = channel::<i32>();\n        let (tx3, rx3) = channel::<i32>();\n\n        let _t = thread::spawn(move|| {\n            for _ in 0..20 { thread::yield_now(); }\n            tx1.send(1).unwrap();\n            rx3.recv().unwrap();\n            for _ in 0..20 { thread::yield_now(); }\n        });\n\n        select! {\n            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },\n            _b = rx2.recv() => { panic!() }\n        }\n        tx3.send(1).unwrap();\n        select! {\n            a = rx1.recv() => { assert!(a.is_err()) },\n            _b = rx2.recv() => { panic!() }\n        }\n    }\n\n    #[test]\n    fn both_ready() {\n        let (tx1, rx1) = channel::<i32>();\n        let (tx2, rx2) = channel::<i32>();\n        let (tx3, rx3) = channel::<()>();\n\n        let _t = thread::spawn(move|| {\n            for _ in 0..20 { thread::yield_now(); }\n            tx1.send(1).unwrap();\n            tx2.send(2).unwrap();\n            rx3.recv().unwrap();\n        });\n\n        select! {\n            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },\n            a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }\n        }\n        select! {\n            a = rx1.recv() => { assert_eq!(a.unwrap(), 1); },\n            a = rx2.recv() => { assert_eq!(a.unwrap(), 2); }\n        }\n        assert_eq!(rx1.try_recv(), Err(TryRecvError::Empty));\n        assert_eq!(rx2.try_recv(), Err(TryRecvError::Empty));\n        tx3.send(()).unwrap();\n    }\n\n    #[test]\n    fn stress() {\n        const AMT: i32 = 10000;\n        let (tx1, rx1) = channel::<i32>();\n        let (tx2, rx2) = channel::<i32>();\n        let (tx3, rx3) = channel::<()>();\n\n        let _t = thread::spawn(move|| {\n            for i in 0..AMT {\n                if i % 2 == 0 {\n                    tx1.send(i).unwrap();\n                } else {\n                    tx2.send(i).unwrap();\n                }\n                rx3.recv().unwrap();\n            }\n        });\n\n        for i in 0..AMT {\n            select! {\n                i1 = rx1.recv() => { assert!(i % 2 == 0 && i == i1.unwrap()); },\n                i2 = rx2.recv() => { assert!(i % 2 == 1 && i == i2.unwrap()); }\n            }\n            tx3.send(()).unwrap();\n        }\n    }\n\n    #[allow(unused_must_use)]\n    #[test]\n    fn cloning() {\n        let (tx1, rx1) = channel::<i32>();\n        let (_tx2, rx2) = channel::<i32>();\n        let (tx3, rx3) = channel::<()>();\n\n        let _t = thread::spawn(move|| {\n            rx3.recv().unwrap();\n            tx1.clone();\n            assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));\n            tx1.send(2).unwrap();\n            rx3.recv().unwrap();\n        });\n\n        tx3.send(()).unwrap();\n        select! {\n            _i1 = rx1.recv() => {},\n            _i2 = rx2.recv() => panic!()\n        }\n        tx3.send(()).unwrap();\n    }\n\n    #[allow(unused_must_use)]\n    #[test]\n    fn cloning2() {\n        let (tx1, rx1) = channel::<i32>();\n        let (_tx2, rx2) = channel::<i32>();\n        let (tx3, rx3) = channel::<()>();\n\n        let _t = thread::spawn(move|| {\n            rx3.recv().unwrap();\n            tx1.clone();\n            assert_eq!(rx3.try_recv(), Err(TryRecvError::Empty));\n            tx1.send(2).unwrap();\n            rx3.recv().unwrap();\n        });\n\n        tx3.send(()).unwrap();\n        select! {\n            _i1 = rx1.recv() => {},\n            _i2 = rx2.recv() => panic!()\n        }\n        tx3.send(()).unwrap();\n    }\n\n    #[test]\n    fn cloning3() {\n        let (tx1, rx1) = channel::<()>();\n        let (tx2, rx2) = channel::<()>();\n        let (tx3, rx3) = channel::<()>();\n        let _t = thread::spawn(move|| {\n            let s = Select::new();\n            let mut h1 = s.handle(&rx1);\n            let mut h2 = s.handle(&rx2);\n            unsafe { h2.add(); }\n            unsafe { h1.add(); }\n            assert_eq!(s.wait(), h2.id);\n            tx3.send(()).unwrap();\n        });\n\n        for _ in 0..1000 { thread::yield_now(); }\n        drop(tx1.clone());\n        tx2.send(()).unwrap();\n        rx3.recv().unwrap();\n    }\n\n    #[test]\n    fn preflight1() {\n        let (tx, rx) = channel();\n        tx.send(()).unwrap();\n        select! {\n            _n = rx.recv() => {}\n        }\n    }\n\n    #[test]\n    fn preflight2() {\n        let (tx, rx) = channel();\n        tx.send(()).unwrap();\n        tx.send(()).unwrap();\n        select! {\n            _n = rx.recv() => {}\n        }\n    }\n\n    #[test]\n    fn preflight3() {\n        let (tx, rx) = channel();\n        drop(tx.clone());\n        tx.send(()).unwrap();\n        select! {\n            _n = rx.recv() => {}\n        }\n    }\n\n    #[test]\n    fn preflight4() {\n        let (tx, rx) = channel();\n        tx.send(()).unwrap();\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn preflight5() {\n        let (tx, rx) = channel();\n        tx.send(()).unwrap();\n        tx.send(()).unwrap();\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn preflight6() {\n        let (tx, rx) = channel();\n        drop(tx.clone());\n        tx.send(()).unwrap();\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn preflight7() {\n        let (tx, rx) = channel::<()>();\n        drop(tx);\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn preflight8() {\n        let (tx, rx) = channel();\n        tx.send(()).unwrap();\n        drop(tx);\n        rx.recv().unwrap();\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn preflight9() {\n        let (tx, rx) = channel();\n        drop(tx.clone());\n        tx.send(()).unwrap();\n        drop(tx);\n        rx.recv().unwrap();\n        let s = Select::new();\n        let mut h = s.handle(&rx);\n        unsafe { h.add(); }\n        assert_eq!(s.wait2(false), h.id);\n    }\n\n    #[test]\n    fn oneshot_data_waiting() {\n        let (tx1, rx1) = channel();\n        let (tx2, rx2) = channel();\n        let _t = thread::spawn(move|| {\n            select! {\n                _n = rx1.recv() => {}\n            }\n            tx2.send(()).unwrap();\n        });\n\n        for _ in 0..100 { thread::yield_now() }\n        tx1.send(()).unwrap();\n        rx2.recv().unwrap();\n    }\n\n    #[test]\n    fn stream_data_waiting() {\n        let (tx1, rx1) = channel();\n        let (tx2, rx2) = channel();\n        tx1.send(()).unwrap();\n        tx1.send(()).unwrap();\n        rx1.recv().unwrap();\n        rx1.recv().unwrap();\n        let _t = thread::spawn(move|| {\n            select! {\n                _n = rx1.recv() => {}\n            }\n            tx2.send(()).unwrap();\n        });\n\n        for _ in 0..100 { thread::yield_now() }\n        tx1.send(()).unwrap();\n        rx2.recv().unwrap();\n    }\n\n    #[test]\n    fn shared_data_waiting() {\n        let (tx1, rx1) = channel();\n        let (tx2, rx2) = channel();\n        drop(tx1.clone());\n        tx1.send(()).unwrap();\n        rx1.recv().unwrap();\n        let _t = thread::spawn(move|| {\n            select! {\n                _n = rx1.recv() => {}\n            }\n            tx2.send(()).unwrap();\n        });\n\n        for _ in 0..100 { thread::yield_now() }\n        tx1.send(()).unwrap();\n        rx2.recv().unwrap();\n    }\n\n    #[test]\n    fn sync1() {\n        let (tx, rx) = sync_channel::<i32>(1);\n        tx.send(1).unwrap();\n        select! {\n            n = rx.recv() => { assert_eq!(n.unwrap(), 1); }\n        }\n    }\n\n    #[test]\n    fn sync2() {\n        let (tx, rx) = sync_channel::<i32>(0);\n        let _t = thread::spawn(move|| {\n            for _ in 0..100 { thread::yield_now() }\n            tx.send(1).unwrap();\n        });\n        select! {\n            n = rx.recv() => { assert_eq!(n.unwrap(), 1); }\n        }\n    }\n\n    #[test]\n    fn sync3() {\n        let (tx1, rx1) = sync_channel::<i32>(0);\n        let (tx2, rx2): (Sender<i32>, Receiver<i32>) = channel();\n        let _t = thread::spawn(move|| { tx1.send(1).unwrap(); });\n        let _t = thread::spawn(move|| { tx2.send(2).unwrap(); });\n        select! {\n            n = rx1.recv() => {\n                let n = n.unwrap();\n                assert_eq!(n, 1);\n                assert_eq!(rx2.recv().unwrap(), 2);\n            },\n            n = rx2.recv() => {\n                let n = n.unwrap();\n                assert_eq!(n, 2);\n                assert_eq!(rx1.recv().unwrap(), 1);\n            }\n        }\n    }\n}\n","// Copyright 2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse sync::{Mutex, Condvar};\n\n/// A barrier enables multiple threads to synchronize the beginning\n/// of some computation.\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::{Arc, Barrier};\n/// use std::thread;\n///\n/// let mut handles = Vec::with_capacity(10);\n/// let barrier = Arc::new(Barrier::new(10));\n/// for _ in 0..10 {\n///     let c = barrier.clone();\n///     // The same messages will be printed together.\n///     // You will NOT see any interleaving.\n///     handles.push(thread::spawn(move|| {\n///         println!(\"before wait\");\n///         c.wait();\n///         println!(\"after wait\");\n///     }));\n/// }\n/// // Wait for other threads to finish.\n/// for handle in handles {\n///     handle.join().unwrap();\n/// }\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Barrier {\n    lock: Mutex<BarrierState>,\n    cvar: Condvar,\n    num_threads: usize,\n}\n\n// The inner state of a double barrier\nstruct BarrierState {\n    count: usize,\n    generation_id: usize,\n}\n\n/// A `BarrierWaitResult` is returned by [`wait`] when all threads in the [`Barrier`]\n/// have rendezvoused.\n///\n/// [`wait`]: struct.Barrier.html#method.wait\n/// [`Barrier`]: struct.Barrier.html\n///\n/// # Examples\n///\n/// ```\n/// use std::sync::Barrier;\n///\n/// let barrier = Barrier::new(1);\n/// let barrier_wait_result = barrier.wait();\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct BarrierWaitResult(bool);\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Barrier {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Barrier { .. }\")\n    }\n}\n\nimpl Barrier {\n    /// Creates a new barrier that can block a given number of threads.\n    ///\n    /// A barrier will block `n`-1 threads which call [`wait`] and then wake up\n    /// all threads at once when the `n`th thread calls [`wait`].\n    ///\n    /// [`wait`]: #method.wait\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Barrier;\n    ///\n    /// let barrier = Barrier::new(10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(n: usize) -> Barrier {\n        Barrier {\n            lock: Mutex::new(BarrierState {\n                count: 0,\n                generation_id: 0,\n            }),\n            cvar: Condvar::new(),\n            num_threads: n,\n        }\n    }\n\n    /// Blocks the current thread until all threads have rendezvoused here.\n    ///\n    /// Barriers are re-usable after all threads have rendezvoused once, and can\n    /// be used continuously.\n    ///\n    /// A single (arbitrary) thread will receive a [`BarrierWaitResult`] that\n    /// returns `true` from [`is_leader`] when returning from this function, and\n    /// all other threads will receive a result that will return `false` from\n    /// [`is_leader`].\n    ///\n    /// [`BarrierWaitResult`]: struct.BarrierWaitResult.html\n    /// [`is_leader`]: struct.BarrierWaitResult.html#method.is_leader\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::{Arc, Barrier};\n    /// use std::thread;\n    ///\n    /// let mut handles = Vec::with_capacity(10);\n    /// let barrier = Arc::new(Barrier::new(10));\n    /// for _ in 0..10 {\n    ///     let c = barrier.clone();\n    ///     // The same messages will be printed together.\n    ///     // You will NOT see any interleaving.\n    ///     handles.push(thread::spawn(move|| {\n    ///         println!(\"before wait\");\n    ///         c.wait();\n    ///         println!(\"after wait\");\n    ///     }));\n    /// }\n    /// // Wait for other threads to finish.\n    /// for handle in handles {\n    ///     handle.join().unwrap();\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn wait(&self) -> BarrierWaitResult {\n        let mut lock = self.lock.lock().unwrap();\n        let local_gen = lock.generation_id;\n        lock.count += 1;\n        if lock.count < self.num_threads {\n            // We need a while loop to guard against spurious wakeups.\n            // http://en.wikipedia.org/wiki/Spurious_wakeup\n            while local_gen == lock.generation_id &&\n                  lock.count < self.num_threads {\n                lock = self.cvar.wait(lock).unwrap();\n            }\n            BarrierWaitResult(false)\n        } else {\n            lock.count = 0;\n            lock.generation_id = lock.generation_id.wrapping_add(1);\n            self.cvar.notify_all();\n            BarrierWaitResult(true)\n        }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for BarrierWaitResult {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"BarrierWaitResult\")\n            .field(\"is_leader\", &self.is_leader())\n            .finish()\n    }\n}\n\nimpl BarrierWaitResult {\n    /// Returns whether this thread from [`wait`] is the \"leader thread\".\n    ///\n    /// Only one thread will have `true` returned from their result, all other\n    /// threads will have `false` returned.\n    ///\n    /// [`wait`]: struct.Barrier.html#method.wait\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::sync::Barrier;\n    ///\n    /// let barrier = Barrier::new(1);\n    /// let barrier_wait_result = barrier.wait();\n    /// println!(\"{:?}\", barrier_wait_result.is_leader());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_leader(&self) -> bool { self.0 }\n}\n\n#[cfg(test)]\nmod tests {\n    use sync::{Arc, Barrier};\n    use sync::mpsc::{channel, TryRecvError};\n    use thread;\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn test_barrier() {\n        const N: usize = 10;\n\n        let barrier = Arc::new(Barrier::new(N));\n        let (tx, rx) = channel();\n\n        for _ in 0..N - 1 {\n            let c = barrier.clone();\n            let tx = tx.clone();\n            thread::spawn(move|| {\n                tx.send(c.wait().is_leader()).unwrap();\n            });\n        }\n\n        // At this point, all spawned threads should be blocked,\n        // so we shouldn't get anything from the port\n        assert!(match rx.try_recv() {\n            Err(TryRecvError::Empty) => true,\n            _ => false,\n        });\n\n        let mut leader_found = barrier.wait().is_leader();\n\n        // Now, the barrier is cleared and we should get data.\n        for _ in 0..N - 1 {\n            if rx.recv().unwrap() {\n                assert!(!leader_found);\n                leader_found = true;\n            }\n        }\n        assert!(leader_found);\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![no_std]\n#![allow(unused_attributes)]\n#![unstable(feature = \"alloc_system\",\n            reason = \"this library is unlikely to be stabilized in its current \\\n                      form or name\",\n            issue = \"32838\")]\n\n#![feature(allocator_api)]\n#![feature(core_intrinsics)]\n#![feature(nll)]\n#![feature(staged_api)]\n#![feature(rustc_attrs)]\n#![cfg_attr(\n    all(target_arch = \"wasm32\", not(target_os = \"emscripten\")),\n    feature(integer_atomics, stdsimd)\n)]\n#![cfg_attr(any(unix, target_os = \"cloudabi\", target_os = \"redox\"), feature(libc))]\n#![rustc_alloc_kind = \"lib\"]\n\n// The minimum alignment guaranteed by the architecture. This value is used to\n// add fast paths for low alignment values.\n#[cfg(all(any(target_arch = \"x86\",\n              target_arch = \"arm\",\n              target_arch = \"mips\",\n              target_arch = \"powerpc\",\n              target_arch = \"powerpc64\",\n              target_arch = \"asmjs\",\n              target_arch = \"wasm32\")))]\n#[allow(dead_code)]\nconst MIN_ALIGN: usize = 8;\n#[cfg(all(any(target_arch = \"x86_64\",\n              target_arch = \"aarch64\",\n              target_arch = \"mips64\",\n              target_arch = \"s390x\",\n              target_arch = \"sparc64\")))]\n#[allow(dead_code)]\nconst MIN_ALIGN: usize = 16;\n\nuse core::alloc::{Alloc, GlobalAlloc, AllocErr, Layout};\nuse core::ptr::NonNull;\n\n/// The default memory allocator provided by the operating system.\n///\n/// This is based on `malloc` on Unix platforms and `HeapAlloc` on Windows,\n/// plus related functions.\n///\n/// This type can be used in a `static` item\n/// with the `#[global_allocator]` attribute\n/// to force the global allocator to be the system\u2019s one.\n/// (The default is jemalloc for executables, on some platforms.)\n///\n/// ```rust\n/// use std::alloc::System;\n///\n/// #[global_allocator]\n/// static A: System = System;\n///\n/// fn main() {\n///     let a = Box::new(4); // Allocates from the system allocator.\n///     println!(\"{}\", a);\n/// }\n/// ```\n///\n/// It can also be used directly to allocate memory\n/// independently of the standard library\u2019s global allocator.\n#[stable(feature = \"alloc_system_type\", since = \"1.28.0\")]\npub struct System;\n\n#[unstable(feature = \"allocator_api\", issue = \"32838\")]\nunsafe impl Alloc for System {\n    #[inline]\n    unsafe fn alloc(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n        NonNull::new(GlobalAlloc::alloc(self, layout)).ok_or(AllocErr)\n    }\n\n    #[inline]\n    unsafe fn alloc_zeroed(&mut self, layout: Layout) -> Result<NonNull<u8>, AllocErr> {\n        NonNull::new(GlobalAlloc::alloc_zeroed(self, layout)).ok_or(AllocErr)\n    }\n\n    #[inline]\n    unsafe fn dealloc(&mut self, ptr: NonNull<u8>, layout: Layout) {\n        GlobalAlloc::dealloc(self, ptr.as_ptr(), layout)\n    }\n\n    #[inline]\n    unsafe fn realloc(&mut self,\n                      ptr: NonNull<u8>,\n                      layout: Layout,\n                      new_size: usize) -> Result<NonNull<u8>, AllocErr> {\n        NonNull::new(GlobalAlloc::realloc(self, ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)\n    }\n}\n\n#[cfg(any(windows, unix, target_os = \"cloudabi\", target_os = \"redox\"))]\nmod realloc_fallback {\n    use core::alloc::{GlobalAlloc, Layout};\n    use core::cmp;\n    use core::ptr;\n\n    impl super::System {\n        pub(crate) unsafe fn realloc_fallback(&self, ptr: *mut u8, old_layout: Layout,\n                                              new_size: usize) -> *mut u8 {\n            // Docs for GlobalAlloc::realloc require this to be valid:\n            let new_layout = Layout::from_size_align_unchecked(new_size, old_layout.align());\n\n            let new_ptr = GlobalAlloc::alloc(self, new_layout);\n            if !new_ptr.is_null() {\n                let size = cmp::min(old_layout.size(), new_size);\n                ptr::copy_nonoverlapping(ptr, new_ptr, size);\n                GlobalAlloc::dealloc(self, ptr, old_layout);\n            }\n            new_ptr\n        }\n    }\n}\n\n#[cfg(any(unix, target_os = \"cloudabi\", target_os = \"redox\"))]\nmod platform {\n    extern crate libc;\n\n    use core::ptr;\n\n    use MIN_ALIGN;\n    use System;\n    use core::alloc::{GlobalAlloc, Layout};\n\n    #[stable(feature = \"alloc_system_type\", since = \"1.28.0\")]\n    unsafe impl GlobalAlloc for System {\n        #[inline]\n        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {\n            if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {\n                libc::malloc(layout.size()) as *mut u8\n            } else {\n                #[cfg(target_os = \"macos\")]\n                {\n                    if layout.align() > (1 << 31) {\n                        return ptr::null_mut()\n                    }\n                }\n                aligned_malloc(&layout)\n            }\n        }\n\n        #[inline]\n        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {\n            if layout.align() <= MIN_ALIGN && layout.align() <= layout.size() {\n                libc::calloc(layout.size(), 1) as *mut u8\n            } else {\n                let ptr = self.alloc(layout.clone());\n                if !ptr.is_null() {\n                    ptr::write_bytes(ptr, 0, layout.size());\n                }\n                ptr\n            }\n        }\n\n        #[inline]\n        unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {\n            libc::free(ptr as *mut libc::c_void)\n        }\n\n        #[inline]\n        unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {\n            if layout.align() <= MIN_ALIGN && layout.align() <= new_size {\n                libc::realloc(ptr as *mut libc::c_void, new_size) as *mut u8\n            } else {\n                self.realloc_fallback(ptr, layout, new_size)\n            }\n        }\n    }\n\n    #[cfg(any(target_os = \"android\",\n              target_os = \"hermit\",\n              target_os = \"redox\",\n              target_os = \"solaris\"))]\n    #[inline]\n    unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {\n        // On android we currently target API level 9 which unfortunately\n        // doesn't have the `posix_memalign` API used below. Instead we use\n        // `memalign`, but this unfortunately has the property on some systems\n        // where the memory returned cannot be deallocated by `free`!\n        //\n        // Upon closer inspection, however, this appears to work just fine with\n        // Android, so for this platform we should be fine to call `memalign`\n        // (which is present in API level 9). Some helpful references could\n        // possibly be chromium using memalign [1], attempts at documenting that\n        // memalign + free is ok [2] [3], or the current source of chromium\n        // which still uses memalign on android [4].\n        //\n        // [1]: https://codereview.chromium.org/10796020/\n        // [2]: https://code.google.com/p/android/issues/detail?id=35391\n        // [3]: https://bugs.chromium.org/p/chromium/issues/detail?id=138579\n        // [4]: https://chromium.googlesource.com/chromium/src/base/+/master/\n        //                                       /memory/aligned_memory.cc\n        libc::memalign(layout.align(), layout.size()) as *mut u8\n    }\n\n    #[cfg(not(any(target_os = \"android\",\n                  target_os = \"hermit\",\n                  target_os = \"redox\",\n                  target_os = \"solaris\")))]\n    #[inline]\n    unsafe fn aligned_malloc(layout: &Layout) -> *mut u8 {\n        let mut out = ptr::null_mut();\n        let ret = libc::posix_memalign(&mut out, layout.align(), layout.size());\n        if ret != 0 {\n            ptr::null_mut()\n        } else {\n            out as *mut u8\n        }\n    }\n}\n\n#[cfg(windows)]\n#[allow(nonstandard_style)]\nmod platform {\n    use MIN_ALIGN;\n    use System;\n    use core::alloc::{GlobalAlloc, Layout};\n\n    type LPVOID = *mut u8;\n    type HANDLE = LPVOID;\n    type SIZE_T = usize;\n    type DWORD = u32;\n    type BOOL = i32;\n\n    extern \"system\" {\n        fn GetProcessHeap() -> HANDLE;\n        fn HeapAlloc(hHeap: HANDLE, dwFlags: DWORD, dwBytes: SIZE_T) -> LPVOID;\n        fn HeapReAlloc(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID, dwBytes: SIZE_T) -> LPVOID;\n        fn HeapFree(hHeap: HANDLE, dwFlags: DWORD, lpMem: LPVOID) -> BOOL;\n        fn GetLastError() -> DWORD;\n    }\n\n    #[repr(C)]\n    struct Header(*mut u8);\n\n    const HEAP_ZERO_MEMORY: DWORD = 0x00000008;\n\n    unsafe fn get_header<'a>(ptr: *mut u8) -> &'a mut Header {\n        &mut *(ptr as *mut Header).offset(-1)\n    }\n\n    unsafe fn align_ptr(ptr: *mut u8, align: usize) -> *mut u8 {\n        let aligned = ptr.add(align - (ptr as usize & (align - 1)));\n        *get_header(aligned) = Header(ptr);\n        aligned\n    }\n\n    #[inline]\n    unsafe fn allocate_with_flags(layout: Layout, flags: DWORD) -> *mut u8 {\n        let ptr = if layout.align() <= MIN_ALIGN {\n            HeapAlloc(GetProcessHeap(), flags, layout.size())\n        } else {\n            let size = layout.size() + layout.align();\n            let ptr = HeapAlloc(GetProcessHeap(), flags, size);\n            if ptr.is_null() {\n                ptr\n            } else {\n                align_ptr(ptr, layout.align())\n            }\n        };\n        ptr as *mut u8\n    }\n\n    #[stable(feature = \"alloc_system_type\", since = \"1.28.0\")]\n    unsafe impl GlobalAlloc for System {\n        #[inline]\n        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {\n            allocate_with_flags(layout, 0)\n        }\n\n        #[inline]\n        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {\n            allocate_with_flags(layout, HEAP_ZERO_MEMORY)\n        }\n\n        #[inline]\n        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {\n            if layout.align() <= MIN_ALIGN {\n                let err = HeapFree(GetProcessHeap(), 0, ptr as LPVOID);\n                debug_assert!(err != 0, \"Failed to free heap memory: {}\",\n                              GetLastError());\n            } else {\n                let header = get_header(ptr);\n                let err = HeapFree(GetProcessHeap(), 0, header.0 as LPVOID);\n                debug_assert!(err != 0, \"Failed to free heap memory: {}\",\n                              GetLastError());\n            }\n        }\n\n        #[inline]\n        unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {\n            if layout.align() <= MIN_ALIGN {\n                HeapReAlloc(GetProcessHeap(), 0, ptr as LPVOID, new_size) as *mut u8\n            } else {\n                self.realloc_fallback(ptr, layout, new_size)\n            }\n        }\n    }\n}\n\n// This is an implementation of a global allocator on the wasm32 platform when\n// emscripten is not in use. In that situation there's no actual runtime for us\n// to lean on for allocation, so instead we provide our own!\n//\n// The wasm32 instruction set has two instructions for getting the current\n// amount of memory and growing the amount of memory. These instructions are the\n// foundation on which we're able to build an allocator, so we do so! Note that\n// the instructions are also pretty \"global\" and this is the \"global\" allocator\n// after all!\n//\n// The current allocator here is the `dlmalloc` crate which we've got included\n// in the rust-lang/rust repository as a submodule. The crate is a port of\n// dlmalloc.c from C to Rust and is basically just so we can have \"pure Rust\"\n// for now which is currently technically required (can't link with C yet).\n//\n// The crate itself provides a global allocator which on wasm has no\n// synchronization as there are no threads!\n#[cfg(all(target_arch = \"wasm32\", not(target_os = \"emscripten\")))]\nmod platform {\n    extern crate dlmalloc;\n\n    use core::alloc::{GlobalAlloc, Layout};\n    use System;\n\n    static mut DLMALLOC: dlmalloc::Dlmalloc = dlmalloc::DLMALLOC_INIT;\n\n    #[stable(feature = \"alloc_system_type\", since = \"1.28.0\")]\n    unsafe impl GlobalAlloc for System {\n        #[inline]\n        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {\n            let _lock = lock::lock();\n            DLMALLOC.malloc(layout.size(), layout.align())\n        }\n\n        #[inline]\n        unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8 {\n            let _lock = lock::lock();\n            DLMALLOC.calloc(layout.size(), layout.align())\n        }\n\n        #[inline]\n        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {\n            let _lock = lock::lock();\n            DLMALLOC.free(ptr, layout.size(), layout.align())\n        }\n\n        #[inline]\n        unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8 {\n            let _lock = lock::lock();\n            DLMALLOC.realloc(ptr, layout.size(), layout.align(), new_size)\n        }\n    }\n\n    #[cfg(target_feature = \"atomics\")]\n    mod lock {\n        use core::arch::wasm32;\n        use core::sync::atomic::{AtomicI32, Ordering::SeqCst};\n\n        static LOCKED: AtomicI32 = AtomicI32::new(0);\n\n        pub struct DropLock;\n\n        pub fn lock() -> DropLock {\n            loop {\n                if LOCKED.swap(1, SeqCst) == 0 {\n                    return DropLock\n                }\n                unsafe {\n                    let r = wasm32::atomic::wait_i32(\n                        &LOCKED as *const AtomicI32 as *mut i32,\n                        1,  // expected value\n                        -1, // timeout\n                    );\n                    debug_assert!(r == 0 || r == 1);\n                }\n            }\n        }\n\n        impl Drop for DropLock {\n            fn drop(&mut self) {\n                let r = LOCKED.swap(0, SeqCst);\n                debug_assert_eq!(r, 1);\n                unsafe {\n                    wasm32::atomic::wake(\n                        &LOCKED as *const AtomicI32 as *mut i32,\n                        1, // only one thread\n                    );\n                }\n            }\n        }\n    }\n\n    #[cfg(not(target_feature = \"atomics\"))]\n    mod lock {\n        #[inline]\n        pub fn lock() {} // no atomics, no threads, that's easy!\n    }\n}\n","//! Caches run-time feature detection so that it only needs to be computed\n//! once.\n\n#![allow(dead_code)] // not used on all platforms\n\nuse core::sync::atomic::Ordering;\n\n#[cfg(target_pointer_width = \"64\")]\nuse core::sync::atomic::AtomicU64;\n\n#[cfg(target_pointer_width = \"32\")]\nuse core::sync::atomic::AtomicU32;\n\n/// Sets the `bit` of `x`.\n#[inline]\nconst fn set_bit(x: u64, bit: u32) -> u64 {\n    x | 1 << bit\n}\n\n/// Tests the `bit` of `x`.\n#[inline]\nconst fn test_bit(x: u64, bit: u32) -> bool {\n    x & (1 << bit) != 0\n}\n\n/// Maximum number of features that can be cached.\nconst CACHE_CAPACITY: u32 = 63;\n\n/// This type is used to initialize the cache\n#[derive(Copy, Clone)]\npub(crate) struct Initializer(u64);\n\nimpl Default for Initializer {\n    fn default() -> Self {\n        Initializer(0)\n    }\n}\n\nimpl Initializer {\n    /// Tests the `bit` of the cache.\n    #[allow(dead_code)]\n    #[inline]\n    pub(crate) fn test(&self, bit: u32) -> bool {\n        // FIXME: this way of making sure that the cache is large enough is\n        // brittle.\n        debug_assert!(\n            bit < CACHE_CAPACITY,\n            \"too many features, time to increase the cache size!\"\n        );\n        test_bit(self.0, bit)\n    }\n\n    /// Sets the `bit` of the cache.\n    #[inline]\n    pub(crate) fn set(&mut self, bit: u32) {\n        // FIXME: this way of making sure that the cache is large enough is\n        // brittle.\n        debug_assert!(\n            bit < CACHE_CAPACITY,\n            \"too many features, time to increase the cache size!\"\n        );\n        let v = self.0;\n        self.0 = set_bit(v, bit);\n    }\n}\n\n/// This global variable is a cache of the features supported by the CPU.\nstatic CACHE: Cache = Cache::uninitialized();\n\n/// Feature cache with capacity for `CACHE_CAPACITY` features.\n///\n/// Note: the last feature bit is used to represent an\n/// uninitialized cache.\n#[cfg(target_pointer_width = \"64\")]\nstruct Cache(AtomicU64);\n\n#[cfg(target_pointer_width = \"64\")]\nimpl Cache {\n    /// Creates an uninitialized cache.\n    const fn uninitialized() -> Self {\n        Cache(AtomicU64::new(u64::max_value()))\n    }\n    /// Is the cache uninitialized?\n    #[inline]\n    pub(crate) fn is_uninitialized(&self) -> bool {\n        self.0.load(Ordering::Relaxed) == u64::max_value()\n    }\n\n    /// Is the `bit` in the cache set?\n    #[inline]\n    pub(crate) fn test(&self, bit: u32) -> bool {\n        test_bit(CACHE.0.load(Ordering::Relaxed), bit)\n    }\n\n    /// Initializes the cache.\n    #[inline]\n    pub(crate) fn initialize(&self, value: Initializer) {\n        self.0.store(value.0, Ordering::Relaxed);\n    }\n}\n\n/// Feature cache with capacity for `CACHE_CAPACITY` features.\n///\n/// Note: the last feature bit is used to represent an\n/// uninitialized cache.\n#[cfg(target_pointer_width = \"32\")]\nstruct Cache(AtomicU32, AtomicU32);\n\n#[cfg(target_pointer_width = \"32\")]\nimpl Cache {\n    /// Creates an uninitialized cache.\n    const fn uninitialized() -> Self {\n        Cache(\n            AtomicU32::new(u32::max_value()),\n            AtomicU32::new(u32::max_value()),\n        )\n    }\n    /// Is the cache uninitialized?\n    #[inline]\n    pub(crate) fn is_uninitialized(&self) -> bool {\n        self.1.load(Ordering::Relaxed) == u32::max_value()\n    }\n\n    /// Is the `bit` in the cache set?\n    #[inline]\n    pub(crate) fn test(&self, bit: u32) -> bool {\n        if bit < 32 {\n            test_bit(CACHE.0.load(Ordering::Relaxed) as u64, bit)\n        } else {\n            test_bit(CACHE.1.load(Ordering::Relaxed) as u64, bit - 32)\n        }\n    }\n\n    /// Initializes the cache.\n    #[inline]\n    pub(crate) fn initialize(&self, value: Initializer) {\n        let lo: u32 = value.0 as u32;\n        let hi: u32 = (value.0 >> 32) as u32;\n        self.0.store(lo, Ordering::Relaxed);\n        self.1.store(hi, Ordering::Relaxed);\n    }\n}\n\n/// Test the `bit` of the storage. If the storage has not been initialized,\n/// initializes it with the result of `f()`.\n///\n/// On its first invocation, it detects the CPU features and caches them in the\n/// `CACHE` global variable as an `AtomicU64`.\n///\n/// It uses the `Feature` variant to index into this variable as a bitset. If\n/// the bit is set, the feature is enabled, and otherwise it is disabled.\n#[inline]\npub(crate) fn test<F>(bit: u32, f: F) -> bool\nwhere\n    F: FnOnce() -> Initializer,\n{\n    if CACHE.is_uninitialized() {\n        CACHE.initialize(f());\n    }\n    CACHE.test(bit)\n}\n","// Copyright 2014-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse self::Entry::*;\nuse self::VacantEntryState::*;\n\nuse collections::CollectionAllocErr;\nuse cell::Cell;\nuse borrow::Borrow;\nuse cmp::max;\nuse fmt::{self, Debug};\n#[allow(deprecated)]\nuse hash::{Hash, Hasher, BuildHasher, SipHasher13};\nuse iter::{FromIterator, FusedIterator};\nuse mem::{self, replace};\nuse ops::{Deref, DerefMut, Index};\nuse sys;\n\nuse super::table::{self, Bucket, EmptyBucket, Fallibility, FullBucket, FullBucketMut, RawTable,\n                   SafeHash};\nuse super::table::BucketState::{Empty, Full};\nuse super::table::Fallibility::{Fallible, Infallible};\n\nconst MIN_NONZERO_RAW_CAPACITY: usize = 32;     // must be a power of two\n\n/// The default behavior of HashMap implements a maximum load factor of 90.9%.\n#[derive(Clone)]\nstruct DefaultResizePolicy;\n\nimpl DefaultResizePolicy {\n    #[inline]\n    fn new() -> DefaultResizePolicy {\n        DefaultResizePolicy\n    }\n\n    /// A hash map's \"capacity\" is the number of elements it can hold without\n    /// being resized. Its \"raw capacity\" is the number of slots required to\n    /// provide that capacity, accounting for maximum loading. The raw capacity\n    /// is always zero or a power of two.\n    #[inline]\n    fn try_raw_capacity(&self, len: usize) -> Result<usize, CollectionAllocErr> {\n        if len == 0 {\n            Ok(0)\n        } else {\n            // 1. Account for loading: `raw_capacity >= len * 1.1`.\n            // 2. Ensure it is a power of two.\n            // 3. Ensure it is at least the minimum size.\n            let mut raw_cap = len.checked_mul(11)\n                .map(|l| l / 10)\n                .and_then(|l| l.checked_next_power_of_two())\n                .ok_or(CollectionAllocErr::CapacityOverflow)?;\n\n            raw_cap = max(MIN_NONZERO_RAW_CAPACITY, raw_cap);\n            Ok(raw_cap)\n        }\n    }\n\n    #[inline]\n    fn raw_capacity(&self, len: usize) -> usize {\n        self.try_raw_capacity(len).expect(\"raw_capacity overflow\")\n    }\n\n    /// The capacity of the given raw capacity.\n    #[inline]\n    fn capacity(&self, raw_cap: usize) -> usize {\n        // This doesn't have to be checked for overflow since allocation size\n        // in bytes will overflow earlier than multiplication by 10.\n        //\n        // As per https://github.com/rust-lang/rust/pull/30991 this is updated\n        // to be: (raw_cap * den + den - 1) / num\n        (raw_cap * 10 + 10 - 1) / 11\n    }\n}\n\n// The main performance trick in this hashmap is called Robin Hood Hashing.\n// It gains its excellent performance from one essential operation:\n//\n//    If an insertion collides with an existing element, and that element's\n//    \"probe distance\" (how far away the element is from its ideal location)\n//    is higher than how far we've already probed, swap the elements.\n//\n// This massively lowers variance in probe distance, and allows us to get very\n// high load factors with good performance. The 90% load factor I use is rather\n// conservative.\n//\n// > Why a load factor of approximately 90%?\n//\n// In general, all the distances to initial buckets will converge on the mean.\n// At a load factor of \u03b1, the odds of finding the target bucket after k\n// probes is approximately 1-\u03b1^k. If we set this equal to 50% (since we converge\n// on the mean) and set k=8 (64-byte cache line / 8-byte hash), \u03b1=0.92. I round\n// this down to make the math easier on the CPU and avoid its FPU.\n// Since on average we start the probing in the middle of a cache line, this\n// strategy pulls in two cache lines of hashes on every lookup. I think that's\n// pretty good, but if you want to trade off some space, it could go down to one\n// cache line on average with an \u03b1 of 0.84.\n//\n// > Wait, what? Where did you get 1-\u03b1^k from?\n//\n// On the first probe, your odds of a collision with an existing element is \u03b1.\n// The odds of doing this twice in a row is approximately \u03b1^2. For three times,\n// \u03b1^3, etc. Therefore, the odds of colliding k times is \u03b1^k. The odds of NOT\n// colliding after k tries is 1-\u03b1^k.\n//\n// The paper from 1986 cited below mentions an implementation which keeps track\n// of the distance-to-initial-bucket histogram. This approach is not suitable\n// for modern architectures because it requires maintaining an internal data\n// structure. This allows very good first guesses, but we are most concerned\n// with guessing entire cache lines, not individual indexes. Furthermore, array\n// accesses are no longer linear and in one direction, as we have now. There\n// is also memory and cache pressure that this would entail that would be very\n// difficult to properly see in a microbenchmark.\n//\n// ## Future Improvements (FIXME!)\n//\n// Allow the load factor to be changed dynamically and/or at initialization.\n//\n// Also, would it be possible for us to reuse storage when growing the\n// underlying table? This is exactly the use case for 'realloc', and may\n// be worth exploring.\n//\n// ## Future Optimizations (FIXME!)\n//\n// Another possible design choice that I made without any real reason is\n// parameterizing the raw table over keys and values. Technically, all we need\n// is the size and alignment of keys and values, and the code should be just as\n// efficient (well, we might need one for power-of-two size and one for not...).\n// This has the potential to reduce code bloat in rust executables, without\n// really losing anything except 4 words (key size, key alignment, val size,\n// val alignment) which can be passed in to every call of a `RawTable` function.\n// This would definitely be an avenue worth exploring if people start complaining\n// about the size of rust executables.\n//\n// Annotate exceedingly likely branches in `table::make_hash`\n// and `search_hashed` to reduce instruction cache pressure\n// and mispredictions once it becomes possible (blocked on issue #11092).\n//\n// Shrinking the table could simply reallocate in place after moving buckets\n// to the first half.\n//\n// The growth algorithm (fragment of the Proof of Correctness)\n// --------------------\n//\n// The growth algorithm is basically a fast path of the naive reinsertion-\n// during-resize algorithm. Other paths should never be taken.\n//\n// Consider growing a robin hood hashtable of capacity n. Normally, we do this\n// by allocating a new table of capacity `2n`, and then individually reinsert\n// each element in the old table into the new one. This guarantees that the\n// new table is a valid robin hood hashtable with all the desired statistical\n// properties. Remark that the order we reinsert the elements in should not\n// matter. For simplicity and efficiency, we will consider only linear\n// reinsertions, which consist of reinserting all elements in the old table\n// into the new one by increasing order of index. However we will not be\n// starting our reinsertions from index 0 in general. If we start from index\n// i, for the purpose of reinsertion we will consider all elements with real\n// index j < i to have virtual index n + j.\n//\n// Our hash generation scheme consists of generating a 64-bit hash and\n// truncating the most significant bits. When moving to the new table, we\n// simply introduce a new bit to the front of the hash. Therefore, if an\n// element has ideal index i in the old table, it can have one of two ideal\n// locations in the new table. If the new bit is 0, then the new ideal index\n// is i. If the new bit is 1, then the new ideal index is n + i. Intuitively,\n// we are producing two independent tables of size n, and for each element we\n// independently choose which table to insert it into with equal probability.\n// However, rather than wrapping around themselves on overflowing their\n// indexes, the first table overflows into the second, and the second into the\n// first. Visually, our new table will look something like:\n//\n// [yy_xxx_xxxx_xxx|xx_yyy_yyyy_yyy]\n//\n// Where x's are elements inserted into the first table, y's are elements\n// inserted into the second, and _'s are empty sections. We now define a few\n// key concepts that we will use later. Note that this is a very abstract\n// perspective of the table. A real resized table would be at least half\n// empty.\n//\n// Theorem: A linear robin hood reinsertion from the first ideal element\n// produces identical results to a linear naive reinsertion from the same\n// element.\n//\n// FIXME(Gankro, pczarn): review the proof and put it all in a separate README.md\n//\n// Adaptive early resizing\n// ----------------------\n// To protect against degenerate performance scenarios (including DOS attacks),\n// the implementation includes an adaptive behavior that can resize the map\n// early (before its capacity is exceeded) when suspiciously long probe sequences\n// are encountered.\n//\n// With this algorithm in place it would be possible to turn a CPU attack into\n// a memory attack due to the aggressive resizing. To prevent that the\n// adaptive behavior only triggers when the map is at least half full.\n// This reduces the effectiveness of the algorithm but also makes it completely safe.\n//\n// The previous safety measure also prevents degenerate interactions with\n// really bad quality hash algorithms that can make normal inputs look like a\n// DOS attack.\n//\nconst DISPLACEMENT_THRESHOLD: usize = 128;\n//\n// The threshold of 128 is chosen to minimize the chance of exceeding it.\n// In particular, we want that chance to be less than 10^-8 with a load of 90%.\n// For displacement, the smallest constant that fits our needs is 90,\n// so we round that up to 128.\n//\n// At a load factor of \u03b1, the odds of finding the target bucket after exactly n\n// unsuccessful probes[1] are\n//\n// Pr_\u03b1{displacement = n} =\n// (1 - \u03b1) / \u03b1 * \u2211_{k\u22651} e^(-k\u03b1) * (k\u03b1)^(k+n) / (k + n)! * (1 - k\u03b1 / (k + n + 1))\n//\n// We use this formula to find the probability of triggering the adaptive behavior\n//\n// Pr_0.909{displacement > 128} = 1.601 * 10^-11\n//\n// 1. Alfredo Viola (2005). Distributional analysis of Robin Hood linear probing\n//    hashing with buckets.\n\n/// A hash map implemented with linear probing and Robin Hood bucket stealing.\n///\n/// By default, `HashMap` uses a hashing algorithm selected to provide\n/// resistance against HashDoS attacks. The algorithm is randomly seeded, and a\n/// reasonable best-effort is made to generate this seed from a high quality,\n/// secure source of randomness provided by the host without blocking the\n/// program. Because of this, the randomness of the seed depends on the output\n/// quality of the system's random number generator when the seed is created.\n/// In particular, seeds generated when the system's entropy pool is abnormally\n/// low such as during system boot may be of a lower quality.\n///\n/// The default hashing algorithm is currently SipHash 1-3, though this is\n/// subject to change at any point in the future. While its performance is very\n/// competitive for medium sized keys, other hashing algorithms will outperform\n/// it for small keys such as integers as well as large keys such as long\n/// strings, though those algorithms will typically *not* protect against\n/// attacks such as HashDoS.\n///\n/// The hashing algorithm can be replaced on a per-`HashMap` basis using the\n/// [`default`], [`with_hasher`], and [`with_capacity_and_hasher`] methods. Many\n/// alternative algorithms are available on crates.io, such as the [`fnv`] crate.\n///\n/// It is required that the keys implement the [`Eq`] and [`Hash`] traits, although\n/// this can frequently be achieved by using `#[derive(PartialEq, Eq, Hash)]`.\n/// If you implement these yourself, it is important that the following\n/// property holds:\n///\n/// ```text\n/// k1 == k2 -> hash(k1) == hash(k2)\n/// ```\n///\n/// In other words, if two keys are equal, their hashes must be equal.\n///\n/// It is a logic error for a key to be modified in such a way that the key's\n/// hash, as determined by the [`Hash`] trait, or its equality, as determined by\n/// the [`Eq`] trait, changes while it is in the map. This is normally only\n/// possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.\n///\n/// Relevant papers/articles:\n///\n/// 1. Pedro Celis. [\"Robin Hood Hashing\"](https://cs.uwaterloo.ca/research/tr/1986/CS-86-14.pdf)\n/// 2. Emmanuel Goossaert. [\"Robin Hood\n///    hashing\"](http://codecapsule.com/2013/11/11/robin-hood-hashing/)\n/// 3. Emmanuel Goossaert. [\"Robin Hood hashing: backward shift\n///    deletion\"](http://codecapsule.com/2013/11/17/robin-hood-hashing-backward-shift-deletion/)\n///\n/// # Examples\n///\n/// ```\n/// use std::collections::HashMap;\n///\n/// // Type inference lets us omit an explicit type signature (which\n/// // would be `HashMap<String, String>` in this example).\n/// let mut book_reviews = HashMap::new();\n///\n/// // Review some books.\n/// book_reviews.insert(\n///     \"Adventures of Huckleberry Finn\".to_string(),\n///     \"My favorite book.\".to_string(),\n/// );\n/// book_reviews.insert(\n///     \"Grimms' Fairy Tales\".to_string(),\n///     \"Masterpiece.\".to_string(),\n/// );\n/// book_reviews.insert(\n///     \"Pride and Prejudice\".to_string(),\n///     \"Very enjoyable.\".to_string(),\n/// );\n/// book_reviews.insert(\n///     \"The Adventures of Sherlock Holmes\".to_string(),\n///     \"Eye lyked it alot.\".to_string(),\n/// );\n///\n/// // Check for a specific one.\n/// // When collections store owned values (String), they can still be\n/// // queried using references (&str).\n/// if !book_reviews.contains_key(\"Les Mis\u00e9rables\") {\n///     println!(\"We've got {} reviews, but Les Mis\u00e9rables ain't one.\",\n///              book_reviews.len());\n/// }\n///\n/// // oops, this review has a lot of spelling mistakes, let's delete it.\n/// book_reviews.remove(\"The Adventures of Sherlock Holmes\");\n///\n/// // Look up the values associated with some keys.\n/// let to_find = [\"Pride and Prejudice\", \"Alice's Adventure in Wonderland\"];\n/// for &book in &to_find {\n///     match book_reviews.get(book) {\n///         Some(review) => println!(\"{}: {}\", book, review),\n///         None => println!(\"{} is unreviewed.\", book)\n///     }\n/// }\n///\n/// // Iterate over everything.\n/// for (book, review) in &book_reviews {\n///     println!(\"{}: \\\"{}\\\"\", book, review);\n/// }\n/// ```\n///\n/// `HashMap` also implements an [`Entry API`](#method.entry), which allows\n/// for more complex methods of getting, setting, updating and removing keys and\n/// their values:\n///\n/// ```\n/// use std::collections::HashMap;\n///\n/// // type inference lets us omit an explicit type signature (which\n/// // would be `HashMap<&str, u8>` in this example).\n/// let mut player_stats = HashMap::new();\n///\n/// fn random_stat_buff() -> u8 {\n///     // could actually return some random value here - let's just return\n///     // some fixed value for now\n///     42\n/// }\n///\n/// // insert a key only if it doesn't already exist\n/// player_stats.entry(\"health\").or_insert(100);\n///\n/// // insert a key using a function that provides a new value only if it\n/// // doesn't already exist\n/// player_stats.entry(\"defence\").or_insert_with(random_stat_buff);\n///\n/// // update a key, guarding against the key possibly not being set\n/// let stat = player_stats.entry(\"attack\").or_insert(100);\n/// *stat += random_stat_buff();\n/// ```\n///\n/// The easiest way to use `HashMap` with a custom type as key is to derive [`Eq`] and [`Hash`].\n/// We must also derive [`PartialEq`].\n///\n/// [`Eq`]: ../../std/cmp/trait.Eq.html\n/// [`Hash`]: ../../std/hash/trait.Hash.html\n/// [`PartialEq`]: ../../std/cmp/trait.PartialEq.html\n/// [`RefCell`]: ../../std/cell/struct.RefCell.html\n/// [`Cell`]: ../../std/cell/struct.Cell.html\n/// [`default`]: #method.default\n/// [`with_hasher`]: #method.with_hasher\n/// [`with_capacity_and_hasher`]: #method.with_capacity_and_hasher\n/// [`fnv`]: https://crates.io/crates/fnv\n///\n/// ```\n/// use std::collections::HashMap;\n///\n/// #[derive(Hash, Eq, PartialEq, Debug)]\n/// struct Viking {\n///     name: String,\n///     country: String,\n/// }\n///\n/// impl Viking {\n///     /// Create a new Viking.\n///     fn new(name: &str, country: &str) -> Viking {\n///         Viking { name: name.to_string(), country: country.to_string() }\n///     }\n/// }\n///\n/// // Use a HashMap to store the vikings' health points.\n/// let mut vikings = HashMap::new();\n///\n/// vikings.insert(Viking::new(\"Einar\", \"Norway\"), 25);\n/// vikings.insert(Viking::new(\"Olaf\", \"Denmark\"), 24);\n/// vikings.insert(Viking::new(\"Harald\", \"Iceland\"), 12);\n///\n/// // Use derived implementation to print the status of the vikings.\n/// for (viking, health) in &vikings {\n///     println!(\"{:?} has {} hp\", viking, health);\n/// }\n/// ```\n///\n/// A `HashMap` with fixed list of elements can be initialized from an array:\n///\n/// ```\n/// use std::collections::HashMap;\n///\n/// fn main() {\n///     let timber_resources: HashMap<&str, i32> =\n///     [(\"Norway\", 100),\n///      (\"Denmark\", 50),\n///      (\"Iceland\", 10)]\n///      .iter().cloned().collect();\n///     // use the values stored in map\n/// }\n/// ```\n\n#[derive(Clone)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct HashMap<K, V, S = RandomState> {\n    // All hashes are keyed on these values, to prevent hash collision attacks.\n    hash_builder: S,\n\n    table: RawTable<K, V>,\n\n    resize_policy: DefaultResizePolicy,\n}\n\n/// Search for a pre-hashed key.\n/// If you don't already know the hash, use search or search_mut instead\n#[inline]\nfn search_hashed<K, V, M, F>(table: M, hash: SafeHash, is_match: F) -> InternalEntry<K, V, M>\n    where M: Deref<Target = RawTable<K, V>>,\n          F: FnMut(&K) -> bool\n{\n    // This is the only function where capacity can be zero. To avoid\n    // undefined behavior when Bucket::new gets the raw bucket in this\n    // case, immediately return the appropriate search result.\n    if table.capacity() == 0 {\n        return InternalEntry::TableIsEmpty;\n    }\n\n    search_hashed_nonempty(table, hash, is_match, true)\n}\n\n/// Search for a pre-hashed key when the hash map is known to be non-empty.\n#[inline]\nfn search_hashed_nonempty<K, V, M, F>(table: M, hash: SafeHash, mut is_match: F,\n                                      compare_hashes: bool)\n    -> InternalEntry<K, V, M>\n    where M: Deref<Target = RawTable<K, V>>,\n          F: FnMut(&K) -> bool\n{\n    // Do not check the capacity as an extra branch could slow the lookup.\n\n    let size = table.size();\n    let mut probe = Bucket::new(table, hash);\n    let mut displacement = 0;\n\n    loop {\n        let full = match probe.peek() {\n            Empty(bucket) => {\n                // Found a hole!\n                return InternalEntry::Vacant {\n                    hash,\n                    elem: NoElem(bucket, displacement),\n                };\n            }\n            Full(bucket) => bucket,\n        };\n\n        let probe_displacement = full.displacement();\n\n        if probe_displacement < displacement {\n            // Found a luckier bucket than me.\n            // We can finish the search early if we hit any bucket\n            // with a lower distance to initial bucket than we've probed.\n            return InternalEntry::Vacant {\n                hash,\n                elem: NeqElem(full, probe_displacement),\n            };\n        }\n\n        // If the hash doesn't match, it can't be this one..\n        if !compare_hashes || hash == full.hash() {\n            // If the key doesn't match, it can't be this one..\n            if is_match(full.read().0) {\n                return InternalEntry::Occupied { elem: full };\n            }\n        }\n        displacement += 1;\n        probe = full.next();\n        debug_assert!(displacement <= size);\n    }\n}\n\n/// Same as `search_hashed_nonempty` but for mutable access.\n#[inline]\nfn search_hashed_nonempty_mut<K, V, M, F>(table: M, hash: SafeHash, mut is_match: F,\n                                          compare_hashes: bool)\n    -> InternalEntry<K, V, M>\n    where M: DerefMut<Target = RawTable<K, V>>,\n          F: FnMut(&K) -> bool\n{\n    // Do not check the capacity as an extra branch could slow the lookup.\n\n    let size = table.size();\n    let mut probe = Bucket::new(table, hash);\n    let mut displacement = 0;\n\n    loop {\n        let mut full = match probe.peek() {\n            Empty(bucket) => {\n                // Found a hole!\n                return InternalEntry::Vacant {\n                    hash,\n                    elem: NoElem(bucket, displacement),\n                };\n            }\n            Full(bucket) => bucket,\n        };\n\n        let probe_displacement = full.displacement();\n\n        if probe_displacement < displacement {\n            // Found a luckier bucket than me.\n            // We can finish the search early if we hit any bucket\n            // with a lower distance to initial bucket than we've probed.\n            return InternalEntry::Vacant {\n                hash,\n                elem: NeqElem(full, probe_displacement),\n            };\n        }\n\n        // If the hash doesn't match, it can't be this one..\n        if hash == full.hash() || !compare_hashes {\n            // If the key doesn't match, it can't be this one..\n            if is_match(full.read_mut().0) {\n                return InternalEntry::Occupied { elem: full };\n            }\n        }\n        displacement += 1;\n        probe = full.next();\n        debug_assert!(displacement <= size);\n    }\n}\n\nfn pop_internal<K, V>(starting_bucket: FullBucketMut<K, V>)\n    -> (K, V, &mut RawTable<K, V>)\n{\n    let (empty, retkey, retval) = starting_bucket.take();\n    let mut gap = match empty.gap_peek() {\n        Ok(b) => b,\n        Err(b) => return (retkey, retval, b.into_table()),\n    };\n\n    while gap.full().displacement() != 0 {\n        gap = match gap.shift() {\n            Ok(b) => b,\n            Err(b) => {\n                return (retkey, retval, b.into_table());\n            },\n        };\n    }\n\n    // Now we've done all our shifting. Return the value we grabbed earlier.\n    (retkey, retval, gap.into_table())\n}\n\n/// Perform robin hood bucket stealing at the given `bucket`. You must\n/// also pass that bucket's displacement so we don't have to recalculate it.\n///\n/// `hash`, `key`, and `val` are the elements to \"robin hood\" into the hashtable.\nfn robin_hood<'a, K: 'a, V: 'a>(bucket: FullBucketMut<'a, K, V>,\n                                mut displacement: usize,\n                                mut hash: SafeHash,\n                                mut key: K,\n                                mut val: V)\n                                -> FullBucketMut<'a, K, V> {\n    let size = bucket.table().size();\n    let raw_capacity = bucket.table().capacity();\n    // There can be at most `size - dib` buckets to displace, because\n    // in the worst case, there are `size` elements and we already are\n    // `displacement` buckets away from the initial one.\n    let idx_end = (bucket.index() + size - bucket.displacement()) % raw_capacity;\n    // Save the *starting point*.\n    let mut bucket = bucket.stash();\n\n    loop {\n        let (old_hash, old_key, old_val) = bucket.replace(hash, key, val);\n        hash = old_hash;\n        key = old_key;\n        val = old_val;\n\n        loop {\n            displacement += 1;\n            let probe = bucket.next();\n            debug_assert!(probe.index() != idx_end);\n\n            let full_bucket = match probe.peek() {\n                Empty(bucket) => {\n                    // Found a hole!\n                    let bucket = bucket.put(hash, key, val);\n                    // Now that it's stolen, just read the value's pointer\n                    // right out of the table! Go back to the *starting point*.\n                    //\n                    // This use of `into_table` is misleading. It turns the\n                    // bucket, which is a FullBucket on top of a\n                    // FullBucketMut, into just one FullBucketMut. The \"table\"\n                    // refers to the inner FullBucketMut in this context.\n                    return bucket.into_table();\n                }\n                Full(bucket) => bucket,\n            };\n\n            let probe_displacement = full_bucket.displacement();\n\n            bucket = full_bucket;\n\n            // Robin hood! Steal the spot.\n            if probe_displacement < displacement {\n                displacement = probe_displacement;\n                break;\n            }\n        }\n    }\n}\n\nimpl<K, V, S> HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    fn make_hash<X: ?Sized>(&self, x: &X) -> SafeHash\n        where X: Hash\n    {\n        table::make_hash(&self.hash_builder, x)\n    }\n\n    /// Search for a key, yielding the index if it's found in the hashtable.\n    /// If you already have the hash for the key lying around, or if you need an\n    /// InternalEntry, use search_hashed or search_hashed_nonempty.\n    #[inline]\n    fn search<'a, Q: ?Sized>(&'a self, q: &Q)\n        -> Option<FullBucket<K, V, &'a RawTable<K, V>>>\n        where K: Borrow<Q>,\n              Q: Eq + Hash\n    {\n        if self.is_empty() {\n            return None;\n        }\n\n        let hash = self.make_hash(q);\n        search_hashed_nonempty(&self.table, hash, |k| q.eq(k.borrow()), true)\n            .into_occupied_bucket()\n    }\n\n    #[inline]\n    fn search_mut<'a, Q: ?Sized>(&'a mut self, q: &Q)\n        -> Option<FullBucket<K, V, &'a mut RawTable<K, V>>>\n        where K: Borrow<Q>,\n              Q: Eq + Hash\n    {\n        if self.is_empty() {\n            return None;\n        }\n\n        let hash = self.make_hash(q);\n        search_hashed_nonempty(&mut self.table, hash, |k| q.eq(k.borrow()), true)\n            .into_occupied_bucket()\n    }\n\n    // The caller should ensure that invariants by Robin Hood Hashing hold\n    // and that there's space in the underlying table.\n    fn insert_hashed_ordered(&mut self, hash: SafeHash, k: K, v: V) {\n        let mut buckets = Bucket::new(&mut self.table, hash);\n        let start_index = buckets.index();\n\n        loop {\n            // We don't need to compare hashes for value swap.\n            // Not even DIBs for Robin Hood.\n            buckets = match buckets.peek() {\n                Empty(empty) => {\n                    empty.put(hash, k, v);\n                    return;\n                }\n                Full(b) => b.into_bucket(),\n            };\n            buckets.next();\n            debug_assert!(buckets.index() != start_index);\n        }\n    }\n}\n\nimpl<K: Hash + Eq, V> HashMap<K, V, RandomState> {\n    /// Creates an empty `HashMap`.\n    ///\n    /// The hash map is initially created with a capacity of 0, so it will not allocate until it\n    /// is first inserted into.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// let mut map: HashMap<&str, i32> = HashMap::new();\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new() -> HashMap<K, V, RandomState> {\n        Default::default()\n    }\n\n    /// Creates an empty `HashMap` with the specified capacity.\n    ///\n    /// The hash map will be able to hold at least `capacity` elements without\n    /// reallocating. If `capacity` is 0, the hash map will not allocate.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState> {\n        HashMap::with_capacity_and_hasher(capacity, Default::default())\n    }\n}\n\nimpl<K, V, S> HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    /// Creates an empty `HashMap` which will use the given hash builder to hash\n    /// keys.\n    ///\n    /// The created map has the default initial capacity.\n    ///\n    /// Warning: `hash_builder` is normally randomly generated, and\n    /// is designed to allow HashMaps to be resistant to attacks that\n    /// cause many collisions and very poor performance. Setting it\n    /// manually using this function can expose a DoS attack vector.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::RandomState;\n    ///\n    /// let s = RandomState::new();\n    /// let mut map = HashMap::with_hasher(s);\n    /// map.insert(1, 2);\n    /// ```\n    #[inline]\n    #[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\n    pub fn with_hasher(hash_builder: S) -> HashMap<K, V, S> {\n        HashMap {\n            hash_builder,\n            resize_policy: DefaultResizePolicy::new(),\n            table: RawTable::new(0),\n        }\n    }\n\n    /// Creates an empty `HashMap` with the specified capacity, using `hash_builder`\n    /// to hash the keys.\n    ///\n    /// The hash map will be able to hold at least `capacity` elements without\n    /// reallocating. If `capacity` is 0, the hash map will not allocate.\n    ///\n    /// Warning: `hash_builder` is normally randomly generated, and\n    /// is designed to allow HashMaps to be resistant to attacks that\n    /// cause many collisions and very poor performance. Setting it\n    /// manually using this function can expose a DoS attack vector.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::RandomState;\n    ///\n    /// let s = RandomState::new();\n    /// let mut map = HashMap::with_capacity_and_hasher(10, s);\n    /// map.insert(1, 2);\n    /// ```\n    #[inline]\n    #[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\n    pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {\n        let resize_policy = DefaultResizePolicy::new();\n        let raw_cap = resize_policy.raw_capacity(capacity);\n        HashMap {\n            hash_builder,\n            resize_policy,\n            table: RawTable::new(raw_cap),\n        }\n    }\n\n    /// Returns a reference to the map's [`BuildHasher`].\n    ///\n    /// [`BuildHasher`]: ../../std/hash/trait.BuildHasher.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::RandomState;\n    ///\n    /// let hasher = RandomState::new();\n    /// let map: HashMap<i32, i32> = HashMap::with_hasher(hasher);\n    /// let hasher: &RandomState = map.hasher();\n    /// ```\n    #[stable(feature = \"hashmap_public_hasher\", since = \"1.9.0\")]\n    pub fn hasher(&self) -> &S {\n        &self.hash_builder\n    }\n\n    /// Returns the number of elements the map can hold without reallocating.\n    ///\n    /// This number is a lower bound; the `HashMap<K, V>` might be able to hold\n    /// more, but is guaranteed to be able to hold at least this many.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// let map: HashMap<i32, i32> = HashMap::with_capacity(100);\n    /// assert!(map.capacity() >= 100);\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn capacity(&self) -> usize {\n        self.resize_policy.capacity(self.raw_capacity())\n    }\n\n    /// Returns the hash map's raw capacity.\n    #[inline]\n    fn raw_capacity(&self) -> usize {\n        self.table.capacity()\n    }\n\n    /// Reserves capacity for at least `additional` more elements to be inserted\n    /// in the `HashMap`. The collection may reserve more space to avoid\n    /// frequent reallocations.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the new allocation size overflows [`usize`].\n    ///\n    /// [`usize`]: ../../std/primitive.usize.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// let mut map: HashMap<&str, i32> = HashMap::new();\n    /// map.reserve(10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn reserve(&mut self, additional: usize) {\n        match self.reserve_internal(additional, Infallible) {\n            Err(CollectionAllocErr::CapacityOverflow) => panic!(\"capacity overflow\"),\n            Err(CollectionAllocErr::AllocErr) => unreachable!(),\n            Ok(()) => { /* yay */ }\n        }\n    }\n\n    /// Tries to reserve capacity for at least `additional` more elements to be inserted\n    /// in the given `HashMap<K,V>`. The collection may reserve more space to avoid\n    /// frequent reallocations.\n    ///\n    /// # Errors\n    ///\n    /// If the capacity overflows, or the allocator reports a failure, then an error\n    /// is returned.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(try_reserve)]\n    /// use std::collections::HashMap;\n    /// let mut map: HashMap<&str, isize> = HashMap::new();\n    /// map.try_reserve(10).expect(\"why is the test harness OOMing on 10 bytes?\");\n    /// ```\n    #[unstable(feature = \"try_reserve\", reason = \"new API\", issue=\"48043\")]\n    pub fn try_reserve(&mut self, additional: usize) -> Result<(), CollectionAllocErr> {\n        self.reserve_internal(additional, Fallible)\n    }\n\n    fn reserve_internal(&mut self, additional: usize, fallibility: Fallibility)\n        -> Result<(), CollectionAllocErr> {\n\n        let remaining = self.capacity() - self.len(); // this can't overflow\n        if remaining < additional {\n            let min_cap = self.len()\n                .checked_add(additional)\n                .ok_or(CollectionAllocErr::CapacityOverflow)?;\n            let raw_cap = self.resize_policy.try_raw_capacity(min_cap)?;\n            self.try_resize(raw_cap, fallibility)?;\n        } else if self.table.tag() && remaining <= self.len() {\n            // Probe sequence is too long and table is half full,\n            // resize early to reduce probing length.\n            let new_capacity = self.table.capacity() * 2;\n            self.try_resize(new_capacity, fallibility)?;\n        }\n        Ok(())\n    }\n\n    /// Resizes the internal vectors to a new capacity. It's your\n    /// responsibility to:\n    ///   1) Ensure `new_raw_cap` is enough for all the elements, accounting\n    ///      for the load factor.\n    ///   2) Ensure `new_raw_cap` is a power of two or zero.\n    #[inline(never)]\n    #[cold]\n    fn try_resize(\n        &mut self,\n        new_raw_cap: usize,\n        fallibility: Fallibility,\n    ) -> Result<(), CollectionAllocErr> {\n        assert!(self.table.size() <= new_raw_cap);\n        assert!(new_raw_cap.is_power_of_two() || new_raw_cap == 0);\n\n        let mut old_table = replace(\n            &mut self.table,\n            match fallibility {\n                Infallible => RawTable::new(new_raw_cap),\n                Fallible => RawTable::try_new(new_raw_cap)?,\n            }\n        );\n        let old_size = old_table.size();\n\n        if old_table.size() == 0 {\n            return Ok(());\n        }\n\n        let mut bucket = Bucket::head_bucket(&mut old_table);\n\n        // This is how the buckets might be laid out in memory:\n        // ($ marks an initialized bucket)\n        //  ________________\n        // |$$$_$$$$$$_$$$$$|\n        //\n        // But we've skipped the entire initial cluster of buckets\n        // and will continue iteration in this order:\n        //  ________________\n        //     |$$$$$$_$$$$$\n        //                  ^ wrap around once end is reached\n        //  ________________\n        //  $$$_____________|\n        //    ^ exit once table.size == 0\n        loop {\n            bucket = match bucket.peek() {\n                Full(bucket) => {\n                    let h = bucket.hash();\n                    let (b, k, v) = bucket.take();\n                    self.insert_hashed_ordered(h, k, v);\n                    if b.table().size() == 0 {\n                        break;\n                    }\n                    b.into_bucket()\n                }\n                Empty(b) => b.into_bucket(),\n            };\n            bucket.next();\n        }\n\n        assert_eq!(self.table.size(), old_size);\n        Ok(())\n    }\n\n    /// Shrinks the capacity of the map as much as possible. It will drop\n    /// down as much as possible while maintaining the internal rules\n    /// and possibly leaving some space in accordance with the resize policy.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<i32, i32> = HashMap::with_capacity(100);\n    /// map.insert(1, 2);\n    /// map.insert(3, 4);\n    /// assert!(map.capacity() >= 100);\n    /// map.shrink_to_fit();\n    /// assert!(map.capacity() >= 2);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn shrink_to_fit(&mut self) {\n        let new_raw_cap = self.resize_policy.raw_capacity(self.len());\n        if self.raw_capacity() != new_raw_cap {\n            let old_table = replace(&mut self.table, RawTable::new(new_raw_cap));\n            let old_size = old_table.size();\n\n            // Shrink the table. Naive algorithm for resizing:\n            for (h, k, v) in old_table.into_iter() {\n                self.insert_hashed_nocheck(h, k, v);\n            }\n\n            debug_assert_eq!(self.table.size(), old_size);\n        }\n    }\n\n    /// Shrinks the capacity of the map with a lower limit. It will drop\n    /// down no lower than the supplied limit while maintaining the internal rules\n    /// and possibly leaving some space in accordance with the resize policy.\n    ///\n    /// Panics if the current capacity is smaller than the supplied\n    /// minimum capacity.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(shrink_to)]\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<i32, i32> = HashMap::with_capacity(100);\n    /// map.insert(1, 2);\n    /// map.insert(3, 4);\n    /// assert!(map.capacity() >= 100);\n    /// map.shrink_to(10);\n    /// assert!(map.capacity() >= 10);\n    /// map.shrink_to(0);\n    /// assert!(map.capacity() >= 2);\n    /// ```\n    #[unstable(feature = \"shrink_to\", reason = \"new API\", issue=\"0\")]\n    pub fn shrink_to(&mut self, min_capacity: usize) {\n        assert!(self.capacity() >= min_capacity, \"Tried to shrink to a larger capacity\");\n\n        let new_raw_cap = self.resize_policy.raw_capacity(max(self.len(), min_capacity));\n        if self.raw_capacity() != new_raw_cap {\n            let old_table = replace(&mut self.table, RawTable::new(new_raw_cap));\n            let old_size = old_table.size();\n\n            // Shrink the table. Naive algorithm for resizing:\n            for (h, k, v) in old_table.into_iter() {\n                self.insert_hashed_nocheck(h, k, v);\n            }\n\n            debug_assert_eq!(self.table.size(), old_size);\n        }\n    }\n\n    /// Insert a pre-hashed key-value pair, without first checking\n    /// that there's enough room in the buckets. Returns a reference to the\n    /// newly insert value.\n    ///\n    /// If the key already exists, the hashtable will be returned untouched\n    /// and a reference to the existing element will be returned.\n    fn insert_hashed_nocheck(&mut self, hash: SafeHash, k: K, v: V) -> Option<V> {\n        let entry = search_hashed(&mut self.table, hash, |key| *key == k).into_entry(k);\n        match entry {\n            Some(Occupied(mut elem)) => Some(elem.insert(v)),\n            Some(Vacant(elem)) => {\n                elem.insert(v);\n                None\n            }\n            None => unreachable!(),\n        }\n    }\n\n    /// An iterator visiting all keys in arbitrary order.\n    /// The iterator element type is `&'a K`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// for key in map.keys() {\n    ///     println!(\"{}\", key);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn keys(&self) -> Keys<K, V> {\n        Keys { inner: self.iter() }\n    }\n\n    /// An iterator visiting all values in arbitrary order.\n    /// The iterator element type is `&'a V`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// for val in map.values() {\n    ///     println!(\"{}\", val);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn values(&self) -> Values<K, V> {\n        Values { inner: self.iter() }\n    }\n\n    /// An iterator visiting all values mutably in arbitrary order.\n    /// The iterator element type is `&'a mut V`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    ///\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// for val in map.values_mut() {\n    ///     *val = *val + 10;\n    /// }\n    ///\n    /// for val in map.values() {\n    ///     println!(\"{}\", val);\n    /// }\n    /// ```\n    #[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\n    pub fn values_mut(&mut self) -> ValuesMut<K, V> {\n        ValuesMut { inner: self.iter_mut() }\n    }\n\n    /// An iterator visiting all key-value pairs in arbitrary order.\n    /// The iterator element type is `(&'a K, &'a V)`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// for (key, val) in map.iter() {\n    ///     println!(\"key: {} val: {}\", key, val);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter(&self) -> Iter<K, V> {\n        Iter { inner: self.table.iter() }\n    }\n\n    /// An iterator visiting all key-value pairs in arbitrary order,\n    /// with mutable references to the values.\n    /// The iterator element type is `(&'a K, &'a mut V)`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// // Update all values\n    /// for (_, val) in map.iter_mut() {\n    ///     *val *= 2;\n    /// }\n    ///\n    /// for (key, val) in &map {\n    ///     println!(\"key: {} val: {}\", key, val);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn iter_mut(&mut self) -> IterMut<K, V> {\n        IterMut { inner: self.table.iter_mut() }\n    }\n\n    /// Gets the given key's corresponding entry in the map for in-place manipulation.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut letters = HashMap::new();\n    ///\n    /// for ch in \"a short treatise on fungi\".chars() {\n    ///     let counter = letters.entry(ch).or_insert(0);\n    ///     *counter += 1;\n    /// }\n    ///\n    /// assert_eq!(letters[&'s'], 2);\n    /// assert_eq!(letters[&'t'], 3);\n    /// assert_eq!(letters[&'u'], 1);\n    /// assert_eq!(letters.get(&'y'), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn entry(&mut self, key: K) -> Entry<K, V> {\n        // Gotta resize now.\n        self.reserve(1);\n        let hash = self.make_hash(&key);\n        search_hashed(&mut self.table, hash, |q| q.eq(&key))\n            .into_entry(key).expect(\"unreachable\")\n    }\n\n    /// Returns the number of elements in the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut a = HashMap::new();\n    /// assert_eq!(a.len(), 0);\n    /// a.insert(1, \"a\");\n    /// assert_eq!(a.len(), 1);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn len(&self) -> usize {\n        self.table.size()\n    }\n\n    /// Returns true if the map contains no elements.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut a = HashMap::new();\n    /// assert!(a.is_empty());\n    /// a.insert(1, \"a\");\n    /// assert!(!a.is_empty());\n    /// ```\n    #[inline]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn is_empty(&self) -> bool {\n        self.len() == 0\n    }\n\n    /// Clears the map, returning all key-value pairs as an iterator. Keeps the\n    /// allocated memory for reuse.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut a = HashMap::new();\n    /// a.insert(1, \"a\");\n    /// a.insert(2, \"b\");\n    ///\n    /// for (k, v) in a.drain().take(1) {\n    ///     assert!(k == 1 || k == 2);\n    ///     assert!(v == \"a\" || v == \"b\");\n    /// }\n    ///\n    /// assert!(a.is_empty());\n    /// ```\n    #[inline]\n    #[stable(feature = \"drain\", since = \"1.6.0\")]\n    pub fn drain(&mut self) -> Drain<K, V> {\n        Drain { inner: self.table.drain() }\n    }\n\n    /// Clears the map, removing all key-value pairs. Keeps the allocated memory\n    /// for reuse.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut a = HashMap::new();\n    /// a.insert(1, \"a\");\n    /// a.clear();\n    /// assert!(a.is_empty());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn clear(&mut self) {\n        self.drain();\n    }\n\n    /// Returns a reference to the value corresponding to the key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.get(&1), Some(&\"a\"));\n    /// assert_eq!(map.get(&2), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search(k).map(|bucket| bucket.into_refs().1)\n    }\n\n    /// Returns the key-value pair corresponding to the supplied key.\n    ///\n    /// The supplied key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(map_get_key_value)]\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.get_key_value(&1), Some((&1, &\"a\")));\n    /// assert_eq!(map.get_key_value(&2), None);\n    /// ```\n    #[unstable(feature = \"map_get_key_value\", issue = \"49347\")]\n    pub fn get_key_value<Q: ?Sized>(&self, k: &Q) -> Option<(&K, &V)>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search(k).map(|bucket| bucket.into_refs())\n    }\n\n    /// Returns true if the map contains a value for the specified key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.contains_key(&1), true);\n    /// assert_eq!(map.contains_key(&2), false);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search(k).is_some()\n    }\n\n    /// Returns a mutable reference to the value corresponding to the key.\n    ///\n    /// The key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// if let Some(x) = map.get_mut(&1) {\n    ///     *x = \"b\";\n    /// }\n    /// assert_eq!(map[&1], \"b\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search_mut(k).map(|bucket| bucket.into_mut_refs().1)\n    }\n\n    /// Inserts a key-value pair into the map.\n    ///\n    /// If the map did not have this key present, [`None`] is returned.\n    ///\n    /// If the map did have this key present, the value is updated, and the old\n    /// value is returned. The key is not updated, though; this matters for\n    /// types that can be `==` without being identical. See the [module-level\n    /// documentation] for more.\n    ///\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    /// [module-level documentation]: index.html#insert-and-complex-keys\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// assert_eq!(map.insert(37, \"a\"), None);\n    /// assert_eq!(map.is_empty(), false);\n    ///\n    /// map.insert(37, \"b\");\n    /// assert_eq!(map.insert(37, \"c\"), Some(\"b\"));\n    /// assert_eq!(map[&37], \"c\");\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, k: K, v: V) -> Option<V> {\n        let hash = self.make_hash(&k);\n        self.reserve(1);\n        self.insert_hashed_nocheck(hash, k, v)\n    }\n\n    /// Removes a key from the map, returning the value at the key if the key\n    /// was previously in the map.\n    ///\n    /// The key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.remove(&1), Some(\"a\"));\n    /// assert_eq!(map.remove(&1), None);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search_mut(k).map(|bucket| pop_internal(bucket).1)\n    }\n\n    /// Removes a key from the map, returning the stored key and value if the\n    /// key was previously in the map.\n    ///\n    /// The key may be any borrowed form of the map's key type, but\n    /// [`Hash`] and [`Eq`] on the borrowed form *must* match those for\n    /// the key type.\n    ///\n    /// [`Eq`]: ../../std/cmp/trait.Eq.html\n    /// [`Hash`]: ../../std/hash/trait.Hash.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// # fn main() {\n    /// let mut map = HashMap::new();\n    /// map.insert(1, \"a\");\n    /// assert_eq!(map.remove_entry(&1), Some((1, \"a\")));\n    /// assert_eq!(map.remove(&1), None);\n    /// # }\n    /// ```\n    #[stable(feature = \"hash_map_remove_entry\", since = \"1.27.0\")]\n    pub fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        self.search_mut(k)\n            .map(|bucket| {\n                let (k, v, _) = pop_internal(bucket);\n                (k, v)\n            })\n    }\n\n    /// Retains only the elements specified by the predicate.\n    ///\n    /// In other words, remove all pairs `(k, v)` such that `f(&k,&mut v)` returns `false`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<i32, i32> = (0..8).map(|x|(x, x*10)).collect();\n    /// map.retain(|&k, _| k % 2 == 0);\n    /// assert_eq!(map.len(), 4);\n    /// ```\n    #[stable(feature = \"retain_hash_collection\", since = \"1.18.0\")]\n    pub fn retain<F>(&mut self, mut f: F)\n        where F: FnMut(&K, &mut V) -> bool\n    {\n        if self.table.size() == 0 {\n            return;\n        }\n        let mut elems_left = self.table.size();\n        let mut bucket = Bucket::head_bucket(&mut self.table);\n        bucket.prev();\n        let start_index = bucket.index();\n        while elems_left != 0 {\n            bucket = match bucket.peek() {\n                Full(mut full) => {\n                    elems_left -= 1;\n                    let should_remove = {\n                        let (k, v) = full.read_mut();\n                        !f(k, v)\n                    };\n                    if should_remove {\n                        let prev_raw = full.raw();\n                        let (_, _, t) = pop_internal(full);\n                        Bucket::new_from(prev_raw, t)\n                    } else {\n                        full.into_bucket()\n                    }\n                },\n                Empty(b) => {\n                    b.into_bucket()\n                }\n            };\n            bucket.prev();  // reverse iteration\n            debug_assert!(elems_left == 0 || bucket.index() != start_index);\n        }\n    }\n}\n\nimpl<K, V, S> HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    /// Creates a raw entry builder for the HashMap.\n    ///\n    /// Raw entries provide the lowest level of control for searching and\n    /// manipulating a map. They must be manually initialized with a hash and\n    /// then manually searched. After this, insertions into a vacant entry\n    /// still require an owned key to be provided.\n    ///\n    /// Raw entries are useful for such exotic situations as:\n    ///\n    /// * Hash memoization\n    /// * Deferring the creation of an owned key until it is known to be required\n    /// * Using a search key that doesn't work with the Borrow trait\n    /// * Using custom comparison logic without newtype wrappers\n    ///\n    /// Because raw entries provide much more low-level control, it's much easier\n    /// to put the HashMap into an inconsistent state which, while memory-safe,\n    /// will cause the map to produce seemingly random results. Higher-level and\n    /// more foolproof APIs like `entry` should be preferred when possible.\n    ///\n    /// In particular, the hash used to initialized the raw entry must still be\n    /// consistent with the hash of the key that is ultimately stored in the entry.\n    /// This is because implementations of HashMap may need to recompute hashes\n    /// when resizing, at which point only the keys are available.\n    ///\n    /// Raw entries give mutable access to the keys. This must not be used\n    /// to modify how the key would compare or hash, as the map will not re-evaluate\n    /// where the key should go, meaning the keys may become \"lost\" if their\n    /// location does not reflect their state. For instance, if you change a key\n    /// so that the map now contains keys which compare equal, search may start\n    /// acting eratically, with two keys randomly masking eachother. Implementations\n    /// are free to assume this doesn't happen (within the limits of memory-safety).\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn raw_entry_mut(&mut self) -> RawEntryBuilderMut<K, V, S> {\n        self.reserve(1);\n        RawEntryBuilderMut { map: self }\n    }\n\n    /// Creates a raw immutable entry builder for the HashMap.\n    ///\n    /// Raw entries provide the lowest level of control for searching and\n    /// manipulating a map. They must be manually initialized with a hash and\n    /// then manually searched.\n    ///\n    /// This is useful for\n    /// * Hash memoization\n    /// * Using a search key that doesn't work with the Borrow trait\n    /// * Using custom comparison logic without newtype wrappers\n    ///\n    /// Unless you are in such a situation, higher-level and more foolproof APIs like\n    /// `get` should be preferred.\n    ///\n    /// Immutable raw entries have very limited use; you might instead want `raw_entry_mut`.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn raw_entry(&self) -> RawEntryBuilder<K, V, S> {\n        RawEntryBuilder { map: self }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> PartialEq for HashMap<K, V, S>\n    where K: Eq + Hash,\n          V: PartialEq,\n          S: BuildHasher\n{\n    fn eq(&self, other: &HashMap<K, V, S>) -> bool {\n        if self.len() != other.len() {\n            return false;\n        }\n\n        self.iter().all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> Eq for HashMap<K, V, S>\n    where K: Eq + Hash,\n          V: Eq,\n          S: BuildHasher\n{\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> Debug for HashMap<K, V, S>\n    where K: Eq + Hash + Debug,\n          V: Debug,\n          S: BuildHasher\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_map().entries(self.iter()).finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> Default for HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher + Default\n{\n    /// Creates an empty `HashMap<K, V, S>`, with the `Default` value for the hasher.\n    fn default() -> HashMap<K, V, S> {\n        HashMap::with_hasher(Default::default())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, Q: ?Sized, V, S> Index<&'a Q> for HashMap<K, V, S>\n    where K: Eq + Hash + Borrow<Q>,\n          Q: Eq + Hash,\n          S: BuildHasher\n{\n    type Output = V;\n\n    /// Returns a reference to the value corresponding to the supplied key.\n    ///\n    /// # Panics\n    ///\n    /// Panics if the key is not present in the `HashMap`.\n    #[inline]\n    fn index(&self, key: &Q) -> &V {\n        self.get(key).expect(\"no entry found for key\")\n    }\n}\n\n/// An iterator over the entries of a `HashMap`.\n///\n/// This `struct` is created by the [`iter`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`iter`]: struct.HashMap.html#method.iter\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Iter<'a, K: 'a, V: 'a> {\n    inner: table::Iter<'a, K, V>,\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Iter<'a, K, V> {\n    fn clone(&self) -> Iter<'a, K, V> {\n        Iter { inner: self.inner.clone() }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K: Debug, V: Debug> fmt::Debug for Iter<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.clone())\n            .finish()\n    }\n}\n\n/// A mutable iterator over the entries of a `HashMap`.\n///\n/// This `struct` is created by the [`iter_mut`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`iter_mut`]: struct.HashMap.html#method.iter_mut\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IterMut<'a, K: 'a, V: 'a> {\n    inner: table::IterMut<'a, K, V>,\n}\n\n/// An owning iterator over the entries of a `HashMap`.\n///\n/// This `struct` is created by the [`into_iter`] method on [`HashMap`][`HashMap`]\n/// (provided by the `IntoIterator` trait). See its documentation for more.\n///\n/// [`into_iter`]: struct.HashMap.html#method.into_iter\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct IntoIter<K, V> {\n    pub(super) inner: table::IntoIter<K, V>,\n}\n\n/// An iterator over the keys of a `HashMap`.\n///\n/// This `struct` is created by the [`keys`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`keys`]: struct.HashMap.html#method.keys\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Keys<'a, K: 'a, V: 'a> {\n    inner: Iter<'a, K, V>,\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Keys<'a, K, V> {\n    fn clone(&self) -> Keys<'a, K, V> {\n        Keys { inner: self.inner.clone() }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K: Debug, V> fmt::Debug for Keys<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.clone())\n            .finish()\n    }\n}\n\n/// An iterator over the values of a `HashMap`.\n///\n/// This `struct` is created by the [`values`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`values`]: struct.HashMap.html#method.values\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Values<'a, K: 'a, V: 'a> {\n    inner: Iter<'a, K, V>,\n}\n\n// FIXME(#26925) Remove in favor of `#[derive(Clone)]`\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Clone for Values<'a, K, V> {\n    fn clone(&self) -> Values<'a, K, V> {\n        Values { inner: self.inner.clone() }\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K, V: Debug> fmt::Debug for Values<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.clone())\n            .finish()\n    }\n}\n\n/// A draining iterator over the entries of a `HashMap`.\n///\n/// This `struct` is created by the [`drain`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`drain`]: struct.HashMap.html#method.drain\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"drain\", since = \"1.6.0\")]\npub struct Drain<'a, K: 'a, V: 'a> {\n    pub(super) inner: table::Drain<'a, K, V>,\n}\n\n/// A mutable iterator over the values of a `HashMap`.\n///\n/// This `struct` is created by the [`values_mut`] method on [`HashMap`]. See its\n/// documentation for more.\n///\n/// [`values_mut`]: struct.HashMap.html#method.values_mut\n/// [`HashMap`]: struct.HashMap.html\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\npub struct ValuesMut<'a, K: 'a, V: 'a> {\n    inner: IterMut<'a, K, V>,\n}\n\nenum InternalEntry<K, V, M> {\n    Occupied { elem: FullBucket<K, V, M> },\n    Vacant {\n        hash: SafeHash,\n        elem: VacantEntryState<K, V, M>,\n    },\n    TableIsEmpty,\n}\n\nimpl<K, V, M> InternalEntry<K, V, M> {\n    #[inline]\n    fn into_occupied_bucket(self) -> Option<FullBucket<K, V, M>> {\n        match self {\n            InternalEntry::Occupied { elem } => Some(elem),\n            _ => None,\n        }\n    }\n}\n\nimpl<'a, K, V> InternalEntry<K, V, &'a mut RawTable<K, V>> {\n    #[inline]\n    fn into_entry(self, key: K) -> Option<Entry<'a, K, V>> {\n        match self {\n            InternalEntry::Occupied { elem } => {\n                Some(Occupied(OccupiedEntry {\n                    key: Some(key),\n                    elem,\n                }))\n            }\n            InternalEntry::Vacant { hash, elem } => {\n                Some(Vacant(VacantEntry {\n                    hash,\n                    key,\n                    elem,\n                }))\n            }\n            InternalEntry::TableIsEmpty => None,\n        }\n    }\n}\n\n/// A builder for computing where in a HashMap a key-value pair would be stored.\n///\n/// See the [`HashMap::raw_entry_mut`] docs for usage examples.\n///\n/// [`HashMap::raw_entry_mut`]: struct.HashMap.html#method.raw_entry_mut\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\npub struct RawEntryBuilderMut<'a, K: 'a, V: 'a, S: 'a> {\n    map: &'a mut HashMap<K, V, S>,\n}\n\n/// A view into a single entry in a map, which may either be vacant or occupied.\n///\n/// This is a lower-level version of [`Entry`].\n///\n/// This `enum` is constructed from the [`raw_entry`] method on [`HashMap`].\n///\n/// [`HashMap`]: struct.HashMap.html\n/// [`Entry`]: enum.Entry.html\n/// [`raw_entry`]: struct.HashMap.html#method.raw_entry\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\npub enum RawEntryMut<'a, K: 'a, V: 'a, S: 'a> {\n    /// An occupied entry.\n    Occupied(RawOccupiedEntryMut<'a, K, V>),\n    /// A vacant entry.\n    Vacant(RawVacantEntryMut<'a, K, V, S>),\n}\n\n/// A view into an occupied entry in a `HashMap`.\n/// It is part of the [`RawEntryMut`] enum.\n///\n/// [`RawEntryMut`]: enum.RawEntryMut.html\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\npub struct RawOccupiedEntryMut<'a, K: 'a, V: 'a> {\n    elem: FullBucket<K, V, &'a mut RawTable<K, V>>,\n}\n\n/// A view into a vacant entry in a `HashMap`.\n/// It is part of the [`RawEntryMut`] enum.\n///\n/// [`RawEntryMut`]: enum.RawEntryMut.html\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\npub struct RawVacantEntryMut<'a, K: 'a, V: 'a, S: 'a> {\n    elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>,\n    hash_builder: &'a S,\n}\n\n/// A builder for computing where in a HashMap a key-value pair would be stored.\n///\n/// See the [`HashMap::raw_entry`] docs for usage examples.\n///\n/// [`HashMap::raw_entry`]: struct.HashMap.html#method.raw_entry\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\npub struct RawEntryBuilder<'a, K: 'a, V: 'a, S: 'a> {\n    map: &'a HashMap<K, V, S>,\n}\n\nimpl<'a, K, V, S> RawEntryBuilderMut<'a, K, V, S>\n    where S: BuildHasher,\n          K: Eq + Hash,\n{\n    /// Create a `RawEntryMut` from the given key.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_key<Q: ?Sized>(self, k: &Q) -> RawEntryMut<'a, K, V, S>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        let mut hasher = self.map.hash_builder.build_hasher();\n        k.hash(&mut hasher);\n        self.from_key_hashed_nocheck(hasher.finish(), k)\n    }\n\n    /// Create a `RawEntryMut` from the given key and its hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> RawEntryMut<'a, K, V, S>\n        where K: Borrow<Q>,\n              Q: Eq\n    {\n        self.from_hash(hash, |q| q.borrow().eq(k))\n    }\n\n    fn search<F>(self, hash: u64, is_match: F, compare_hashes: bool)  -> RawEntryMut<'a, K, V, S>\n        where for<'b> F: FnMut(&'b K) -> bool,\n    {\n        match search_hashed_nonempty_mut(&mut self.map.table,\n                                         SafeHash::new(hash),\n                                         is_match,\n                                         compare_hashes) {\n            InternalEntry::Occupied { elem } => {\n                RawEntryMut::Occupied(RawOccupiedEntryMut { elem })\n            }\n            InternalEntry::Vacant { elem, .. } => {\n                RawEntryMut::Vacant(RawVacantEntryMut {\n                    elem,\n                    hash_builder: &self.map.hash_builder,\n                })\n            }\n            InternalEntry::TableIsEmpty => {\n                unreachable!()\n            }\n        }\n    }\n    /// Create a `RawEntryMut` from the given hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_hash<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S>\n        where for<'b> F: FnMut(&'b K) -> bool,\n    {\n        self.search(hash, is_match, true)\n    }\n\n    /// Search possible locations for an element with hash `hash` until `is_match` returns true for\n    /// one of them. There is no guarantee that all keys passed to `is_match` will have the provided\n    /// hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn search_bucket<F>(self, hash: u64, is_match: F) -> RawEntryMut<'a, K, V, S>\n        where for<'b> F: FnMut(&'b K) -> bool,\n    {\n        self.search(hash, is_match, false)\n    }\n}\n\nimpl<'a, K, V, S> RawEntryBuilder<'a, K, V, S>\n    where S: BuildHasher,\n{\n    /// Access an entry by key.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_key<Q: ?Sized>(self, k: &Q) -> Option<(&'a K, &'a V)>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n    {\n        let mut hasher = self.map.hash_builder.build_hasher();\n        k.hash(&mut hasher);\n        self.from_key_hashed_nocheck(hasher.finish(), k)\n    }\n\n    /// Access an entry by a key and its hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_key_hashed_nocheck<Q: ?Sized>(self, hash: u64, k: &Q) -> Option<(&'a K, &'a V)>\n        where K: Borrow<Q>,\n              Q: Hash + Eq\n\n    {\n        self.from_hash(hash, |q| q.borrow().eq(k))\n    }\n\n    fn search<F>(self, hash: u64, is_match: F, compare_hashes: bool) -> Option<(&'a K, &'a V)>\n        where F: FnMut(&K) -> bool\n    {\n        match search_hashed_nonempty(&self.map.table,\n                                     SafeHash::new(hash),\n                                     is_match,\n                                     compare_hashes) {\n            InternalEntry::Occupied { elem } => Some(elem.into_refs()),\n            InternalEntry::Vacant { .. } => None,\n            InternalEntry::TableIsEmpty => unreachable!(),\n        }\n    }\n\n    /// Access an entry by hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn from_hash<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)>\n        where F: FnMut(&K) -> bool\n    {\n        self.search(hash, is_match, true)\n    }\n\n    /// Search possible locations for an element with hash `hash` until `is_match` returns true for\n    /// one of them. There is no guarantee that all keys passed to `is_match` will have the provided\n    /// hash.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn search_bucket<F>(self, hash: u64, is_match: F) -> Option<(&'a K, &'a V)>\n        where F: FnMut(&K) -> bool\n    {\n        self.search(hash, is_match, false)\n    }\n}\n\nimpl<'a, K, V, S> RawEntryMut<'a, K, V, S> {\n    /// Ensures a value is in the entry by inserting the default if empty, and returns\n    /// mutable references to the key and value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(hash_raw_entry)]\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.raw_entry_mut().from_key(\"poneyland\").or_insert(\"poneyland\", 12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    ///\n    /// *map.raw_entry_mut().from_key(\"poneyland\").or_insert(\"poneyland\", 12).1 += 10;\n    /// assert_eq!(map[\"poneyland\"], 22);\n    /// ```\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn or_insert(self, default_key: K, default_val: V) -> (&'a mut K, &'a mut V)\n        where K: Hash,\n              S: BuildHasher,\n    {\n        match self {\n            RawEntryMut::Occupied(entry) => entry.into_key_value(),\n            RawEntryMut::Vacant(entry) => entry.insert(default_key, default_val),\n        }\n    }\n\n    /// Ensures a value is in the entry by inserting the result of the default function if empty,\n    /// and returns mutable references to the key and value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(hash_raw_entry)]\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, String> = HashMap::new();\n    ///\n    /// map.raw_entry_mut().from_key(\"poneyland\").or_insert_with(|| {\n    ///     (\"poneyland\", \"hoho\".to_string())\n    /// });\n    ///\n    /// assert_eq!(map[\"poneyland\"], \"hoho\".to_string());\n    /// ```\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn or_insert_with<F>(self, default: F) -> (&'a mut K, &'a mut V)\n        where F: FnOnce() -> (K, V),\n              K: Hash,\n              S: BuildHasher,\n    {\n        match self {\n            RawEntryMut::Occupied(entry) => entry.into_key_value(),\n            RawEntryMut::Vacant(entry) => {\n                let (k, v) = default();\n                entry.insert(k, v)\n            }\n        }\n    }\n\n    /// Provides in-place mutable access to an occupied entry before any\n    /// potential inserts into the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(hash_raw_entry)]\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    ///\n    /// map.raw_entry_mut()\n    ///    .from_key(\"poneyland\")\n    ///    .and_modify(|_k, v| { *v += 1 })\n    ///    .or_insert(\"poneyland\", 42);\n    /// assert_eq!(map[\"poneyland\"], 42);\n    ///\n    /// map.raw_entry_mut()\n    ///    .from_key(\"poneyland\")\n    ///    .and_modify(|_k, v| { *v += 1 })\n    ///    .or_insert(\"poneyland\", 0);\n    /// assert_eq!(map[\"poneyland\"], 43);\n    /// ```\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn and_modify<F>(self, f: F) -> Self\n        where F: FnOnce(&mut K, &mut V)\n    {\n        match self {\n            RawEntryMut::Occupied(mut entry) => {\n                {\n                    let (k, v) = entry.get_key_value_mut();\n                    f(k, v);\n                }\n                RawEntryMut::Occupied(entry)\n            },\n            RawEntryMut::Vacant(entry) => RawEntryMut::Vacant(entry),\n        }\n    }\n}\n\nimpl<'a, K, V> RawOccupiedEntryMut<'a, K, V> {\n    /// Gets a reference to the key in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn key(&self) -> &K {\n        self.elem.read().0\n    }\n\n    /// Gets a mutable reference to the key in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn key_mut(&mut self) -> &mut K {\n        self.elem.read_mut().0\n    }\n\n    /// Converts the entry into a mutable reference to the key in the entry\n    /// with a lifetime bound to the map itself.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn into_key(self) -> &'a mut K {\n        self.elem.into_mut_refs().0\n    }\n\n    /// Gets a reference to the value in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn get(&self) -> &V {\n        self.elem.read().1\n    }\n\n    /// Converts the OccupiedEntry into a mutable reference to the value in the entry\n    /// with a lifetime bound to the map itself.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn into_mut(self) -> &'a mut V {\n        self.elem.into_mut_refs().1\n    }\n\n    /// Gets a mutable reference to the value in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn get_mut(&mut self) -> &mut V {\n        self.elem.read_mut().1\n    }\n\n    /// Gets a reference to the key and value in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn get_key_value(&mut self) -> (&K, &V) {\n        self.elem.read()\n    }\n\n    /// Gets a mutable reference to the key and value in the entry.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn get_key_value_mut(&mut self) -> (&mut K, &mut V) {\n        self.elem.read_mut()\n    }\n\n    /// Converts the OccupiedEntry into a mutable reference to the key and value in the entry\n    /// with a lifetime bound to the map itself.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn into_key_value(self) -> (&'a mut K, &'a mut V) {\n        self.elem.into_mut_refs()\n    }\n\n    /// Sets the value of the entry, and returns the entry's old value.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn insert(&mut self, value: V) -> V {\n        mem::replace(self.get_mut(), value)\n    }\n\n    /// Sets the value of the entry, and returns the entry's old value.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn insert_key(&mut self, key: K) -> K {\n        mem::replace(self.key_mut(), key)\n    }\n\n    /// Takes the value out of the entry, and returns it.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn remove(self) -> V {\n        pop_internal(self.elem).1\n    }\n\n    /// Take the ownership of the key and value from the map.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn remove_entry(self) -> (K, V) {\n        let (k, v, _) = pop_internal(self.elem);\n        (k, v)\n    }\n}\n\nimpl<'a, K, V, S> RawVacantEntryMut<'a, K, V, S> {\n    /// Sets the value of the entry with the VacantEntry's key,\n    /// and returns a mutable reference to it.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn insert(self, key: K, value: V) -> (&'a mut K, &'a mut V)\n        where K: Hash,\n              S: BuildHasher,\n    {\n        let mut hasher = self.hash_builder.build_hasher();\n        key.hash(&mut hasher);\n        self.insert_hashed_nocheck(hasher.finish(), key, value)\n    }\n\n    /// Sets the value of the entry with the VacantEntry's key,\n    /// and returns a mutable reference to it.\n    #[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\n    pub fn insert_hashed_nocheck(self, hash: u64, key: K, value: V) -> (&'a mut K, &'a mut V) {\n        let hash = SafeHash::new(hash);\n        let b = match self.elem {\n            NeqElem(mut bucket, disp) => {\n                if disp >= DISPLACEMENT_THRESHOLD {\n                    bucket.table_mut().set_tag(true);\n                }\n                robin_hood(bucket, disp, hash, key, value)\n            },\n            NoElem(mut bucket, disp) => {\n                if disp >= DISPLACEMENT_THRESHOLD {\n                    bucket.table_mut().set_tag(true);\n                }\n                bucket.put(hash, key, value)\n            },\n        };\n        b.into_mut_refs()\n    }\n}\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\nimpl<'a, K, V, S> Debug for RawEntryBuilderMut<'a, K, V, S> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RawEntryBuilder\")\n         .finish()\n    }\n}\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\nimpl<'a, K: Debug, V: Debug, S> Debug for RawEntryMut<'a, K, V, S> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            RawEntryMut::Vacant(ref v) => {\n                f.debug_tuple(\"RawEntry\")\n                    .field(v)\n                    .finish()\n            }\n            RawEntryMut::Occupied(ref o) => {\n                f.debug_tuple(\"RawEntry\")\n                    .field(o)\n                    .finish()\n            }\n        }\n    }\n}\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\nimpl<'a, K: Debug, V: Debug> Debug for RawOccupiedEntryMut<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RawOccupiedEntryMut\")\n         .field(\"key\", self.key())\n         .field(\"value\", self.get())\n         .finish()\n    }\n}\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\nimpl<'a, K, V, S> Debug for RawVacantEntryMut<'a, K, V, S> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RawVacantEntryMut\")\n         .finish()\n    }\n}\n\n#[unstable(feature = \"hash_raw_entry\", issue = \"54043\")]\nimpl<'a, K, V, S> Debug for RawEntryBuilder<'a, K, V, S> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"RawEntryBuilder\")\n         .finish()\n    }\n}\n\n/// A view into a single entry in a map, which may either be vacant or occupied.\n///\n/// This `enum` is constructed from the [`entry`] method on [`HashMap`].\n///\n/// [`HashMap`]: struct.HashMap.html\n/// [`entry`]: struct.HashMap.html#method.entry\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Entry<'a, K: 'a, V: 'a> {\n    /// An occupied entry.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Occupied(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n             OccupiedEntry<'a, K, V>),\n\n    /// A vacant entry.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Vacant(#[stable(feature = \"rust1\", since = \"1.0.0\")]\n           VacantEntry<'a, K, V>),\n}\n\n#[stable(feature= \"debug_hash_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug, V: 'a + Debug> Debug for Entry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            Vacant(ref v) => {\n                f.debug_tuple(\"Entry\")\n                    .field(v)\n                    .finish()\n            }\n            Occupied(ref o) => {\n                f.debug_tuple(\"Entry\")\n                    .field(o)\n                    .finish()\n            }\n        }\n    }\n}\n\n/// A view into an occupied entry in a `HashMap`.\n/// It is part of the [`Entry`] enum.\n///\n/// [`Entry`]: enum.Entry.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct OccupiedEntry<'a, K: 'a, V: 'a> {\n    key: Option<K>,\n    elem: FullBucket<K, V, &'a mut RawTable<K, V>>,\n}\n\n#[stable(feature= \"debug_hash_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"OccupiedEntry\")\n            .field(\"key\", self.key())\n            .field(\"value\", self.get())\n            .finish()\n    }\n}\n\n/// A view into a vacant entry in a `HashMap`.\n/// It is part of the [`Entry`] enum.\n///\n/// [`Entry`]: enum.Entry.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct VacantEntry<'a, K: 'a, V: 'a> {\n    hash: SafeHash,\n    key: K,\n    elem: VacantEntryState<K, V, &'a mut RawTable<K, V>>,\n}\n\n#[stable(feature= \"debug_hash_map\", since = \"1.12.0\")]\nimpl<'a, K: 'a + Debug, V: 'a> Debug for VacantEntry<'a, K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"VacantEntry\")\n            .field(self.key())\n            .finish()\n    }\n}\n\n/// Possible states of a VacantEntry.\nenum VacantEntryState<K, V, M> {\n    /// The index is occupied, but the key to insert has precedence,\n    /// and will kick the current one out on insertion.\n    NeqElem(FullBucket<K, V, M>, usize),\n    /// The index is genuinely vacant.\n    NoElem(EmptyBucket<K, V, M>, usize),\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    type Item = (&'a K, &'a V);\n    type IntoIter = Iter<'a, K, V>;\n\n    fn into_iter(self) -> Iter<'a, K, V> {\n        self.iter()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    type Item = (&'a K, &'a mut V);\n    type IntoIter = IterMut<'a, K, V>;\n\n    fn into_iter(self) -> IterMut<'a, K, V> {\n        self.iter_mut()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> IntoIterator for HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    type Item = (K, V);\n    type IntoIter = IntoIter<K, V>;\n\n    /// Creates a consuming iterator, that is, one that moves each key-value\n    /// pair out of the map in arbitrary order. The map cannot be used after\n    /// calling this.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map = HashMap::new();\n    /// map.insert(\"a\", 1);\n    /// map.insert(\"b\", 2);\n    /// map.insert(\"c\", 3);\n    ///\n    /// // Not possible with .iter()\n    /// let vec: Vec<(&str, i32)> = map.into_iter().collect();\n    /// ```\n    fn into_iter(self) -> IntoIter<K, V> {\n        IntoIter { inner: self.table.into_iter() }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for Iter<'a, K, V> {\n    type Item = (&'a K, &'a V);\n\n    #[inline]\n    fn next(&mut self) -> Option<(&'a K, &'a V)> {\n        self.inner.next()\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Iter<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for IterMut<'a, K, V> {\n    type Item = (&'a K, &'a mut V);\n\n    #[inline]\n    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {\n        self.inner.next()\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for IterMut<'a, K, V> {}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K, V> fmt::Debug for IterMut<'a, K, V>\n    where K: fmt::Debug,\n          V: fmt::Debug,\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.inner.iter())\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> Iterator for IntoIter<K, V> {\n    type Item = (K, V);\n\n    #[inline]\n    fn next(&mut self) -> Option<(K, V)> {\n        self.inner.next().map(|(_, k, v)| (k, v))\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V> ExactSizeIterator for IntoIter<K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<K, V> FusedIterator for IntoIter<K, V> {}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<K: Debug, V: Debug> fmt::Debug for IntoIter<K, V> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.inner.iter())\n            .finish()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for Keys<'a, K, V> {\n    type Item = &'a K;\n\n    #[inline]\n    fn next(&mut self) -> Option<(&'a K)> {\n        self.inner.next().map(|(k, _)| k)\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Keys<'a, K, V> {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> Iterator for Values<'a, K, V> {\n    type Item = &'a V;\n\n    #[inline]\n    fn next(&mut self) -> Option<(&'a V)> {\n        self.inner.next().map(|(_, v)| v)\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Values<'a, K, V> {}\n\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\nimpl<'a, K, V> Iterator for ValuesMut<'a, K, V> {\n    type Item = &'a mut V;\n\n    #[inline]\n    fn next(&mut self) -> Option<(&'a mut V)> {\n        self.inner.next().map(|(_, v)| v)\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"map_values_mut\", since = \"1.10.0\")]\nimpl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for ValuesMut<'a, K, V> {}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K, V> fmt::Debug for ValuesMut<'a, K, V>\n    where K: fmt::Debug,\n          V: fmt::Debug,\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.inner.inner.iter())\n            .finish()\n    }\n}\n\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, K, V> Iterator for Drain<'a, K, V> {\n    type Item = (K, V);\n\n    #[inline]\n    fn next(&mut self) -> Option<(K, V)> {\n        self.inner.next().map(|(_, k, v)| (k, v))\n    }\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        self.inner.size_hint()\n    }\n}\n#[stable(feature = \"drain\", since = \"1.6.0\")]\nimpl<'a, K, V> ExactSizeIterator for Drain<'a, K, V> {\n    #[inline]\n    fn len(&self) -> usize {\n        self.inner.len()\n    }\n}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl<'a, K, V> FusedIterator for Drain<'a, K, V> {}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a, K, V> fmt::Debug for Drain<'a, K, V>\n    where K: fmt::Debug,\n          V: fmt::Debug,\n{\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_list()\n            .entries(self.inner.iter())\n            .finish()\n    }\n}\n\nimpl<'a, K, V> Entry<'a, K, V> {\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    /// Ensures a value is in the entry by inserting the default if empty, and returns\n    /// a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    ///\n    /// *map.entry(\"poneyland\").or_insert(12) += 10;\n    /// assert_eq!(map[\"poneyland\"], 22);\n    /// ```\n    pub fn or_insert(self, default: V) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(default),\n        }\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    /// Ensures a value is in the entry by inserting the result of the default function if empty,\n    /// and returns a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, String> = HashMap::new();\n    /// let s = \"hoho\".to_string();\n    ///\n    /// map.entry(\"poneyland\").or_insert_with(|| s);\n    ///\n    /// assert_eq!(map[\"poneyland\"], \"hoho\".to_string());\n    /// ```\n    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(default()),\n        }\n    }\n\n    /// Returns a reference to this entry's key.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        match *self {\n            Occupied(ref entry) => entry.key(),\n            Vacant(ref entry) => entry.key(),\n        }\n    }\n\n    /// Provides in-place mutable access to an occupied entry before any\n    /// potential inserts into the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    ///\n    /// map.entry(\"poneyland\")\n    ///    .and_modify(|e| { *e += 1 })\n    ///    .or_insert(42);\n    /// assert_eq!(map[\"poneyland\"], 42);\n    ///\n    /// map.entry(\"poneyland\")\n    ///    .and_modify(|e| { *e += 1 })\n    ///    .or_insert(42);\n    /// assert_eq!(map[\"poneyland\"], 43);\n    /// ```\n    #[stable(feature = \"entry_and_modify\", since = \"1.26.0\")]\n    pub fn and_modify<F>(self, f: F) -> Self\n        where F: FnOnce(&mut V)\n    {\n        match self {\n            Occupied(mut entry) => {\n                f(entry.get_mut());\n                Occupied(entry)\n            },\n            Vacant(entry) => Vacant(entry),\n        }\n    }\n\n}\n\nimpl<'a, K, V: Default> Entry<'a, K, V> {\n    #[stable(feature = \"entry_or_default\", since = \"1.28.0\")]\n    /// Ensures a value is in the entry by inserting the default value if empty,\n    /// and returns a mutable reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// # fn main() {\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, Option<u32>> = HashMap::new();\n    /// map.entry(\"poneyland\").or_default();\n    ///\n    /// assert_eq!(map[\"poneyland\"], None);\n    /// # }\n    /// ```\n    pub fn or_default(self) -> &'a mut V {\n        match self {\n            Occupied(entry) => entry.into_mut(),\n            Vacant(entry) => entry.insert(Default::default()),\n        }\n    }\n}\n\nimpl<'a, K, V> OccupiedEntry<'a, K, V> {\n    /// Gets a reference to the key in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        self.elem.read().0\n    }\n\n    /// Take the ownership of the key and value from the map.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     // We delete the entry from the map.\n    ///     o.remove_entry();\n    /// }\n    ///\n    /// assert_eq!(map.contains_key(\"poneyland\"), false);\n    /// ```\n    #[stable(feature = \"map_entry_recover_keys2\", since = \"1.12.0\")]\n    pub fn remove_entry(self) -> (K, V) {\n        let (k, v, _) = pop_internal(self.elem);\n        (k, v)\n    }\n\n    /// Gets a reference to the value in the entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.get(), &12);\n    /// }\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get(&self) -> &V {\n        self.elem.read().1\n    }\n\n    /// Gets a mutable reference to the value in the entry.\n    ///\n    /// If you need a reference to the `OccupiedEntry` which may outlive the\n    /// destruction of the `Entry` value, see [`into_mut`].\n    ///\n    /// [`into_mut`]: #method.into_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    /// if let Entry::Occupied(mut o) = map.entry(\"poneyland\") {\n    ///     *o.get_mut() += 10;\n    ///     assert_eq!(*o.get(), 22);\n    ///\n    ///     // We can use the same Entry multiple times.\n    ///     *o.get_mut() += 2;\n    /// }\n    ///\n    /// assert_eq!(map[\"poneyland\"], 24);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn get_mut(&mut self) -> &mut V {\n        self.elem.read_mut().1\n    }\n\n    /// Converts the OccupiedEntry into a mutable reference to the value in the entry\n    /// with a lifetime bound to the map itself.\n    ///\n    /// If you need multiple references to the `OccupiedEntry`, see [`get_mut`].\n    ///\n    /// [`get_mut`]: #method.get_mut\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// assert_eq!(map[\"poneyland\"], 12);\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     *o.into_mut() += 10;\n    /// }\n    ///\n    /// assert_eq!(map[\"poneyland\"], 22);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn into_mut(self) -> &'a mut V {\n        self.elem.into_mut_refs().1\n    }\n\n    /// Sets the value of the entry, and returns the entry's old value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(mut o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.insert(15), 12);\n    /// }\n    ///\n    /// assert_eq!(map[\"poneyland\"], 15);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(&mut self, mut value: V) -> V {\n        let old_value = self.get_mut();\n        mem::swap(&mut value, old_value);\n        value\n    }\n\n    /// Takes the value out of the entry, and returns it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// map.entry(\"poneyland\").or_insert(12);\n    ///\n    /// if let Entry::Occupied(o) = map.entry(\"poneyland\") {\n    ///     assert_eq!(o.remove(), 12);\n    /// }\n    ///\n    /// assert_eq!(map.contains_key(\"poneyland\"), false);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn remove(self) -> V {\n        pop_internal(self.elem).1\n    }\n\n    /// Returns a key that was used for search.\n    ///\n    /// The key was retained for further use.\n    fn take_key(&mut self) -> Option<K> {\n        self.key.take()\n    }\n\n    /// Replaces the entry, returning the old key and value. The new key in the hash map will be\n    /// the key used to create this entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(map_entry_replace)]\n    /// use std::collections::hash_map::{Entry, HashMap};\n    /// use std::rc::Rc;\n    ///\n    /// let mut map: HashMap<Rc<String>, u32> = HashMap::new();\n    /// map.insert(Rc::new(\"Stringthing\".to_string()), 15);\n    ///\n    /// let my_key = Rc::new(\"Stringthing\".to_string());\n    ///\n    /// if let Entry::Occupied(entry) = map.entry(my_key) {\n    ///     // Also replace the key with a handle to our other key.\n    ///     let (old_key, old_value): (Rc<String>, u32) = entry.replace_entry(16);\n    /// }\n    ///\n    /// ```\n    #[unstable(feature = \"map_entry_replace\", issue = \"44286\")]\n    pub fn replace_entry(mut self, value: V) -> (K, V) {\n        let (old_key, old_value) = self.elem.read_mut();\n\n        let old_key = mem::replace(old_key, self.key.unwrap());\n        let old_value = mem::replace(old_value, value);\n\n        (old_key, old_value)\n    }\n\n    /// Replaces the key in the hash map with the key used to create this entry.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(map_entry_replace)]\n    /// use std::collections::hash_map::{Entry, HashMap};\n    /// use std::rc::Rc;\n    ///\n    /// let mut map: HashMap<Rc<String>, u32> = HashMap::new();\n    /// let mut known_strings: Vec<Rc<String>> = Vec::new();\n    ///\n    /// // Initialise known strings, run program, etc.\n    ///\n    /// reclaim_memory(&mut map, &known_strings);\n    ///\n    /// fn reclaim_memory(map: &mut HashMap<Rc<String>, u32>, known_strings: &[Rc<String>] ) {\n    ///     for s in known_strings {\n    ///         if let Entry::Occupied(entry) = map.entry(s.clone()) {\n    ///             // Replaces the entry's key with our version of it in `known_strings`.\n    ///             entry.replace_key();\n    ///         }\n    ///     }\n    /// }\n    /// ```\n    #[unstable(feature = \"map_entry_replace\", issue = \"44286\")]\n    pub fn replace_key(mut self) -> K {\n        let (old_key, _) = self.elem.read_mut();\n        mem::replace(old_key, self.key.unwrap())\n    }\n}\n\nimpl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {\n    /// Gets a reference to the key that would be used when inserting a value\n    /// through the `VacantEntry`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    /// assert_eq!(map.entry(\"poneyland\").key(), &\"poneyland\");\n    /// ```\n    #[stable(feature = \"map_entry_keys\", since = \"1.10.0\")]\n    pub fn key(&self) -> &K {\n        &self.key\n    }\n\n    /// Take ownership of the key.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    ///\n    /// if let Entry::Vacant(v) = map.entry(\"poneyland\") {\n    ///     v.into_key();\n    /// }\n    /// ```\n    #[stable(feature = \"map_entry_recover_keys2\", since = \"1.12.0\")]\n    pub fn into_key(self) -> K {\n        self.key\n    }\n\n    /// Sets the value of the entry with the VacantEntry's key,\n    /// and returns a mutable reference to it.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::HashMap;\n    /// use std::collections::hash_map::Entry;\n    ///\n    /// let mut map: HashMap<&str, u32> = HashMap::new();\n    ///\n    /// if let Entry::Vacant(o) = map.entry(\"poneyland\") {\n    ///     o.insert(37);\n    /// }\n    /// assert_eq!(map[\"poneyland\"], 37);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn insert(self, value: V) -> &'a mut V {\n        let b = match self.elem {\n            NeqElem(mut bucket, disp) => {\n                if disp >= DISPLACEMENT_THRESHOLD {\n                    bucket.table_mut().set_tag(true);\n                }\n                robin_hood(bucket, disp, self.hash, self.key, value)\n            },\n            NoElem(mut bucket, disp) => {\n                if disp >= DISPLACEMENT_THRESHOLD {\n                    bucket.table_mut().set_tag(true);\n                }\n                bucket.put(self.hash, self.key, value)\n            },\n        };\n        b.into_mut_refs().1\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher + Default\n{\n    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> HashMap<K, V, S> {\n        let mut map = HashMap::with_hasher(Default::default());\n        map.extend(iter);\n        map\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<K, V, S> Extend<(K, V)> for HashMap<K, V, S>\n    where K: Eq + Hash,\n          S: BuildHasher\n{\n    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {\n        // Keys may be already present or show multiple times in the iterator.\n        // Reserve the entire hint lower bound if the map is empty.\n        // Otherwise reserve half the hint (rounded up), so the map\n        // will only resize twice in the worst case.\n        let iter = iter.into_iter();\n        let reserve = if self.is_empty() {\n            iter.size_hint().0\n        } else {\n            (iter.size_hint().0 + 1) / 2\n        };\n        self.reserve(reserve);\n        for (k, v) in iter {\n            self.insert(k, v);\n        }\n    }\n}\n\n#[stable(feature = \"hash_extend_copy\", since = \"1.4.0\")]\nimpl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap<K, V, S>\n    where K: Eq + Hash + Copy,\n          V: Copy,\n          S: BuildHasher\n{\n    fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) {\n        self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));\n    }\n}\n\n/// `RandomState` is the default state for [`HashMap`] types.\n///\n/// A particular instance `RandomState` will create the same instances of\n/// [`Hasher`], but the hashers created by two different `RandomState`\n/// instances are unlikely to produce the same result for the same values.\n///\n/// [`HashMap`]: struct.HashMap.html\n/// [`Hasher`]: ../../hash/trait.Hasher.html\n///\n/// # Examples\n///\n/// ```\n/// use std::collections::HashMap;\n/// use std::collections::hash_map::RandomState;\n///\n/// let s = RandomState::new();\n/// let mut map = HashMap::with_hasher(s);\n/// map.insert(1, 2);\n/// ```\n#[derive(Clone)]\n#[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\npub struct RandomState {\n    k0: u64,\n    k1: u64,\n}\n\nimpl RandomState {\n    /// Constructs a new `RandomState` that is initialized with random keys.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::collections::hash_map::RandomState;\n    ///\n    /// let s = RandomState::new();\n    /// ```\n    #[inline]\n    #[allow(deprecated)]\n    // rand\n    #[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\n    pub fn new() -> RandomState {\n        // Historically this function did not cache keys from the OS and instead\n        // simply always called `rand::thread_rng().gen()` twice. In #31356 it\n        // was discovered, however, that because we re-seed the thread-local RNG\n        // from the OS periodically that this can cause excessive slowdown when\n        // many hash maps are created on a thread. To solve this performance\n        // trap we cache the first set of randomly generated keys per-thread.\n        //\n        // Later in #36481 it was discovered that exposing a deterministic\n        // iteration order allows a form of DOS attack. To counter that we\n        // increment one of the seeds on every RandomState creation, giving\n        // every corresponding HashMap a different iteration order.\n        thread_local!(static KEYS: Cell<(u64, u64)> = {\n            Cell::new(sys::hashmap_random_keys())\n        });\n\n        KEYS.with(|keys| {\n            let (k0, k1) = keys.get();\n            keys.set((k0.wrapping_add(1), k1));\n            RandomState { k0: k0, k1: k1 }\n        })\n    }\n}\n\n#[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\nimpl BuildHasher for RandomState {\n    type Hasher = DefaultHasher;\n    #[inline]\n    #[allow(deprecated)]\n    fn build_hasher(&self) -> DefaultHasher {\n        DefaultHasher(SipHasher13::new_with_keys(self.k0, self.k1))\n    }\n}\n\n/// The default [`Hasher`] used by [`RandomState`].\n///\n/// The internal algorithm is not specified, and so it and its hashes should\n/// not be relied upon over releases.\n///\n/// [`RandomState`]: struct.RandomState.html\n/// [`Hasher`]: ../../hash/trait.Hasher.html\n#[stable(feature = \"hashmap_default_hasher\", since = \"1.13.0\")]\n#[allow(deprecated)]\n#[derive(Clone, Debug)]\npub struct DefaultHasher(SipHasher13);\n\nimpl DefaultHasher {\n    /// Creates a new `DefaultHasher`.\n    ///\n    /// This hasher is not guaranteed to be the same as all other\n    /// `DefaultHasher` instances, but is the same as all other `DefaultHasher`\n    /// instances created through `new` or `default`.\n    #[stable(feature = \"hashmap_default_hasher\", since = \"1.13.0\")]\n    #[allow(deprecated)]\n    pub fn new() -> DefaultHasher {\n        DefaultHasher(SipHasher13::new_with_keys(0, 0))\n    }\n}\n\n#[stable(feature = \"hashmap_default_hasher\", since = \"1.13.0\")]\nimpl Default for DefaultHasher {\n    /// Creates a new `DefaultHasher` using [`new`][DefaultHasher::new].\n    /// See its documentation for more.\n    fn default() -> DefaultHasher {\n        DefaultHasher::new()\n    }\n}\n\n#[stable(feature = \"hashmap_default_hasher\", since = \"1.13.0\")]\nimpl Hasher for DefaultHasher {\n    #[inline]\n    fn write(&mut self, msg: &[u8]) {\n        self.0.write(msg)\n    }\n\n    #[inline]\n    fn finish(&self) -> u64 {\n        self.0.finish()\n    }\n}\n\n#[stable(feature = \"hashmap_build_hasher\", since = \"1.7.0\")]\nimpl Default for RandomState {\n    /// Constructs a new `RandomState`.\n    #[inline]\n    fn default() -> RandomState {\n        RandomState::new()\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for RandomState {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"RandomState { .. }\")\n    }\n}\n\nimpl<K, S, Q: ?Sized> super::Recover<Q> for HashMap<K, (), S>\n    where K: Eq + Hash + Borrow<Q>,\n          S: BuildHasher,\n          Q: Eq + Hash\n{\n    type Key = K;\n\n    #[inline]\n    fn get(&self, key: &Q) -> Option<&K> {\n        self.search(key).map(|bucket| bucket.into_refs().0)\n    }\n\n    fn take(&mut self, key: &Q) -> Option<K> {\n        self.search_mut(key).map(|bucket| pop_internal(bucket).0)\n    }\n\n    #[inline]\n    fn replace(&mut self, key: K) -> Option<K> {\n        self.reserve(1);\n\n        match self.entry(key) {\n            Occupied(mut occupied) => {\n                let key = occupied.take_key().unwrap();\n                Some(mem::replace(occupied.elem.read_mut().0, key))\n            }\n            Vacant(vacant) => {\n                vacant.insert(());\n                None\n            }\n        }\n    }\n}\n\n#[allow(dead_code)]\nfn assert_covariance() {\n    fn map_key<'new>(v: HashMap<&'static str, u8>) -> HashMap<&'new str, u8> {\n        v\n    }\n    fn map_val<'new>(v: HashMap<u8, &'static str>) -> HashMap<u8, &'new str> {\n        v\n    }\n    fn iter_key<'a, 'new>(v: Iter<'a, &'static str, u8>) -> Iter<'a, &'new str, u8> {\n        v\n    }\n    fn iter_val<'a, 'new>(v: Iter<'a, u8, &'static str>) -> Iter<'a, u8, &'new str> {\n        v\n    }\n    fn into_iter_key<'new>(v: IntoIter<&'static str, u8>) -> IntoIter<&'new str, u8> {\n        v\n    }\n    fn into_iter_val<'new>(v: IntoIter<u8, &'static str>) -> IntoIter<u8, &'new str> {\n        v\n    }\n    fn keys_key<'a, 'new>(v: Keys<'a, &'static str, u8>) -> Keys<'a, &'new str, u8> {\n        v\n    }\n    fn keys_val<'a, 'new>(v: Keys<'a, u8, &'static str>) -> Keys<'a, u8, &'new str> {\n        v\n    }\n    fn values_key<'a, 'new>(v: Values<'a, &'static str, u8>) -> Values<'a, &'new str, u8> {\n        v\n    }\n    fn values_val<'a, 'new>(v: Values<'a, u8, &'static str>) -> Values<'a, u8, &'new str> {\n        v\n    }\n    fn drain<'new>(d: Drain<'static, &'static str, &'static str>)\n                   -> Drain<'new, &'new str, &'new str> {\n        d\n    }\n}\n\n#[cfg(test)]\nmod test_map {\n    use super::HashMap;\n    use super::Entry::{Occupied, Vacant};\n    use super::RandomState;\n    use cell::RefCell;\n    use rand::{thread_rng, Rng};\n    use realstd::collections::CollectionAllocErr::*;\n    use realstd::mem::size_of;\n    use realstd::usize;\n\n    #[test]\n    fn test_zero_capacities() {\n        type HM = HashMap<i32, i32>;\n\n        let m = HM::new();\n        assert_eq!(m.capacity(), 0);\n\n        let m = HM::default();\n        assert_eq!(m.capacity(), 0);\n\n        let m = HM::with_hasher(RandomState::new());\n        assert_eq!(m.capacity(), 0);\n\n        let m = HM::with_capacity(0);\n        assert_eq!(m.capacity(), 0);\n\n        let m = HM::with_capacity_and_hasher(0, RandomState::new());\n        assert_eq!(m.capacity(), 0);\n\n        let mut m = HM::new();\n        m.insert(1, 1);\n        m.insert(2, 2);\n        m.remove(&1);\n        m.remove(&2);\n        m.shrink_to_fit();\n        assert_eq!(m.capacity(), 0);\n\n        let mut m = HM::new();\n        m.reserve(0);\n        assert_eq!(m.capacity(), 0);\n    }\n\n    #[test]\n    fn test_create_capacity_zero() {\n        let mut m = HashMap::with_capacity(0);\n\n        assert!(m.insert(1, 1).is_none());\n\n        assert!(m.contains_key(&1));\n        assert!(!m.contains_key(&0));\n    }\n\n    #[test]\n    fn test_insert() {\n        let mut m = HashMap::new();\n        assert_eq!(m.len(), 0);\n        assert!(m.insert(1, 2).is_none());\n        assert_eq!(m.len(), 1);\n        assert!(m.insert(2, 4).is_none());\n        assert_eq!(m.len(), 2);\n        assert_eq!(*m.get(&1).unwrap(), 2);\n        assert_eq!(*m.get(&2).unwrap(), 4);\n    }\n\n    #[test]\n    fn test_clone() {\n        let mut m = HashMap::new();\n        assert_eq!(m.len(), 0);\n        assert!(m.insert(1, 2).is_none());\n        assert_eq!(m.len(), 1);\n        assert!(m.insert(2, 4).is_none());\n        assert_eq!(m.len(), 2);\n        let m2 = m.clone();\n        assert_eq!(*m2.get(&1).unwrap(), 2);\n        assert_eq!(*m2.get(&2).unwrap(), 4);\n        assert_eq!(m2.len(), 2);\n    }\n\n    thread_local! { static DROP_VECTOR: RefCell<Vec<i32>> = RefCell::new(Vec::new()) }\n\n    #[derive(Hash, PartialEq, Eq)]\n    struct Droppable {\n        k: usize,\n    }\n\n    impl Droppable {\n        fn new(k: usize) -> Droppable {\n            DROP_VECTOR.with(|slot| {\n                slot.borrow_mut()[k] += 1;\n            });\n\n            Droppable { k }\n        }\n    }\n\n    impl Drop for Droppable {\n        fn drop(&mut self) {\n            DROP_VECTOR.with(|slot| {\n                slot.borrow_mut()[self.k] -= 1;\n            });\n        }\n    }\n\n    impl Clone for Droppable {\n        fn clone(&self) -> Droppable {\n            Droppable::new(self.k)\n        }\n    }\n\n    #[test]\n    fn test_drops() {\n        DROP_VECTOR.with(|slot| {\n            *slot.borrow_mut() = vec![0; 200];\n        });\n\n        {\n            let mut m = HashMap::new();\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..200 {\n                    assert_eq!(v.borrow()[i], 0);\n                }\n            });\n\n            for i in 0..100 {\n                let d1 = Droppable::new(i);\n                let d2 = Droppable::new(i + 100);\n                m.insert(d1, d2);\n            }\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..200 {\n                    assert_eq!(v.borrow()[i], 1);\n                }\n            });\n\n            for i in 0..50 {\n                let k = Droppable::new(i);\n                let v = m.remove(&k);\n\n                assert!(v.is_some());\n\n                DROP_VECTOR.with(|v| {\n                    assert_eq!(v.borrow()[i], 1);\n                    assert_eq!(v.borrow()[i+100], 1);\n                });\n            }\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..50 {\n                    assert_eq!(v.borrow()[i], 0);\n                    assert_eq!(v.borrow()[i+100], 0);\n                }\n\n                for i in 50..100 {\n                    assert_eq!(v.borrow()[i], 1);\n                    assert_eq!(v.borrow()[i+100], 1);\n                }\n            });\n        }\n\n        DROP_VECTOR.with(|v| {\n            for i in 0..200 {\n                assert_eq!(v.borrow()[i], 0);\n            }\n        });\n    }\n\n    #[test]\n    fn test_into_iter_drops() {\n        DROP_VECTOR.with(|v| {\n            *v.borrow_mut() = vec![0; 200];\n        });\n\n        let hm = {\n            let mut hm = HashMap::new();\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..200 {\n                    assert_eq!(v.borrow()[i], 0);\n                }\n            });\n\n            for i in 0..100 {\n                let d1 = Droppable::new(i);\n                let d2 = Droppable::new(i + 100);\n                hm.insert(d1, d2);\n            }\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..200 {\n                    assert_eq!(v.borrow()[i], 1);\n                }\n            });\n\n            hm\n        };\n\n        // By the way, ensure that cloning doesn't screw up the dropping.\n        drop(hm.clone());\n\n        {\n            let mut half = hm.into_iter().take(50);\n\n            DROP_VECTOR.with(|v| {\n                for i in 0..200 {\n                    assert_eq!(v.borrow()[i], 1);\n                }\n            });\n\n            for _ in half.by_ref() {}\n\n            DROP_VECTOR.with(|v| {\n                let nk = (0..100)\n                    .filter(|&i| v.borrow()[i] == 1)\n                    .count();\n\n                let nv = (0..100)\n                    .filter(|&i| v.borrow()[i + 100] == 1)\n                    .count();\n\n                assert_eq!(nk, 50);\n                assert_eq!(nv, 50);\n            });\n        };\n\n        DROP_VECTOR.with(|v| {\n            for i in 0..200 {\n                assert_eq!(v.borrow()[i], 0);\n            }\n        });\n    }\n\n    #[test]\n    fn test_empty_remove() {\n        let mut m: HashMap<i32, bool> = HashMap::new();\n        assert_eq!(m.remove(&0), None);\n    }\n\n    #[test]\n    fn test_empty_entry() {\n        let mut m: HashMap<i32, bool> = HashMap::new();\n        match m.entry(0) {\n            Occupied(_) => panic!(),\n            Vacant(_) => {}\n        }\n        assert!(*m.entry(0).or_insert(true));\n        assert_eq!(m.len(), 1);\n    }\n\n    #[test]\n    fn test_empty_iter() {\n        let mut m: HashMap<i32, bool> = HashMap::new();\n        assert_eq!(m.drain().next(), None);\n        assert_eq!(m.keys().next(), None);\n        assert_eq!(m.values().next(), None);\n        assert_eq!(m.values_mut().next(), None);\n        assert_eq!(m.iter().next(), None);\n        assert_eq!(m.iter_mut().next(), None);\n        assert_eq!(m.len(), 0);\n        assert!(m.is_empty());\n        assert_eq!(m.into_iter().next(), None);\n    }\n\n    #[test]\n    fn test_lots_of_insertions() {\n        let mut m = HashMap::new();\n\n        // Try this a few times to make sure we never screw up the hashmap's\n        // internal state.\n        for _ in 0..10 {\n            assert!(m.is_empty());\n\n            for i in 1..1001 {\n                assert!(m.insert(i, i).is_none());\n\n                for j in 1..i + 1 {\n                    let r = m.get(&j);\n                    assert_eq!(r, Some(&j));\n                }\n\n                for j in i + 1..1001 {\n                    let r = m.get(&j);\n                    assert_eq!(r, None);\n                }\n            }\n\n            for i in 1001..2001 {\n                assert!(!m.contains_key(&i));\n            }\n\n            // remove forwards\n            for i in 1..1001 {\n                assert!(m.remove(&i).is_some());\n\n                for j in 1..i + 1 {\n                    assert!(!m.contains_key(&j));\n                }\n\n                for j in i + 1..1001 {\n                    assert!(m.contains_key(&j));\n                }\n            }\n\n            for i in 1..1001 {\n                assert!(!m.contains_key(&i));\n            }\n\n            for i in 1..1001 {\n                assert!(m.insert(i, i).is_none());\n            }\n\n            // remove backwards\n            for i in (1..1001).rev() {\n                assert!(m.remove(&i).is_some());\n\n                for j in i..1001 {\n                    assert!(!m.contains_key(&j));\n                }\n\n                for j in 1..i {\n                    assert!(m.contains_key(&j));\n                }\n            }\n        }\n    }\n\n    #[test]\n    fn test_find_mut() {\n        let mut m = HashMap::new();\n        assert!(m.insert(1, 12).is_none());\n        assert!(m.insert(2, 8).is_none());\n        assert!(m.insert(5, 14).is_none());\n        let new = 100;\n        match m.get_mut(&5) {\n            None => panic!(),\n            Some(x) => *x = new,\n        }\n        assert_eq!(m.get(&5), Some(&new));\n    }\n\n    #[test]\n    fn test_insert_overwrite() {\n        let mut m = HashMap::new();\n        assert!(m.insert(1, 2).is_none());\n        assert_eq!(*m.get(&1).unwrap(), 2);\n        assert!(!m.insert(1, 3).is_none());\n        assert_eq!(*m.get(&1).unwrap(), 3);\n    }\n\n    #[test]\n    fn test_insert_conflicts() {\n        let mut m = HashMap::with_capacity(4);\n        assert!(m.insert(1, 2).is_none());\n        assert!(m.insert(5, 3).is_none());\n        assert!(m.insert(9, 4).is_none());\n        assert_eq!(*m.get(&9).unwrap(), 4);\n        assert_eq!(*m.get(&5).unwrap(), 3);\n        assert_eq!(*m.get(&1).unwrap(), 2);\n    }\n\n    #[test]\n    fn test_conflict_remove() {\n        let mut m = HashMap::with_capacity(4);\n        assert!(m.insert(1, 2).is_none());\n        assert_eq!(*m.get(&1).unwrap(), 2);\n        assert!(m.insert(5, 3).is_none());\n        assert_eq!(*m.get(&1).unwrap(), 2);\n        assert_eq!(*m.get(&5).unwrap(), 3);\n        assert!(m.insert(9, 4).is_none());\n        assert_eq!(*m.get(&1).unwrap(), 2);\n        assert_eq!(*m.get(&5).unwrap(), 3);\n        assert_eq!(*m.get(&9).unwrap(), 4);\n        assert!(m.remove(&1).is_some());\n        assert_eq!(*m.get(&9).unwrap(), 4);\n        assert_eq!(*m.get(&5).unwrap(), 3);\n    }\n\n    #[test]\n    fn test_is_empty() {\n        let mut m = HashMap::with_capacity(4);\n        assert!(m.insert(1, 2).is_none());\n        assert!(!m.is_empty());\n        assert!(m.remove(&1).is_some());\n        assert!(m.is_empty());\n    }\n\n    #[test]\n    fn test_remove() {\n        let mut m = HashMap::new();\n        m.insert(1, 2);\n        assert_eq!(m.remove(&1), Some(2));\n        assert_eq!(m.remove(&1), None);\n    }\n\n    #[test]\n    fn test_remove_entry() {\n        let mut m = HashMap::new();\n        m.insert(1, 2);\n        assert_eq!(m.remove_entry(&1), Some((1, 2)));\n        assert_eq!(m.remove(&1), None);\n    }\n\n    #[test]\n    fn test_iterate() {\n        let mut m = HashMap::with_capacity(4);\n        for i in 0..32 {\n            assert!(m.insert(i, i*2).is_none());\n        }\n        assert_eq!(m.len(), 32);\n\n        let mut observed: u32 = 0;\n\n        for (k, v) in &m {\n            assert_eq!(*v, *k * 2);\n            observed |= 1 << *k;\n        }\n        assert_eq!(observed, 0xFFFF_FFFF);\n    }\n\n    #[test]\n    fn test_keys() {\n        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];\n        let map: HashMap<_, _> = vec.into_iter().collect();\n        let keys: Vec<_> = map.keys().cloned().collect();\n        assert_eq!(keys.len(), 3);\n        assert!(keys.contains(&1));\n        assert!(keys.contains(&2));\n        assert!(keys.contains(&3));\n    }\n\n    #[test]\n    fn test_values() {\n        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];\n        let map: HashMap<_, _> = vec.into_iter().collect();\n        let values: Vec<_> = map.values().cloned().collect();\n        assert_eq!(values.len(), 3);\n        assert!(values.contains(&'a'));\n        assert!(values.contains(&'b'));\n        assert!(values.contains(&'c'));\n    }\n\n    #[test]\n    fn test_values_mut() {\n        let vec = vec![(1, 1), (2, 2), (3, 3)];\n        let mut map: HashMap<_, _> = vec.into_iter().collect();\n        for value in map.values_mut() {\n            *value = (*value) * 2\n        }\n        let values: Vec<_> = map.values().cloned().collect();\n        assert_eq!(values.len(), 3);\n        assert!(values.contains(&2));\n        assert!(values.contains(&4));\n        assert!(values.contains(&6));\n    }\n\n    #[test]\n    fn test_find() {\n        let mut m = HashMap::new();\n        assert!(m.get(&1).is_none());\n        m.insert(1, 2);\n        match m.get(&1) {\n            None => panic!(),\n            Some(v) => assert_eq!(*v, 2),\n        }\n    }\n\n    #[test]\n    fn test_eq() {\n        let mut m1 = HashMap::new();\n        m1.insert(1, 2);\n        m1.insert(2, 3);\n        m1.insert(3, 4);\n\n        let mut m2 = HashMap::new();\n        m2.insert(1, 2);\n        m2.insert(2, 3);\n\n        assert!(m1 != m2);\n\n        m2.insert(3, 4);\n\n        assert_eq!(m1, m2);\n    }\n\n    #[test]\n    fn test_show() {\n        let mut map = HashMap::new();\n        let empty: HashMap<i32, i32> = HashMap::new();\n\n        map.insert(1, 2);\n        map.insert(3, 4);\n\n        let map_str = format!(\"{:?}\", map);\n\n        assert!(map_str == \"{1: 2, 3: 4}\" ||\n                map_str == \"{3: 4, 1: 2}\");\n        assert_eq!(format!(\"{:?}\", empty), \"{}\");\n    }\n\n    #[test]\n    fn test_expand() {\n        let mut m = HashMap::new();\n\n        assert_eq!(m.len(), 0);\n        assert!(m.is_empty());\n\n        let mut i = 0;\n        let old_raw_cap = m.raw_capacity();\n        while old_raw_cap == m.raw_capacity() {\n            m.insert(i, i);\n            i += 1;\n        }\n\n        assert_eq!(m.len(), i);\n        assert!(!m.is_empty());\n    }\n\n    #[test]\n    fn test_behavior_resize_policy() {\n        let mut m = HashMap::new();\n\n        assert_eq!(m.len(), 0);\n        assert_eq!(m.raw_capacity(), 0);\n        assert!(m.is_empty());\n\n        m.insert(0, 0);\n        m.remove(&0);\n        assert!(m.is_empty());\n        let initial_raw_cap = m.raw_capacity();\n        m.reserve(initial_raw_cap);\n        let raw_cap = m.raw_capacity();\n\n        assert_eq!(raw_cap, initial_raw_cap * 2);\n\n        let mut i = 0;\n        for _ in 0..raw_cap * 3 / 4 {\n            m.insert(i, i);\n            i += 1;\n        }\n        // three quarters full\n\n        assert_eq!(m.len(), i);\n        assert_eq!(m.raw_capacity(), raw_cap);\n\n        for _ in 0..raw_cap / 4 {\n            m.insert(i, i);\n            i += 1;\n        }\n        // half full\n\n        let new_raw_cap = m.raw_capacity();\n        assert_eq!(new_raw_cap, raw_cap * 2);\n\n        for _ in 0..raw_cap / 2 - 1 {\n            i -= 1;\n            m.remove(&i);\n            assert_eq!(m.raw_capacity(), new_raw_cap);\n        }\n        // A little more than one quarter full.\n        m.shrink_to_fit();\n        assert_eq!(m.raw_capacity(), raw_cap);\n        // again, a little more than half full\n        for _ in 0..raw_cap / 2 - 1 {\n            i -= 1;\n            m.remove(&i);\n        }\n        m.shrink_to_fit();\n\n        assert_eq!(m.len(), i);\n        assert!(!m.is_empty());\n        assert_eq!(m.raw_capacity(), initial_raw_cap);\n    }\n\n    #[test]\n    fn test_reserve_shrink_to_fit() {\n        let mut m = HashMap::new();\n        m.insert(0, 0);\n        m.remove(&0);\n        assert!(m.capacity() >= m.len());\n        for i in 0..128 {\n            m.insert(i, i);\n        }\n        m.reserve(256);\n\n        let usable_cap = m.capacity();\n        for i in 128..(128 + 256) {\n            m.insert(i, i);\n            assert_eq!(m.capacity(), usable_cap);\n        }\n\n        for i in 100..(128 + 256) {\n            assert_eq!(m.remove(&i), Some(i));\n        }\n        m.shrink_to_fit();\n\n        assert_eq!(m.len(), 100);\n        assert!(!m.is_empty());\n        assert!(m.capacity() >= m.len());\n\n        for i in 0..100 {\n            assert_eq!(m.remove(&i), Some(i));\n        }\n        m.shrink_to_fit();\n        m.insert(0, 0);\n\n        assert_eq!(m.len(), 1);\n        assert!(m.capacity() >= m.len());\n        assert_eq!(m.remove(&0), Some(0));\n    }\n\n    #[test]\n    fn test_from_iter() {\n        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];\n\n        let map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        for &(k, v) in &xs {\n            assert_eq!(map.get(&k), Some(&v));\n        }\n    }\n\n    #[test]\n    fn test_size_hint() {\n        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];\n\n        let map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        let mut iter = map.iter();\n\n        for _ in iter.by_ref().take(3) {}\n\n        assert_eq!(iter.size_hint(), (3, Some(3)));\n    }\n\n    #[test]\n    fn test_iter_len() {\n        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];\n\n        let map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        let mut iter = map.iter();\n\n        for _ in iter.by_ref().take(3) {}\n\n        assert_eq!(iter.len(), 3);\n    }\n\n    #[test]\n    fn test_mut_size_hint() {\n        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];\n\n        let mut map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        let mut iter = map.iter_mut();\n\n        for _ in iter.by_ref().take(3) {}\n\n        assert_eq!(iter.size_hint(), (3, Some(3)));\n    }\n\n    #[test]\n    fn test_iter_mut_len() {\n        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];\n\n        let mut map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        let mut iter = map.iter_mut();\n\n        for _ in iter.by_ref().take(3) {}\n\n        assert_eq!(iter.len(), 3);\n    }\n\n    #[test]\n    fn test_index() {\n        let mut map = HashMap::new();\n\n        map.insert(1, 2);\n        map.insert(2, 1);\n        map.insert(3, 4);\n\n        assert_eq!(map[&2], 1);\n    }\n\n    #[test]\n    #[should_panic]\n    fn test_index_nonexistent() {\n        let mut map = HashMap::new();\n\n        map.insert(1, 2);\n        map.insert(2, 1);\n        map.insert(3, 4);\n\n        map[&4];\n    }\n\n    #[test]\n    fn test_entry() {\n        let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];\n\n        let mut map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        // Existing key (insert)\n        match map.entry(1) {\n            Vacant(_) => unreachable!(),\n            Occupied(mut view) => {\n                assert_eq!(view.get(), &10);\n                assert_eq!(view.insert(100), 10);\n            }\n        }\n        assert_eq!(map.get(&1).unwrap(), &100);\n        assert_eq!(map.len(), 6);\n\n\n        // Existing key (update)\n        match map.entry(2) {\n            Vacant(_) => unreachable!(),\n            Occupied(mut view) => {\n                let v = view.get_mut();\n                let new_v = (*v) * 10;\n                *v = new_v;\n            }\n        }\n        assert_eq!(map.get(&2).unwrap(), &200);\n        assert_eq!(map.len(), 6);\n\n        // Existing key (take)\n        match map.entry(3) {\n            Vacant(_) => unreachable!(),\n            Occupied(view) => {\n                assert_eq!(view.remove(), 30);\n            }\n        }\n        assert_eq!(map.get(&3), None);\n        assert_eq!(map.len(), 5);\n\n\n        // Inexistent key (insert)\n        match map.entry(10) {\n            Occupied(_) => unreachable!(),\n            Vacant(view) => {\n                assert_eq!(*view.insert(1000), 1000);\n            }\n        }\n        assert_eq!(map.get(&10).unwrap(), &1000);\n        assert_eq!(map.len(), 6);\n    }\n\n    #[test]\n    fn test_entry_take_doesnt_corrupt() {\n        #![allow(deprecated)] //rand\n        // Test for #19292\n        fn check(m: &HashMap<i32, ()>) {\n            for k in m.keys() {\n                assert!(m.contains_key(k),\n                        \"{} is in keys() but not in the map?\", k);\n            }\n        }\n\n        let mut m = HashMap::new();\n        let mut rng = thread_rng();\n\n        // Populate the map with some items.\n        for _ in 0..50 {\n            let x = rng.gen_range(-10, 10);\n            m.insert(x, ());\n        }\n\n        for _ in 0..1000 {\n            let x = rng.gen_range(-10, 10);\n            match m.entry(x) {\n                Vacant(_) => {}\n                Occupied(e) => {\n                    e.remove();\n                }\n            }\n\n            check(&m);\n        }\n    }\n\n    #[test]\n    fn test_extend_ref() {\n        let mut a = HashMap::new();\n        a.insert(1, \"one\");\n        let mut b = HashMap::new();\n        b.insert(2, \"two\");\n        b.insert(3, \"three\");\n\n        a.extend(&b);\n\n        assert_eq!(a.len(), 3);\n        assert_eq!(a[&1], \"one\");\n        assert_eq!(a[&2], \"two\");\n        assert_eq!(a[&3], \"three\");\n    }\n\n    #[test]\n    fn test_capacity_not_less_than_len() {\n        let mut a = HashMap::new();\n        let mut item = 0;\n\n        for _ in 0..116 {\n            a.insert(item, 0);\n            item += 1;\n        }\n\n        assert!(a.capacity() > a.len());\n\n        let free = a.capacity() - a.len();\n        for _ in 0..free {\n            a.insert(item, 0);\n            item += 1;\n        }\n\n        assert_eq!(a.len(), a.capacity());\n\n        // Insert at capacity should cause allocation.\n        a.insert(item, 0);\n        assert!(a.capacity() > a.len());\n    }\n\n    #[test]\n    fn test_occupied_entry_key() {\n        let mut a = HashMap::new();\n        let key = \"hello there\";\n        let value = \"value goes here\";\n        assert!(a.is_empty());\n        a.insert(key.clone(), value.clone());\n        assert_eq!(a.len(), 1);\n        assert_eq!(a[key], value);\n\n        match a.entry(key.clone()) {\n            Vacant(_) => panic!(),\n            Occupied(e) => assert_eq!(key, *e.key()),\n        }\n        assert_eq!(a.len(), 1);\n        assert_eq!(a[key], value);\n    }\n\n    #[test]\n    fn test_vacant_entry_key() {\n        let mut a = HashMap::new();\n        let key = \"hello there\";\n        let value = \"value goes here\";\n\n        assert!(a.is_empty());\n        match a.entry(key.clone()) {\n            Occupied(_) => panic!(),\n            Vacant(e) => {\n                assert_eq!(key, *e.key());\n                e.insert(value.clone());\n            }\n        }\n        assert_eq!(a.len(), 1);\n        assert_eq!(a[key], value);\n    }\n\n    #[test]\n    fn test_retain() {\n        let mut map: HashMap<i32, i32> = (0..100).map(|x|(x, x*10)).collect();\n\n        map.retain(|&k, _| k % 2 == 0);\n        assert_eq!(map.len(), 50);\n        assert_eq!(map[&2], 20);\n        assert_eq!(map[&4], 40);\n        assert_eq!(map[&6], 60);\n    }\n\n    #[test]\n    fn test_adaptive() {\n        const TEST_LEN: usize = 5000;\n        // by cloning we get maps with the same hasher seed\n        let mut first = HashMap::new();\n        let mut second = first.clone();\n        first.extend((0..TEST_LEN).map(|i| (i, i)));\n        second.extend((TEST_LEN..TEST_LEN * 2).map(|i| (i, i)));\n\n        for (&k, &v) in &second {\n            let prev_cap = first.capacity();\n            let expect_grow = first.len() == prev_cap;\n            first.insert(k, v);\n            if !expect_grow && first.capacity() != prev_cap {\n                return;\n            }\n        }\n        panic!(\"Adaptive early resize failed\");\n    }\n\n    #[test]\n    fn test_try_reserve() {\n\n        let mut empty_bytes: HashMap<u8,u8> = HashMap::new();\n\n        const MAX_USIZE: usize = usize::MAX;\n\n        // HashMap and RawTables use complicated size calculations\n        // hashes_size is sizeof(HashUint) * capacity;\n        // pairs_size is sizeof((K. V)) * capacity;\n        // alignment_hashes_size is 8\n        // alignment_pairs size is 4\n        let size_of_multiplier = (size_of::<usize>() + size_of::<(u8, u8)>()).next_power_of_two();\n        // The following formula is used to calculate the new capacity\n        let max_no_ovf = ((MAX_USIZE / 11) * 10) / size_of_multiplier - 1;\n\n        if let Err(CapacityOverflow) = empty_bytes.try_reserve(MAX_USIZE) {\n        } else { panic!(\"usize::MAX should trigger an overflow!\"); }\n\n        if size_of::<usize>() < 8 {\n            if let Err(CapacityOverflow) = empty_bytes.try_reserve(max_no_ovf) {\n            } else { panic!(\"isize::MAX + 1 should trigger a CapacityOverflow!\") }\n        } else {\n            if let Err(AllocErr) = empty_bytes.try_reserve(max_no_ovf) {\n            } else { panic!(\"isize::MAX + 1 should trigger an OOM!\") }\n        }\n    }\n\n    #[test]\n    fn test_raw_entry() {\n        use super::RawEntryMut::{Occupied, Vacant};\n\n        let xs = [(1i32, 10i32), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];\n\n        let mut map: HashMap<_, _> = xs.iter().cloned().collect();\n\n        let compute_hash = |map: &HashMap<i32, i32>, k: i32| -> u64 {\n            use core::hash::{BuildHasher, Hash, Hasher};\n\n            let mut hasher = map.hasher().build_hasher();\n            k.hash(&mut hasher);\n            hasher.finish()\n        };\n\n        // Existing key (insert)\n        match map.raw_entry_mut().from_key(&1) {\n            Vacant(_) => unreachable!(),\n            Occupied(mut view) => {\n                assert_eq!(view.get(), &10);\n                assert_eq!(view.insert(100), 10);\n            }\n        }\n        let hash1 = compute_hash(&map, 1);\n        assert_eq!(map.raw_entry().from_key(&1).unwrap(), (&1, &100));\n        assert_eq!(map.raw_entry().from_hash(hash1, |k| *k == 1).unwrap(), (&1, &100));\n        assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash1, &1).unwrap(), (&1, &100));\n        assert_eq!(map.raw_entry().search_bucket(hash1, |k| *k == 1).unwrap(), (&1, &100));\n        assert_eq!(map.len(), 6);\n\n        // Existing key (update)\n        match map.raw_entry_mut().from_key(&2) {\n            Vacant(_) => unreachable!(),\n            Occupied(mut view) => {\n                let v = view.get_mut();\n                let new_v = (*v) * 10;\n                *v = new_v;\n            }\n        }\n        let hash2 = compute_hash(&map, 2);\n        assert_eq!(map.raw_entry().from_key(&2).unwrap(), (&2, &200));\n        assert_eq!(map.raw_entry().from_hash(hash2, |k| *k == 2).unwrap(), (&2, &200));\n        assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash2, &2).unwrap(), (&2, &200));\n        assert_eq!(map.raw_entry().search_bucket(hash2, |k| *k == 2).unwrap(), (&2, &200));\n        assert_eq!(map.len(), 6);\n\n        // Existing key (take)\n        let hash3 = compute_hash(&map, 3);\n        match map.raw_entry_mut().from_key_hashed_nocheck(hash3, &3) {\n            Vacant(_) => unreachable!(),\n            Occupied(view) => {\n                assert_eq!(view.remove_entry(), (3, 30));\n            }\n        }\n        assert_eq!(map.raw_entry().from_key(&3), None);\n        assert_eq!(map.raw_entry().from_hash(hash3, |k| *k == 3), None);\n        assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash3, &3), None);\n        assert_eq!(map.raw_entry().search_bucket(hash3, |k| *k == 3), None);\n        assert_eq!(map.len(), 5);\n\n\n        // Nonexistent key (insert)\n        match map.raw_entry_mut().from_key(&10) {\n            Occupied(_) => unreachable!(),\n            Vacant(view) => {\n                assert_eq!(view.insert(10, 1000), (&mut 10, &mut 1000));\n            }\n        }\n        assert_eq!(map.raw_entry().from_key(&10).unwrap(), (&10, &1000));\n        assert_eq!(map.len(), 6);\n\n        // Ensure all lookup methods produce equivalent results.\n        for k in 0..12 {\n            let hash = compute_hash(&map, k);\n            let v = map.get(&k).cloned();\n            let kv = v.as_ref().map(|v| (&k, v));\n\n            assert_eq!(map.raw_entry().from_key(&k), kv);\n            assert_eq!(map.raw_entry().from_hash(hash, |q| *q == k), kv);\n            assert_eq!(map.raw_entry().from_key_hashed_nocheck(hash, &k), kv);\n            assert_eq!(map.raw_entry().search_bucket(hash, |q| *q == k), kv);\n\n            match map.raw_entry_mut().from_key(&k) {\n                Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv),\n                Vacant(_) => assert_eq!(v, None),\n            }\n            match map.raw_entry_mut().from_key_hashed_nocheck(hash, &k) {\n                Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv),\n                Vacant(_) => assert_eq!(v, None),\n            }\n            match map.raw_entry_mut().from_hash(hash, |q| *q == k) {\n                Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv),\n                Vacant(_) => assert_eq!(v, None),\n            }\n            match map.raw_entry_mut().search_bucket(hash, |q| *q == k) {\n                Occupied(mut o) => assert_eq!(Some(o.get_key_value()), kv),\n                Vacant(_) => assert_eq!(v, None),\n            }\n        }\n    }\n\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n#![unstable(feature = \"ip\", reason = \"extra functionality has not been \\\n                                      scrutinized to the level that it should \\\n                                      be to be stable\",\n            issue = \"27709\")]\n\nuse cmp::Ordering;\nuse fmt;\nuse hash;\nuse sys::net::netc as c;\nuse sys_common::{AsInner, FromInner};\n\n/// An IP address, either IPv4 or IPv6.\n///\n/// This enum can contain either an [`Ipv4Addr`] or an [`Ipv6Addr`], see their\n/// respective documentation for more details.\n///\n/// The size of an `IpAddr` instance may vary depending on the target operating\n/// system.\n///\n/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html\n/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html\n///\n/// # Examples\n///\n/// ```\n/// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n///\n/// let localhost_v4 = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));\n/// let localhost_v6 = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));\n///\n/// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost_v4));\n/// assert_eq!(\"::1\".parse(), Ok(localhost_v6));\n///\n/// assert_eq!(localhost_v4.is_ipv6(), false);\n/// assert_eq!(localhost_v4.is_ipv4(), true);\n/// ```\n#[stable(feature = \"ip_addr\", since = \"1.7.0\")]\n#[derive(Copy, Clone, Eq, PartialEq, Debug, Hash, PartialOrd, Ord)]\npub enum IpAddr {\n    /// An IPv4 address.\n    #[stable(feature = \"ip_addr\", since = \"1.7.0\")]\n    V4(#[stable(feature = \"ip_addr\", since = \"1.7.0\")] Ipv4Addr),\n    /// An IPv6 address.\n    #[stable(feature = \"ip_addr\", since = \"1.7.0\")]\n    V6(#[stable(feature = \"ip_addr\", since = \"1.7.0\")] Ipv6Addr),\n}\n\n/// An IPv4 address.\n///\n/// IPv4 addresses are defined as 32-bit integers in [IETF RFC 791].\n/// They are usually represented as four octets.\n///\n/// See [`IpAddr`] for a type encompassing both IPv4 and IPv6 addresses.\n///\n/// The size of an `Ipv4Addr` struct may vary depending on the target operating\n/// system.\n///\n/// [IETF RFC 791]: https://tools.ietf.org/html/rfc791\n/// [`IpAddr`]: ../../std/net/enum.IpAddr.html\n///\n/// # Textual representation\n///\n/// `Ipv4Addr` provides a [`FromStr`] implementation. The four octets are in decimal\n/// notation, divided by `.` (this is called \"dot-decimal notation\").\n///\n/// [`FromStr`]: ../../std/str/trait.FromStr.html\n///\n/// # Examples\n///\n/// ```\n/// use std::net::Ipv4Addr;\n///\n/// let localhost = Ipv4Addr::new(127, 0, 0, 1);\n/// assert_eq!(\"127.0.0.1\".parse(), Ok(localhost));\n/// assert_eq!(localhost.is_loopback(), true);\n/// ```\n#[derive(Copy)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Ipv4Addr {\n    inner: c::in_addr,\n}\n\n/// An IPv6 address.\n///\n/// IPv6 addresses are defined as 128-bit integers in [IETF RFC 4291].\n/// They are usually represented as eight 16-bit segments.\n///\n/// See [`IpAddr`] for a type encompassing both IPv4 and IPv6 addresses.\n///\n/// The size of an `Ipv6Addr` struct may vary depending on the target operating\n/// system.\n///\n/// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291\n/// [`IpAddr`]: ../../std/net/enum.IpAddr.html\n///\n/// # Textual representation\n///\n/// `Ipv6Addr` provides a [`FromStr`] implementation. There are many ways to represent\n/// an IPv6 address in text, but in general, each segments is written in hexadecimal\n/// notation, and segments are separated by `:`. For more information, see\n/// [IETF RFC 5952].\n///\n/// [`FromStr`]: ../../std/str/trait.FromStr.html\n/// [IETF RFC 5952]: https://tools.ietf.org/html/rfc5952\n///\n/// # Examples\n///\n/// ```\n/// use std::net::Ipv6Addr;\n///\n/// let localhost = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);\n/// assert_eq!(\"::1\".parse(), Ok(localhost));\n/// assert_eq!(localhost.is_loopback(), true);\n/// ```\n#[derive(Copy)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct Ipv6Addr {\n    inner: c::in6_addr,\n}\n\n#[allow(missing_docs)]\n#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]\npub enum Ipv6MulticastScope {\n    InterfaceLocal,\n    LinkLocal,\n    RealmLocal,\n    AdminLocal,\n    SiteLocal,\n    OrganizationLocal,\n    Global\n}\n\nimpl IpAddr {\n    /// Returns [`true`] for the special 'unspecified' address.\n    ///\n    /// See the documentation for [`Ipv4Addr::is_unspecified`][IPv4] and\n    /// [`Ipv6Addr::is_unspecified`][IPv6] for more details.\n    ///\n    /// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_unspecified\n    /// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_unspecified\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)).is_unspecified(), true);\n    /// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)).is_unspecified(), true);\n    /// ```\n    #[stable(feature = \"ip_shared\", since = \"1.12.0\")]\n    pub fn is_unspecified(&self) -> bool {\n        match self {\n            IpAddr::V4(ip) => ip.is_unspecified(),\n            IpAddr::V6(ip) => ip.is_unspecified(),\n        }\n    }\n\n    /// Returns [`true`] if this is a loopback address.\n    ///\n    /// See the documentation for [`Ipv4Addr::is_loopback`][IPv4] and\n    /// [`Ipv6Addr::is_loopback`][IPv6] for more details.\n    ///\n    /// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_loopback\n    /// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_loopback\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).is_loopback(), true);\n    /// assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1)).is_loopback(), true);\n    /// ```\n    #[stable(feature = \"ip_shared\", since = \"1.12.0\")]\n    pub fn is_loopback(&self) -> bool {\n        match self {\n            IpAddr::V4(ip) => ip.is_loopback(),\n            IpAddr::V6(ip) => ip.is_loopback(),\n        }\n    }\n\n    /// Returns [`true`] if the address appears to be globally routable.\n    ///\n    /// See the documentation for [`Ipv4Addr::is_global`][IPv4] and\n    /// [`Ipv6Addr::is_global`][IPv6] for more details.\n    ///\n    /// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_global\n    /// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_global\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// fn main() {\n    ///     assert_eq!(IpAddr::V4(Ipv4Addr::new(80, 9, 12, 3)).is_global(), true);\n    ///     assert_eq!(IpAddr::V6(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1)).is_global(),\n    ///                true);\n    /// }\n    /// ```\n    pub fn is_global(&self) -> bool {\n        match self {\n            IpAddr::V4(ip) => ip.is_global(),\n            IpAddr::V6(ip) => ip.is_global(),\n        }\n    }\n\n    /// Returns [`true`] if this is a multicast address.\n    ///\n    /// See the documentation for [`Ipv4Addr::is_multicast`][IPv4] and\n    /// [`Ipv6Addr::is_multicast`][IPv6] for more details.\n    ///\n    /// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_multicast\n    /// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_multicast\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(IpAddr::V4(Ipv4Addr::new(224, 254, 0, 0)).is_multicast(), true);\n    /// assert_eq!(IpAddr::V6(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0)).is_multicast(), true);\n    /// ```\n    #[stable(feature = \"ip_shared\", since = \"1.12.0\")]\n    pub fn is_multicast(&self) -> bool {\n        match self {\n            IpAddr::V4(ip) => ip.is_multicast(),\n            IpAddr::V6(ip) => ip.is_multicast(),\n        }\n    }\n\n    /// Returns [`true`] if this address is in a range designated for documentation.\n    ///\n    /// See the documentation for [`Ipv4Addr::is_documentation`][IPv4] and\n    /// [`Ipv6Addr::is_documentation`][IPv6] for more details.\n    ///\n    /// [IPv4]: ../../std/net/struct.Ipv4Addr.html#method.is_documentation\n    /// [IPv6]: ../../std/net/struct.Ipv6Addr.html#method.is_documentation\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// fn main() {\n    ///     assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_documentation(), true);\n    ///     assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0))\n    ///                       .is_documentation(), true);\n    /// }\n    /// ```\n    pub fn is_documentation(&self) -> bool {\n        match self {\n            IpAddr::V4(ip) => ip.is_documentation(),\n            IpAddr::V6(ip) => ip.is_documentation(),\n        }\n    }\n\n    /// Returns [`true`] if this address is an [IPv4 address], and [`false`] otherwise.\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    /// [`false`]: ../../std/primitive.bool.html\n    /// [IPv4 address]: #variant.V4\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// fn main() {\n    ///     assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv4(), true);\n    ///     assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv4(),\n    ///                false);\n    /// }\n    /// ```\n    #[stable(feature = \"ipaddr_checker\", since = \"1.16.0\")]\n    pub fn is_ipv4(&self) -> bool {\n        match self {\n            IpAddr::V4(_) => true,\n            IpAddr::V6(_) => false,\n        }\n    }\n\n    /// Returns [`true`] if this address is an [IPv6 address], and [`false`] otherwise.\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    /// [`false`]: ../../std/primitive.bool.html\n    /// [IPv6 address]: #variant.V6\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};\n    ///\n    /// fn main() {\n    ///     assert_eq!(IpAddr::V4(Ipv4Addr::new(203, 0, 113, 6)).is_ipv6(), false);\n    ///     assert_eq!(IpAddr::V6(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0)).is_ipv6(),\n    ///                true);\n    /// }\n    /// ```\n    #[stable(feature = \"ipaddr_checker\", since = \"1.16.0\")]\n    pub fn is_ipv6(&self) -> bool {\n        match self {\n            IpAddr::V4(_) => false,\n            IpAddr::V6(_) => true,\n        }\n    }\n}\n\nimpl Ipv4Addr {\n    /// Creates a new IPv4 address from four eight-bit octets.\n    ///\n    /// The result will represent the IP address `a`.`b`.`c`.`d`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::new(127, 0, 0, 1);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature = \"const_ip\")]\n    pub const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr {\n        Ipv4Addr {\n            inner: c::in_addr {\n                s_addr: u32::to_be(\n                    ((a as u32) << 24) |\n                    ((b as u32) << 16) |\n                    ((c as u32) <<  8) |\n                    (d as u32)\n                ),\n            }\n        }\n    }\n\n    /// An IPv4 address with the address pointing to localhost: 127.0.0.1.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::LOCALHOST;\n    /// assert_eq!(addr, Ipv4Addr::new(127, 0, 0, 1));\n    /// ```\n    #[stable(feature = \"ip_constructors\", since = \"1.30.0\")]\n    pub const LOCALHOST: Self = Ipv4Addr::new(127, 0, 0, 1);\n\n    /// An IPv4 address representing an unspecified address: 0.0.0.0\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::UNSPECIFIED;\n    /// assert_eq!(addr, Ipv4Addr::new(0, 0, 0, 0));\n    /// ```\n    #[stable(feature = \"ip_constructors\", since = \"1.30.0\")]\n    pub const UNSPECIFIED: Self = Ipv4Addr::new(0, 0, 0, 0);\n\n    /// An IPv4 address representing the broadcast address: 255.255.255.255\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::BROADCAST;\n    /// assert_eq!(addr, Ipv4Addr::new(255, 255, 255, 255));\n    /// ```\n    #[stable(feature = \"ip_constructors\", since = \"1.30.0\")]\n    pub const BROADCAST: Self = Ipv4Addr::new(255, 255, 255, 255);\n\n    /// Returns the four eight-bit integers that make up this address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::new(127, 0, 0, 1);\n    /// assert_eq!(addr.octets(), [127, 0, 0, 1]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn octets(&self) -> [u8; 4] {\n        let bits = u32::from_be(self.inner.s_addr);\n        [(bits >> 24) as u8, (bits >> 16) as u8, (bits >> 8) as u8, bits as u8]\n    }\n\n    /// Returns [`true`] for the special 'unspecified' address (0.0.0.0).\n    ///\n    /// This property is defined in _UNIX Network Programming, Second Edition_,\n    /// W. Richard Stevens, p. 891; see also [ip7].\n    ///\n    /// [ip7]: http://man7.org/linux/man-pages/man7/ip.7.html\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(0, 0, 0, 0).is_unspecified(), true);\n    /// assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_unspecified(), false);\n    /// ```\n    #[stable(feature = \"ip_shared\", since = \"1.12.0\")]\n    pub fn is_unspecified(&self) -> bool {\n        self.inner.s_addr == 0\n    }\n\n    /// Returns [`true`] if this is a loopback address (127.0.0.0/8).\n    ///\n    /// This property is defined by [IETF RFC 1122].\n    ///\n    /// [IETF RFC 1122]: https://tools.ietf.org/html/rfc1122\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(127, 0, 0, 1).is_loopback(), true);\n    /// assert_eq!(Ipv4Addr::new(45, 22, 13, 197).is_loopback(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_loopback(&self) -> bool {\n        self.octets()[0] == 127\n    }\n\n    /// Returns [`true`] if this is a private address.\n    ///\n    /// The private address ranges are defined in [IETF RFC 1918] and include:\n    ///\n    ///  - 10.0.0.0/8\n    ///  - 172.16.0.0/12\n    ///  - 192.168.0.0/16\n    ///\n    /// [IETF RFC 1918]: https://tools.ietf.org/html/rfc1918\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(10, 0, 0, 1).is_private(), true);\n    /// assert_eq!(Ipv4Addr::new(10, 10, 10, 10).is_private(), true);\n    /// assert_eq!(Ipv4Addr::new(172, 16, 10, 10).is_private(), true);\n    /// assert_eq!(Ipv4Addr::new(172, 29, 45, 14).is_private(), true);\n    /// assert_eq!(Ipv4Addr::new(172, 32, 0, 2).is_private(), false);\n    /// assert_eq!(Ipv4Addr::new(192, 168, 0, 2).is_private(), true);\n    /// assert_eq!(Ipv4Addr::new(192, 169, 0, 2).is_private(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_private(&self) -> bool {\n        match self.octets() {\n            [10, ..] => true,\n            [172, b, ..] if b >= 16 && b <= 31 => true,\n            [192, 168, ..] => true,\n            _ => false,\n        }\n    }\n\n    /// Returns [`true`] if the address is link-local (169.254.0.0/16).\n    ///\n    /// This property is defined by [IETF RFC 3927].\n    ///\n    /// [IETF RFC 3927]: https://tools.ietf.org/html/rfc3927\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(169, 254, 0, 0).is_link_local(), true);\n    /// assert_eq!(Ipv4Addr::new(169, 254, 10, 65).is_link_local(), true);\n    /// assert_eq!(Ipv4Addr::new(16, 89, 10, 65).is_link_local(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_link_local(&self) -> bool {\n        match self.octets() {\n            [169, 254, ..] => true,\n            _ => false,\n        }\n    }\n\n    /// Returns [`true`] if the address appears to be globally routable.\n    /// See [iana-ipv4-special-registry][ipv4-sr].\n    ///\n    /// The following return false:\n    ///\n    /// - private address (10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16)\n    /// - the loopback address (127.0.0.0/8)\n    /// - the link-local address (169.254.0.0/16)\n    /// - the broadcast address (255.255.255.255/32)\n    /// - test addresses used for documentation (192.0.2.0/24, 198.51.100.0/24 and 203.0.113.0/24)\n    /// - the unspecified address (0.0.0.0)\n    ///\n    /// [ipv4-sr]: https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv4Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv4Addr::new(10, 254, 0, 0).is_global(), false);\n    ///     assert_eq!(Ipv4Addr::new(192, 168, 10, 65).is_global(), false);\n    ///     assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_global(), false);\n    ///     assert_eq!(Ipv4Addr::new(0, 0, 0, 0).is_global(), false);\n    ///     assert_eq!(Ipv4Addr::new(80, 9, 12, 3).is_global(), true);\n    /// }\n    /// ```\n    pub fn is_global(&self) -> bool {\n        !self.is_private() && !self.is_loopback() && !self.is_link_local() &&\n        !self.is_broadcast() && !self.is_documentation() && !self.is_unspecified()\n    }\n\n    /// Returns [`true`] if this is a multicast address (224.0.0.0/4).\n    ///\n    /// Multicast addresses have a most significant octet between 224 and 239,\n    /// and is defined by [IETF RFC 5771].\n    ///\n    /// [IETF RFC 5771]: https://tools.ietf.org/html/rfc5771\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(224, 254, 0, 0).is_multicast(), true);\n    /// assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_multicast(), true);\n    /// assert_eq!(Ipv4Addr::new(172, 16, 10, 65).is_multicast(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_multicast(&self) -> bool {\n        self.octets()[0] >= 224 && self.octets()[0] <= 239\n    }\n\n    /// Returns [`true`] if this is a broadcast address (255.255.255.255).\n    ///\n    /// A broadcast address has all octets set to 255 as defined in [IETF RFC 919].\n    ///\n    /// [IETF RFC 919]: https://tools.ietf.org/html/rfc919\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(255, 255, 255, 255).is_broadcast(), true);\n    /// assert_eq!(Ipv4Addr::new(236, 168, 10, 65).is_broadcast(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_broadcast(&self) -> bool {\n        self == &Self::BROADCAST\n    }\n\n    /// Returns [`true`] if this address is in a range designated for documentation.\n    ///\n    /// This is defined in [IETF RFC 5737]:\n    ///\n    /// - 192.0.2.0/24 (TEST-NET-1)\n    /// - 198.51.100.0/24 (TEST-NET-2)\n    /// - 203.0.113.0/24 (TEST-NET-3)\n    ///\n    /// [IETF RFC 5737]: https://tools.ietf.org/html/rfc5737\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).is_documentation(), true);\n    /// assert_eq!(Ipv4Addr::new(198, 51, 100, 65).is_documentation(), true);\n    /// assert_eq!(Ipv4Addr::new(203, 0, 113, 6).is_documentation(), true);\n    /// assert_eq!(Ipv4Addr::new(193, 34, 17, 19).is_documentation(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_documentation(&self) -> bool {\n        match self.octets() {\n            [192, 0, 2, _] => true,\n            [198, 51, 100, _] => true,\n            [203, 0, 113, _] => true,\n            _ => false,\n        }\n    }\n\n    /// Converts this address to an IPv4-compatible [IPv6 address].\n    ///\n    /// a.b.c.d becomes ::a.b.c.d\n    ///\n    /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).to_ipv6_compatible(),\n    ///            Ipv6Addr::new(0, 0, 0, 0, 0, 0, 49152, 767));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_ipv6_compatible(&self) -> Ipv6Addr {\n        Ipv6Addr::new(0, 0, 0, 0, 0, 0,\n                      ((self.octets()[0] as u16) << 8) | self.octets()[1] as u16,\n                      ((self.octets()[2] as u16) << 8) | self.octets()[3] as u16)\n    }\n\n    /// Converts this address to an IPv4-mapped [IPv6 address].\n    ///\n    /// a.b.c.d becomes ::ffff:a.b.c.d\n    ///\n    /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(Ipv4Addr::new(192, 0, 2, 255).to_ipv6_mapped(),\n    ///            Ipv6Addr::new(0, 0, 0, 0, 0, 65535, 49152, 767));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_ipv6_mapped(&self) -> Ipv6Addr {\n        Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff,\n                      ((self.octets()[0] as u16) << 8) | self.octets()[1] as u16,\n                      ((self.octets()[2] as u16) << 8) | self.octets()[3] as u16)\n    }\n}\n\n#[stable(feature = \"ip_addr\", since = \"1.7.0\")]\nimpl fmt::Display for IpAddr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        match self {\n            IpAddr::V4(ip) => ip.fmt(fmt),\n            IpAddr::V6(ip) => ip.fmt(fmt),\n        }\n    }\n}\n\n#[stable(feature = \"ip_from_ip\", since = \"1.16.0\")]\nimpl From<Ipv4Addr> for IpAddr {\n    fn from(ipv4: Ipv4Addr) -> IpAddr {\n        IpAddr::V4(ipv4)\n    }\n}\n\n#[stable(feature = \"ip_from_ip\", since = \"1.16.0\")]\nimpl From<Ipv6Addr> for IpAddr {\n    fn from(ipv6: Ipv6Addr) -> IpAddr {\n        IpAddr::V6(ipv6)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for Ipv4Addr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        let octets = self.octets();\n        write!(fmt, \"{}.{}.{}.{}\", octets[0], octets[1], octets[2], octets[3])\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for Ipv4Addr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self, fmt)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Clone for Ipv4Addr {\n    fn clone(&self) -> Ipv4Addr { *self }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for Ipv4Addr {\n    fn eq(&self, other: &Ipv4Addr) -> bool {\n        self.inner.s_addr == other.inner.s_addr\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialEq<Ipv4Addr> for IpAddr {\n    fn eq(&self, other: &Ipv4Addr) -> bool {\n        match self {\n            IpAddr::V4(v4) => v4 == other,\n            IpAddr::V6(_) => false,\n        }\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialEq<IpAddr> for Ipv4Addr {\n    fn eq(&self, other: &IpAddr) -> bool {\n        match other {\n            IpAddr::V4(v4) => self == v4,\n            IpAddr::V6(_) => false,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for Ipv4Addr {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl hash::Hash for Ipv4Addr {\n    fn hash<H: hash::Hasher>(&self, s: &mut H) {\n        // `inner` is #[repr(packed)], so we need to copy `s_addr`.\n        {self.inner.s_addr}.hash(s)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for Ipv4Addr {\n    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialOrd<Ipv4Addr> for IpAddr {\n    fn partial_cmp(&self, other: &Ipv4Addr) -> Option<Ordering> {\n        match self {\n            IpAddr::V4(v4) => v4.partial_cmp(other),\n            IpAddr::V6(_) => Some(Ordering::Greater),\n        }\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialOrd<IpAddr> for Ipv4Addr {\n    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {\n        match other {\n            IpAddr::V4(v4) => self.partial_cmp(v4),\n            IpAddr::V6(_) => Some(Ordering::Less),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for Ipv4Addr {\n    fn cmp(&self, other: &Ipv4Addr) -> Ordering {\n        u32::from_be(self.inner.s_addr).cmp(&u32::from_be(other.inner.s_addr))\n    }\n}\n\nimpl AsInner<c::in_addr> for Ipv4Addr {\n    fn as_inner(&self) -> &c::in_addr { &self.inner }\n}\nimpl FromInner<c::in_addr> for Ipv4Addr {\n    fn from_inner(addr: c::in_addr) -> Ipv4Addr {\n        Ipv4Addr { inner: addr }\n    }\n}\n\n#[stable(feature = \"ip_u32\", since = \"1.1.0\")]\nimpl From<Ipv4Addr> for u32 {\n    /// Convert an `Ipv4Addr` into a host byte order `u32`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::new(13, 12, 11, 10);\n    /// assert_eq!(0x0d0c0b0au32, u32::from(addr));\n    /// ```\n    fn from(ip: Ipv4Addr) -> u32 {\n        let ip = ip.octets();\n        ((ip[0] as u32) << 24) + ((ip[1] as u32) << 16) + ((ip[2] as u32) << 8) + (ip[3] as u32)\n    }\n}\n\n#[stable(feature = \"ip_u32\", since = \"1.1.0\")]\nimpl From<u32> for Ipv4Addr {\n    /// Convert a host byte order `u32` into an `Ipv4Addr`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::from(0x0d0c0b0au32);\n    /// assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);\n    /// ```\n    fn from(ip: u32) -> Ipv4Addr {\n        Ipv4Addr::new((ip >> 24) as u8, (ip >> 16) as u8, (ip >> 8) as u8, ip as u8)\n    }\n}\n\n#[stable(feature = \"from_slice_v4\", since = \"1.9.0\")]\nimpl From<[u8; 4]> for Ipv4Addr {\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv4Addr;\n    ///\n    /// let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);\n    /// assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);\n    /// ```\n    fn from(octets: [u8; 4]) -> Ipv4Addr {\n        Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3])\n    }\n}\n\n#[stable(feature = \"ip_from_slice\", since = \"1.17.0\")]\nimpl From<[u8; 4]> for IpAddr {\n    /// Create an `IpAddr::V4` from a four element byte array.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr};\n    ///\n    /// let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);\n    /// assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);\n    /// ```\n    fn from(octets: [u8; 4]) -> IpAddr {\n        IpAddr::V4(Ipv4Addr::from(octets))\n    }\n}\n\nimpl Ipv6Addr {\n    /// Creates a new IPv6 address from eight 16-bit segments.\n    ///\n    /// The result will represent the IP address a:b:c:d:e:f:g:h.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// let addr = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_const_unstable(feature = \"const_ip\")]\n    pub const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16,\n                     g: u16, h: u16) -> Ipv6Addr {\n        Ipv6Addr {\n            inner: c::in6_addr {\n                s6_addr: [\n                    (a >> 8) as u8, a as u8,\n                    (b >> 8) as u8, b as u8,\n                    (c >> 8) as u8, c as u8,\n                    (d >> 8) as u8, d as u8,\n                    (e >> 8) as u8, e as u8,\n                    (f >> 8) as u8, f as u8,\n                    (g >> 8) as u8, g as u8,\n                    (h >> 8) as u8, h as u8\n                ],\n            }\n        }\n\n    }\n\n    /// An IPv6 address representing localhost: `::1`.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// let addr = Ipv6Addr::LOCALHOST;\n    /// assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));\n    /// ```\n    #[stable(feature = \"ip_constructors\", since = \"1.30.0\")]\n    pub const LOCALHOST: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1);\n\n    /// An IPv6 address representing the unspecified address: `::`\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// let addr = Ipv6Addr::UNSPECIFIED;\n    /// assert_eq!(addr, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));\n    /// ```\n    #[stable(feature = \"ip_constructors\", since = \"1.30.0\")]\n    pub const UNSPECIFIED: Self = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0);\n\n    /// Returns the eight 16-bit segments that make up this address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).segments(),\n    ///            [0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff]);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn segments(&self) -> [u16; 8] {\n        let arr = &self.inner.s6_addr;\n        [\n            (arr[0] as u16) << 8 | (arr[1] as u16),\n            (arr[2] as u16) << 8 | (arr[3] as u16),\n            (arr[4] as u16) << 8 | (arr[5] as u16),\n            (arr[6] as u16) << 8 | (arr[7] as u16),\n            (arr[8] as u16) << 8 | (arr[9] as u16),\n            (arr[10] as u16) << 8 | (arr[11] as u16),\n            (arr[12] as u16) << 8 | (arr[13] as u16),\n            (arr[14] as u16) << 8 | (arr[15] as u16),\n        ]\n    }\n\n    /// Returns [`true`] for the special 'unspecified' address (::).\n    ///\n    /// This property is defined in [IETF RFC 4291].\n    ///\n    /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unspecified(), false);\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).is_unspecified(), true);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_unspecified(&self) -> bool {\n        self.segments() == [0, 0, 0, 0, 0, 0, 0, 0]\n    }\n\n    /// Returns [`true`] if this is a loopback address (::1).\n    ///\n    /// This property is defined in [IETF RFC 4291].\n    ///\n    /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_loopback(), false);\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_loopback(), true);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_loopback(&self) -> bool {\n        self.segments() == [0, 0, 0, 0, 0, 0, 0, 1]\n    }\n\n    /// Returns [`true`] if the address appears to be globally routable.\n    ///\n    /// The following return [`false`]:\n    ///\n    /// - the loopback address\n    /// - link-local, site-local, and unique local unicast addresses\n    /// - interface-, link-, realm-, admin- and site-local multicast addresses\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    /// [`false`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_global(), true);\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0x1).is_global(), false);\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0x1c9, 0, 0, 0xafc8, 0, 0x1).is_global(), true);\n    /// }\n    /// ```\n    pub fn is_global(&self) -> bool {\n        match self.multicast_scope() {\n            Some(Ipv6MulticastScope::Global) => true,\n            None => self.is_unicast_global(),\n            _ => false\n        }\n    }\n\n    /// Returns [`true`] if this is a unique local address (fc00::/7).\n    ///\n    /// This property is defined in [IETF RFC 4193].\n    ///\n    /// [IETF RFC 4193]: https://tools.ietf.org/html/rfc4193\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unique_local(),\n    ///                false);\n    ///     assert_eq!(Ipv6Addr::new(0xfc02, 0, 0, 0, 0, 0, 0, 0).is_unique_local(), true);\n    /// }\n    /// ```\n    pub fn is_unique_local(&self) -> bool {\n        (self.segments()[0] & 0xfe00) == 0xfc00\n    }\n\n    /// Returns [`true`] if the address is unicast and link-local (fe80::/10).\n    ///\n    /// This property is defined in [IETF RFC 4291].\n    ///\n    /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_link_local(),\n    ///                false);\n    ///     assert_eq!(Ipv6Addr::new(0xfe8a, 0, 0, 0, 0, 0, 0, 0).is_unicast_link_local(), true);\n    /// }\n    /// ```\n    pub fn is_unicast_link_local(&self) -> bool {\n        (self.segments()[0] & 0xffc0) == 0xfe80\n    }\n\n    /// Returns [`true`] if this is a deprecated unicast site-local address\n    /// (fec0::/10).\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_site_local(),\n    ///                false);\n    ///     assert_eq!(Ipv6Addr::new(0xfec2, 0, 0, 0, 0, 0, 0, 0).is_unicast_site_local(), true);\n    /// }\n    /// ```\n    pub fn is_unicast_site_local(&self) -> bool {\n        (self.segments()[0] & 0xffc0) == 0xfec0\n    }\n\n    /// Returns [`true`] if this is an address reserved for documentation\n    /// (2001:db8::/32).\n    ///\n    /// This property is defined in [IETF RFC 3849].\n    ///\n    /// [IETF RFC 3849]: https://tools.ietf.org/html/rfc3849\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_documentation(),\n    ///                false);\n    ///     assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_documentation(), true);\n    /// }\n    /// ```\n    pub fn is_documentation(&self) -> bool {\n        (self.segments()[0] == 0x2001) && (self.segments()[1] == 0xdb8)\n    }\n\n    /// Returns [`true`] if the address is a globally routable unicast address.\n    ///\n    /// The following return false:\n    ///\n    /// - the loopback address\n    /// - the link-local addresses\n    /// - the (deprecated) site-local addresses\n    /// - unique local addresses\n    /// - the unspecified address\n    /// - the address range reserved for documentation\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::Ipv6Addr;\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 0).is_unicast_global(), false);\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_unicast_global(),\n    ///                true);\n    /// }\n    /// ```\n    pub fn is_unicast_global(&self) -> bool {\n        !self.is_multicast()\n            && !self.is_loopback() && !self.is_unicast_link_local()\n            && !self.is_unicast_site_local() && !self.is_unique_local()\n            && !self.is_unspecified() && !self.is_documentation()\n    }\n\n    /// Returns the address's multicast scope if the address is multicast.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// #![feature(ip)]\n    ///\n    /// use std::net::{Ipv6Addr, Ipv6MulticastScope};\n    ///\n    /// fn main() {\n    ///     assert_eq!(Ipv6Addr::new(0xff0e, 0, 0, 0, 0, 0, 0, 0).multicast_scope(),\n    ///                              Some(Ipv6MulticastScope::Global));\n    ///     assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).multicast_scope(), None);\n    /// }\n    /// ```\n    pub fn multicast_scope(&self) -> Option<Ipv6MulticastScope> {\n        if self.is_multicast() {\n            match self.segments()[0] & 0x000f {\n                1 => Some(Ipv6MulticastScope::InterfaceLocal),\n                2 => Some(Ipv6MulticastScope::LinkLocal),\n                3 => Some(Ipv6MulticastScope::RealmLocal),\n                4 => Some(Ipv6MulticastScope::AdminLocal),\n                5 => Some(Ipv6MulticastScope::SiteLocal),\n                8 => Some(Ipv6MulticastScope::OrganizationLocal),\n                14 => Some(Ipv6MulticastScope::Global),\n                _ => None\n            }\n        } else {\n            None\n        }\n    }\n\n    /// Returns [`true`] if this is a multicast address (ff00::/8).\n    ///\n    /// This property is defined by [IETF RFC 4291].\n    ///\n    /// [IETF RFC 4291]: https://tools.ietf.org/html/rfc4291\n    /// [`true`]: ../../std/primitive.bool.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).is_multicast(), true);\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).is_multicast(), false);\n    /// ```\n    #[stable(since = \"1.7.0\", feature = \"ip_17\")]\n    pub fn is_multicast(&self) -> bool {\n        (self.segments()[0] & 0xff00) == 0xff00\n    }\n\n    /// Converts this address to an [IPv4 address]. Returns [`None`] if this address is\n    /// neither IPv4-compatible or IPv4-mapped.\n    ///\n    /// ::a.b.c.d and ::ffff:a.b.c.d become a.b.c.d\n    ///\n    /// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html\n    /// [`None`]: ../../std/option/enum.Option.html#variant.None\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{Ipv4Addr, Ipv6Addr};\n    ///\n    /// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).to_ipv4(), None);\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc00a, 0x2ff).to_ipv4(),\n    ///            Some(Ipv4Addr::new(192, 10, 2, 255)));\n    /// assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_ipv4(),\n    ///            Some(Ipv4Addr::new(0, 0, 0, 1)));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn to_ipv4(&self) -> Option<Ipv4Addr> {\n        match self.segments() {\n            [0, 0, 0, 0, 0, f, g, h] if f == 0 || f == 0xffff => {\n                Some(Ipv4Addr::new((g >> 8) as u8, g as u8,\n                                   (h >> 8) as u8, h as u8))\n            },\n            _ => None\n        }\n    }\n\n    /// Returns the sixteen eight-bit integers the IPv6 address consists of.\n    ///\n    /// ```\n    /// use std::net::Ipv6Addr;\n    ///\n    /// assert_eq!(Ipv6Addr::new(0xff00, 0, 0, 0, 0, 0, 0, 0).octets(),\n    ///            [255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);\n    /// ```\n    #[stable(feature = \"ipv6_to_octets\", since = \"1.12.0\")]\n    pub fn octets(&self) -> [u8; 16] {\n        self.inner.s6_addr\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for Ipv6Addr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        match self.segments() {\n            // We need special cases for :: and ::1, otherwise they're formatted\n            // as ::0.0.0.[01]\n            [0, 0, 0, 0, 0, 0, 0, 0] => write!(fmt, \"::\"),\n            [0, 0, 0, 0, 0, 0, 0, 1] => write!(fmt, \"::1\"),\n            // Ipv4 Compatible address\n            [0, 0, 0, 0, 0, 0, g, h] => {\n                write!(fmt, \"::{}.{}.{}.{}\", (g >> 8) as u8, g as u8,\n                       (h >> 8) as u8, h as u8)\n            }\n            // Ipv4-Mapped address\n            [0, 0, 0, 0, 0, 0xffff, g, h] => {\n                write!(fmt, \"::ffff:{}.{}.{}.{}\", (g >> 8) as u8, g as u8,\n                       (h >> 8) as u8, h as u8)\n            },\n            _ => {\n                fn find_zero_slice(segments: &[u16; 8]) -> (usize, usize) {\n                    let mut longest_span_len = 0;\n                    let mut longest_span_at = 0;\n                    let mut cur_span_len = 0;\n                    let mut cur_span_at = 0;\n\n                    for i in 0..8 {\n                        if segments[i] == 0 {\n                            if cur_span_len == 0 {\n                                cur_span_at = i;\n                            }\n\n                            cur_span_len += 1;\n\n                            if cur_span_len > longest_span_len {\n                                longest_span_len = cur_span_len;\n                                longest_span_at = cur_span_at;\n                            }\n                        } else {\n                            cur_span_len = 0;\n                            cur_span_at = 0;\n                        }\n                    }\n\n                    (longest_span_at, longest_span_len)\n                }\n\n                let (zeros_at, zeros_len) = find_zero_slice(&self.segments());\n\n                if zeros_len > 1 {\n                    fn fmt_subslice(segments: &[u16], fmt: &mut fmt::Formatter) -> fmt::Result {\n                        if !segments.is_empty() {\n                            write!(fmt, \"{:x}\", segments[0])?;\n                            for &seg in &segments[1..] {\n                                write!(fmt, \":{:x}\", seg)?;\n                            }\n                        }\n                        Ok(())\n                    }\n\n                    fmt_subslice(&self.segments()[..zeros_at], fmt)?;\n                    fmt.write_str(\"::\")?;\n                    fmt_subslice(&self.segments()[zeros_at + zeros_len..], fmt)\n                } else {\n                    let &[a, b, c, d, e, f, g, h] = &self.segments();\n                    write!(fmt, \"{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}:{:x}\",\n                           a, b, c, d, e, f, g, h)\n                }\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for Ipv6Addr {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self, fmt)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Clone for Ipv6Addr {\n    fn clone(&self) -> Ipv6Addr { *self }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for Ipv6Addr {\n    fn eq(&self, other: &Ipv6Addr) -> bool {\n        self.inner.s6_addr == other.inner.s6_addr\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialEq<IpAddr> for Ipv6Addr {\n    fn eq(&self, other: &IpAddr) -> bool {\n        match other {\n            IpAddr::V4(_) => false,\n            IpAddr::V6(v6) => self == v6,\n        }\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialEq<Ipv6Addr> for IpAddr {\n    fn eq(&self, other: &Ipv6Addr) -> bool {\n        match self {\n            IpAddr::V4(_) => false,\n            IpAddr::V6(v6) => v6 == other,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for Ipv6Addr {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl hash::Hash for Ipv6Addr {\n    fn hash<H: hash::Hasher>(&self, s: &mut H) {\n        self.inner.s6_addr.hash(s)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialOrd for Ipv6Addr {\n    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {\n        Some(self.cmp(other))\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialOrd<Ipv6Addr> for IpAddr {\n    fn partial_cmp(&self, other: &Ipv6Addr) -> Option<Ordering> {\n        match self {\n            IpAddr::V4(_) => Some(Ordering::Less),\n            IpAddr::V6(v6) => v6.partial_cmp(other),\n        }\n    }\n}\n\n#[stable(feature = \"ip_cmp\", since = \"1.16.0\")]\nimpl PartialOrd<IpAddr> for Ipv6Addr {\n    fn partial_cmp(&self, other: &IpAddr) -> Option<Ordering> {\n        match other {\n            IpAddr::V4(_) => Some(Ordering::Greater),\n            IpAddr::V6(v6) => self.partial_cmp(v6),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Ord for Ipv6Addr {\n    fn cmp(&self, other: &Ipv6Addr) -> Ordering {\n        self.segments().cmp(&other.segments())\n    }\n}\n\nimpl AsInner<c::in6_addr> for Ipv6Addr {\n    fn as_inner(&self) -> &c::in6_addr { &self.inner }\n}\nimpl FromInner<c::in6_addr> for Ipv6Addr {\n    fn from_inner(addr: c::in6_addr) -> Ipv6Addr {\n        Ipv6Addr { inner: addr }\n    }\n}\n\n#[stable(feature = \"i128\", since = \"1.26.0\")]\nimpl From<Ipv6Addr> for u128 {\n    fn from(ip: Ipv6Addr) -> u128 {\n        let ip = ip.segments();\n        ((ip[0] as u128) << 112) + ((ip[1] as u128) << 96) + ((ip[2] as u128) << 80) +\n            ((ip[3] as u128) << 64) + ((ip[4] as u128) << 48) + ((ip[5] as u128) << 32) +\n            ((ip[6] as u128) << 16) + (ip[7] as u128)\n    }\n}\n#[stable(feature = \"i128\", since = \"1.26.0\")]\nimpl From<u128> for Ipv6Addr {\n    fn from(ip: u128) -> Ipv6Addr {\n        Ipv6Addr::new(\n            (ip >> 112) as u16, (ip >> 96) as u16, (ip >> 80) as u16,\n            (ip >> 64) as u16, (ip >> 48) as u16, (ip >> 32) as u16,\n            (ip >> 16) as u16, ip as u16,\n        )\n    }\n}\n\n#[stable(feature = \"ipv6_from_octets\", since = \"1.9.0\")]\nimpl From<[u8; 16]> for Ipv6Addr {\n    fn from(octets: [u8; 16]) -> Ipv6Addr {\n        let inner = c::in6_addr { s6_addr: octets };\n        Ipv6Addr::from_inner(inner)\n    }\n}\n\n#[stable(feature = \"ipv6_from_segments\", since = \"1.16.0\")]\nimpl From<[u16; 8]> for Ipv6Addr {\n    fn from(segments: [u16; 8]) -> Ipv6Addr {\n        let [a, b, c, d, e, f, g, h] = segments;\n        Ipv6Addr::new(a, b, c, d, e, f, g, h)\n    }\n}\n\n\n#[stable(feature = \"ip_from_slice\", since = \"1.17.0\")]\nimpl From<[u8; 16]> for IpAddr {\n    /// Create an `IpAddr::V6` from a sixteen element byte array.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv6Addr};\n    ///\n    /// let addr = IpAddr::from([\n    ///     25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,\n    ///     17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,\n    /// ]);\n    /// assert_eq!(\n    ///     IpAddr::V6(Ipv6Addr::new(\n    ///         0x1918, 0x1716,\n    ///         0x1514, 0x1312,\n    ///         0x1110, 0x0f0e,\n    ///         0x0d0c, 0x0b0a\n    ///     )),\n    ///     addr\n    /// );\n    /// ```\n    fn from(octets: [u8; 16]) -> IpAddr {\n        IpAddr::V6(Ipv6Addr::from(octets))\n    }\n}\n\n#[stable(feature = \"ip_from_slice\", since = \"1.17.0\")]\nimpl From<[u16; 8]> for IpAddr {\n    /// Create an `IpAddr::V6` from an eight element 16-bit array.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv6Addr};\n    ///\n    /// let addr = IpAddr::from([\n    ///     525u16, 524u16, 523u16, 522u16,\n    ///     521u16, 520u16, 519u16, 518u16,\n    /// ]);\n    /// assert_eq!(\n    ///     IpAddr::V6(Ipv6Addr::new(\n    ///         0x20d, 0x20c,\n    ///         0x20b, 0x20a,\n    ///         0x209, 0x208,\n    ///         0x207, 0x206\n    ///     )),\n    ///     addr\n    /// );\n    /// ```\n    fn from(segments: [u16; 8]) -> IpAddr {\n        IpAddr::V6(Ipv6Addr::from(segments))\n    }\n}\n\n// Tests for this module\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use net::*;\n    use net::Ipv6MulticastScope::*;\n    use net::test::{tsa, sa6, sa4};\n\n    #[test]\n    fn test_from_str_ipv4() {\n        assert_eq!(Ok(Ipv4Addr::new(127, 0, 0, 1)), \"127.0.0.1\".parse());\n        assert_eq!(Ok(Ipv4Addr::new(255, 255, 255, 255)), \"255.255.255.255\".parse());\n        assert_eq!(Ok(Ipv4Addr::new(0, 0, 0, 0)), \"0.0.0.0\".parse());\n\n        // out of range\n        let none: Option<Ipv4Addr> = \"256.0.0.1\".parse().ok();\n        assert_eq!(None, none);\n        // too short\n        let none: Option<Ipv4Addr> = \"255.0.0\".parse().ok();\n        assert_eq!(None, none);\n        // too long\n        let none: Option<Ipv4Addr> = \"255.0.0.1.2\".parse().ok();\n        assert_eq!(None, none);\n        // no number between dots\n        let none: Option<Ipv4Addr> = \"255.0..1\".parse().ok();\n        assert_eq!(None, none);\n    }\n\n    #[test]\n    fn test_from_str_ipv6() {\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)), \"0:0:0:0:0:0:0:0\".parse());\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), \"0:0:0:0:0:0:0:1\".parse());\n\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)), \"::1\".parse());\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0)), \"::\".parse());\n\n        assert_eq!(Ok(Ipv6Addr::new(0x2a02, 0x6b8, 0, 0, 0, 0, 0x11, 0x11)),\n                \"2a02:6b8::11:11\".parse());\n\n        // too long group\n        let none: Option<Ipv6Addr> = \"::00000\".parse().ok();\n        assert_eq!(None, none);\n        // too short\n        let none: Option<Ipv6Addr> = \"1:2:3:4:5:6:7\".parse().ok();\n        assert_eq!(None, none);\n        // too long\n        let none: Option<Ipv6Addr> = \"1:2:3:4:5:6:7:8:9\".parse().ok();\n        assert_eq!(None, none);\n        // triple colon\n        let none: Option<Ipv6Addr> = \"1:2:::6:7:8\".parse().ok();\n        assert_eq!(None, none);\n        // two double colons\n        let none: Option<Ipv6Addr> = \"1:2::6::8\".parse().ok();\n        assert_eq!(None, none);\n        // `::` indicating zero groups of zeros\n        let none: Option<Ipv6Addr> = \"1:2:3:4::5:6:7:8\".parse().ok();\n        assert_eq!(None, none);\n    }\n\n    #[test]\n    fn test_from_str_ipv4_in_ipv6() {\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 49152, 545)),\n                \"::192.0.2.33\".parse());\n        assert_eq!(Ok(Ipv6Addr::new(0, 0, 0, 0, 0, 0xFFFF, 49152, 545)),\n                \"::FFFF:192.0.2.33\".parse());\n        assert_eq!(Ok(Ipv6Addr::new(0x64, 0xff9b, 0, 0, 0, 0, 49152, 545)),\n                \"64:ff9b::192.0.2.33\".parse());\n        assert_eq!(Ok(Ipv6Addr::new(0x2001, 0xdb8, 0x122, 0xc000, 0x2, 0x2100, 49152, 545)),\n                \"2001:db8:122:c000:2:2100:192.0.2.33\".parse());\n\n        // colon after v4\n        let none: Option<Ipv4Addr> = \"::127.0.0.1:\".parse().ok();\n        assert_eq!(None, none);\n        // not enough groups\n        let none: Option<Ipv6Addr> = \"1.2.3.4.5:127.0.0.1\".parse().ok();\n        assert_eq!(None, none);\n        // too many groups\n        let none: Option<Ipv6Addr> = \"1.2.3.4.5:6:7:127.0.0.1\".parse().ok();\n        assert_eq!(None, none);\n    }\n\n    #[test]\n    fn test_from_str_socket_addr() {\n        assert_eq!(Ok(sa4(Ipv4Addr::new(77, 88, 21, 11), 80)),\n                   \"77.88.21.11:80\".parse());\n        assert_eq!(Ok(SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80)),\n                   \"77.88.21.11:80\".parse());\n        assert_eq!(Ok(sa6(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53)),\n                   \"[2a02:6b8:0:1::1]:53\".parse());\n        assert_eq!(Ok(SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1,\n                                                      0, 0, 0, 1), 53, 0, 0)),\n                   \"[2a02:6b8:0:1::1]:53\".parse());\n        assert_eq!(Ok(sa6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0x7F00, 1), 22)),\n                   \"[::127.0.0.1]:22\".parse());\n        assert_eq!(Ok(SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0,\n                                                      0x7F00, 1), 22, 0, 0)),\n                   \"[::127.0.0.1]:22\".parse());\n\n        // without port\n        let none: Option<SocketAddr> = \"127.0.0.1\".parse().ok();\n        assert_eq!(None, none);\n        // without port\n        let none: Option<SocketAddr> = \"127.0.0.1:\".parse().ok();\n        assert_eq!(None, none);\n        // wrong brackets around v4\n        let none: Option<SocketAddr> = \"[127.0.0.1]:22\".parse().ok();\n        assert_eq!(None, none);\n        // port out of range\n        let none: Option<SocketAddr> = \"127.0.0.1:123456\".parse().ok();\n        assert_eq!(None, none);\n    }\n\n    #[test]\n    fn ipv6_addr_to_string() {\n        // ipv4-mapped address\n        let a1 = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x280);\n        assert_eq!(a1.to_string(), \"::ffff:192.0.2.128\");\n\n        // ipv4-compatible address\n        let a1 = Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0xc000, 0x280);\n        assert_eq!(a1.to_string(), \"::192.0.2.128\");\n\n        // v6 address with no zero segments\n        assert_eq!(Ipv6Addr::new(8, 9, 10, 11, 12, 13, 14, 15).to_string(),\n                   \"8:9:a:b:c:d:e:f\");\n\n        // reduce a single run of zeros\n        assert_eq!(\"ae::ffff:102:304\",\n                   Ipv6Addr::new(0xae, 0, 0, 0, 0, 0xffff, 0x0102, 0x0304).to_string());\n\n        // don't reduce just a single zero segment\n        assert_eq!(\"1:2:3:4:5:6:0:8\",\n                   Ipv6Addr::new(1, 2, 3, 4, 5, 6, 0, 8).to_string());\n\n        // 'any' address\n        assert_eq!(\"::\", Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0).to_string());\n\n        // loopback address\n        assert_eq!(\"::1\", Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).to_string());\n\n        // ends in zeros\n        assert_eq!(\"1::\", Ipv6Addr::new(1, 0, 0, 0, 0, 0, 0, 0).to_string());\n\n        // two runs of zeros, second one is longer\n        assert_eq!(\"1:0:0:4::8\", Ipv6Addr::new(1, 0, 0, 4, 0, 0, 0, 8).to_string());\n\n        // two runs of zeros, equal length\n        assert_eq!(\"1::4:5:0:0:8\", Ipv6Addr::new(1, 0, 0, 4, 5, 0, 0, 8).to_string());\n    }\n\n    #[test]\n    fn ipv4_to_ipv6() {\n        assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x1234, 0x5678),\n                   Ipv4Addr::new(0x12, 0x34, 0x56, 0x78).to_ipv6_mapped());\n        assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0x1234, 0x5678),\n                   Ipv4Addr::new(0x12, 0x34, 0x56, 0x78).to_ipv6_compatible());\n    }\n\n    #[test]\n    fn ipv6_to_ipv4() {\n        assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x1234, 0x5678).to_ipv4(),\n                   Some(Ipv4Addr::new(0x12, 0x34, 0x56, 0x78)));\n        assert_eq!(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0x1234, 0x5678).to_ipv4(),\n                   Some(Ipv4Addr::new(0x12, 0x34, 0x56, 0x78)));\n        assert_eq!(Ipv6Addr::new(0, 0, 1, 0, 0, 0, 0x1234, 0x5678).to_ipv4(),\n                   None);\n    }\n\n    #[test]\n    fn ip_properties() {\n        fn check4(octets: &[u8; 4], unspec: bool, loopback: bool,\n                  global: bool, multicast: bool, documentation: bool) {\n            let ip = IpAddr::V4(Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3]));\n            assert_eq!(ip.is_unspecified(), unspec);\n            assert_eq!(ip.is_loopback(), loopback);\n            assert_eq!(ip.is_global(), global);\n            assert_eq!(ip.is_multicast(), multicast);\n            assert_eq!(ip.is_documentation(), documentation);\n        }\n\n        fn check6(str_addr: &str, unspec: bool, loopback: bool,\n                  global: bool, u_doc: bool, mcast: bool) {\n            let ip = IpAddr::V6(str_addr.parse().unwrap());\n            assert_eq!(ip.is_unspecified(), unspec);\n            assert_eq!(ip.is_loopback(), loopback);\n            assert_eq!(ip.is_global(), global);\n            assert_eq!(ip.is_documentation(), u_doc);\n            assert_eq!(ip.is_multicast(), mcast);\n        }\n\n        //     address                unspec loopbk global multicast doc\n        check4(&[0, 0, 0, 0],         true,  false, false,  false,   false);\n        check4(&[0, 0, 0, 1],         false, false, true,   false,   false);\n        check4(&[0, 1, 0, 0],         false, false, true,   false,   false);\n        check4(&[10, 9, 8, 7],        false, false, false,  false,   false);\n        check4(&[127, 1, 2, 3],       false, true,  false,  false,   false);\n        check4(&[172, 31, 254, 253],  false, false, false,  false,   false);\n        check4(&[169, 254, 253, 242], false, false, false,  false,   false);\n        check4(&[192, 0, 2, 183],     false, false, false,  false,   true);\n        check4(&[192, 1, 2, 183],     false, false, true,   false,   false);\n        check4(&[192, 168, 254, 253], false, false, false,  false,   false);\n        check4(&[198, 51, 100, 0],    false, false, false,  false,   true);\n        check4(&[203, 0, 113, 0],     false, false, false,  false,   true);\n        check4(&[203, 2, 113, 0],     false, false, true,   false,   false);\n        check4(&[224, 0, 0, 0],       false, false, true,   true,    false);\n        check4(&[239, 255, 255, 255], false, false, true,   true,    false);\n        check4(&[255, 255, 255, 255], false, false, false,  false,   false);\n\n        //     address                            unspec loopbk global doc    mcast\n        check6(\"::\",                              true,  false, false, false, false);\n        check6(\"::1\",                             false, true,  false, false, false);\n        check6(\"::0.0.0.2\",                       false, false, true,  false, false);\n        check6(\"1::\",                             false, false, true,  false, false);\n        check6(\"fc00::\",                          false, false, false, false, false);\n        check6(\"fdff:ffff::\",                     false, false, false, false, false);\n        check6(\"fe80:ffff::\",                     false, false, false, false, false);\n        check6(\"febf:ffff::\",                     false, false, false, false, false);\n        check6(\"fec0::\",                          false, false, false, false, false);\n        check6(\"ff01::\",                          false, false, false, false, true);\n        check6(\"ff02::\",                          false, false, false, false, true);\n        check6(\"ff03::\",                          false, false, false, false, true);\n        check6(\"ff04::\",                          false, false, false, false, true);\n        check6(\"ff05::\",                          false, false, false, false, true);\n        check6(\"ff08::\",                          false, false, false, false, true);\n        check6(\"ff0e::\",                          false, false, true,  false, true);\n        check6(\"2001:db8:85a3::8a2e:370:7334\",    false, false, false, true,  false);\n        check6(\"102:304:506:708:90a:b0c:d0e:f10\", false, false, true,  false, false);\n    }\n\n    #[test]\n    fn ipv4_properties() {\n        fn check(octets: &[u8; 4], unspec: bool, loopback: bool,\n                 private: bool, link_local: bool, global: bool,\n                 multicast: bool, broadcast: bool, documentation: bool) {\n            let ip = Ipv4Addr::new(octets[0], octets[1], octets[2], octets[3]);\n            assert_eq!(octets, &ip.octets());\n\n            assert_eq!(ip.is_unspecified(), unspec);\n            assert_eq!(ip.is_loopback(), loopback);\n            assert_eq!(ip.is_private(), private);\n            assert_eq!(ip.is_link_local(), link_local);\n            assert_eq!(ip.is_global(), global);\n            assert_eq!(ip.is_multicast(), multicast);\n            assert_eq!(ip.is_broadcast(), broadcast);\n            assert_eq!(ip.is_documentation(), documentation);\n        }\n\n        //    address                unspec loopbk privt  linloc global multicast brdcast doc\n        check(&[0, 0, 0, 0],         true,  false, false, false, false,  false,    false,  false);\n        check(&[0, 0, 0, 1],         false, false, false, false, true,   false,    false,  false);\n        check(&[0, 1, 0, 0],         false, false, false, false, true,   false,    false,  false);\n        check(&[10, 9, 8, 7],        false, false, true,  false, false,  false,    false,  false);\n        check(&[127, 1, 2, 3],       false, true,  false, false, false,  false,    false,  false);\n        check(&[172, 31, 254, 253],  false, false, true,  false, false,  false,    false,  false);\n        check(&[169, 254, 253, 242], false, false, false, true,  false,  false,    false,  false);\n        check(&[192, 0, 2, 183],     false, false, false, false, false,  false,    false,  true);\n        check(&[192, 1, 2, 183],     false, false, false, false, true,   false,    false,  false);\n        check(&[192, 168, 254, 253], false, false, true,  false, false,  false,    false,  false);\n        check(&[198, 51, 100, 0],    false, false, false, false, false,  false,    false,  true);\n        check(&[203, 0, 113, 0],     false, false, false, false, false,  false,    false,  true);\n        check(&[203, 2, 113, 0],     false, false, false, false, true,   false,    false,  false);\n        check(&[224, 0, 0, 0],       false, false, false, false, true,   true,     false,  false);\n        check(&[239, 255, 255, 255], false, false, false, false, true,   true,     false,  false);\n        check(&[255, 255, 255, 255], false, false, false, false, false,  false,    true,   false);\n    }\n\n    #[test]\n    fn ipv6_properties() {\n        fn check(str_addr: &str, octets: &[u8; 16], unspec: bool, loopback: bool,\n                 unique_local: bool, global: bool,\n                 u_link_local: bool, u_site_local: bool, u_global: bool, u_doc: bool,\n                 m_scope: Option<Ipv6MulticastScope>) {\n            let ip: Ipv6Addr = str_addr.parse().unwrap();\n            assert_eq!(str_addr, ip.to_string());\n            assert_eq!(&ip.octets(), octets);\n            assert_eq!(Ipv6Addr::from(*octets), ip);\n\n            assert_eq!(ip.is_unspecified(), unspec);\n            assert_eq!(ip.is_loopback(), loopback);\n            assert_eq!(ip.is_unique_local(), unique_local);\n            assert_eq!(ip.is_global(), global);\n            assert_eq!(ip.is_unicast_link_local(), u_link_local);\n            assert_eq!(ip.is_unicast_site_local(), u_site_local);\n            assert_eq!(ip.is_unicast_global(), u_global);\n            assert_eq!(ip.is_documentation(), u_doc);\n            assert_eq!(ip.multicast_scope(), m_scope);\n            assert_eq!(ip.is_multicast(), m_scope.is_some());\n        }\n\n        //    unspec loopbk uniqlo global unill  unisl  uniglo doc    mscope\n        check(\"::\", &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              true,  false, false, false, false, false, false, false, None);\n        check(\"::1\", &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],\n              false, true,  false, false, false, false, false, false, None);\n        check(\"::0.0.0.2\", &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2],\n              false, false, false, true,  false, false, true,  false, None);\n        check(\"1::\", &[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, true,  false, false, true,  false, None);\n        check(\"fc00::\", &[0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, true,  false, false, false, false, false, None);\n        check(\"fdff:ffff::\", &[0xfd, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, true,  false, false, false, false, false, None);\n        check(\"fe80:ffff::\", &[0xfe, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, true,  false, false, false, None);\n        check(\"febf:ffff::\", &[0xfe, 0xbf, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, true,  false, false, false, None);\n        check(\"fec0::\", &[0xfe, 0xc0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, true,  false, false, None);\n        check(\"ff01::\", &[0xff, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(InterfaceLocal));\n        check(\"ff02::\", &[0xff, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(LinkLocal));\n        check(\"ff03::\", &[0xff, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(RealmLocal));\n        check(\"ff04::\", &[0xff, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(AdminLocal));\n        check(\"ff05::\", &[0xff, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(SiteLocal));\n        check(\"ff08::\", &[0xff, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, false, false, false, false, false, Some(OrganizationLocal));\n        check(\"ff0e::\", &[0xff, 0xe, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n              false, false, false, true,  false, false, false, false, Some(Global));\n        check(\"2001:db8:85a3::8a2e:370:7334\",\n              &[0x20, 1, 0xd, 0xb8, 0x85, 0xa3, 0, 0, 0, 0, 0x8a, 0x2e, 3, 0x70, 0x73, 0x34],\n              false, false, false, false, false, false, false, true, None);\n        check(\"102:304:506:708:90a:b0c:d0e:f10\",\n              &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16],\n              false, false, false, true,  false, false, true,  false, None);\n    }\n\n    #[test]\n    fn to_socket_addr_socketaddr() {\n        let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 12345);\n        assert_eq!(Ok(vec![a]), tsa(a));\n    }\n\n    #[test]\n    fn test_ipv4_to_int() {\n        let a = Ipv4Addr::new(0x11, 0x22, 0x33, 0x44);\n        assert_eq!(u32::from(a), 0x11223344);\n    }\n\n    #[test]\n    fn test_int_to_ipv4() {\n        let a = Ipv4Addr::new(0x11, 0x22, 0x33, 0x44);\n        assert_eq!(Ipv4Addr::from(0x11223344), a);\n    }\n\n    #[test]\n    fn test_ipv6_to_int() {\n        let a = Ipv6Addr::new(0x1122, 0x3344, 0x5566, 0x7788, 0x99aa, 0xbbcc, 0xddee, 0xff11);\n        assert_eq!(u128::from(a), 0x112233445566778899aabbccddeeff11u128);\n    }\n\n    #[test]\n    fn test_int_to_ipv6() {\n        let a = Ipv6Addr::new(0x1122, 0x3344, 0x5566, 0x7788, 0x99aa, 0xbbcc, 0xddee, 0xff11);\n        assert_eq!(Ipv6Addr::from(0x112233445566778899aabbccddeeff11u128), a);\n    }\n\n    #[test]\n    fn ipv4_from_constructors() {\n        assert_eq!(Ipv4Addr::LOCALHOST, Ipv4Addr::new(127, 0, 0, 1));\n        assert!(Ipv4Addr::LOCALHOST.is_loopback());\n        assert_eq!(Ipv4Addr::UNSPECIFIED, Ipv4Addr::new(0, 0, 0, 0));\n        assert!(Ipv4Addr::UNSPECIFIED.is_unspecified());\n        assert_eq!(Ipv4Addr::BROADCAST, Ipv4Addr::new(255, 255, 255, 255));\n        assert!(Ipv4Addr::BROADCAST.is_broadcast());\n    }\n\n    #[test]\n    fn ipv6_from_contructors() {\n        assert_eq!(Ipv6Addr::LOCALHOST, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));\n        assert!(Ipv6Addr::LOCALHOST.is_loopback());\n        assert_eq!(Ipv6Addr::UNSPECIFIED, Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 0));\n        assert!(Ipv6Addr::UNSPECIFIED.is_unspecified());\n    }\n\n    #[test]\n    fn ipv4_from_octets() {\n        assert_eq!(Ipv4Addr::from([127, 0, 0, 1]), Ipv4Addr::new(127, 0, 0, 1))\n    }\n\n    #[test]\n    fn ipv6_from_segments() {\n        let from_u16s = Ipv6Addr::from([0x0011, 0x2233, 0x4455, 0x6677,\n                                        0x8899, 0xaabb, 0xccdd, 0xeeff]);\n        let new = Ipv6Addr::new(0x0011, 0x2233, 0x4455, 0x6677,\n                                0x8899, 0xaabb, 0xccdd, 0xeeff);\n        assert_eq!(new, from_u16s);\n    }\n\n    #[test]\n    fn ipv6_from_octets() {\n        let from_u16s = Ipv6Addr::from([0x0011, 0x2233, 0x4455, 0x6677,\n                                        0x8899, 0xaabb, 0xccdd, 0xeeff]);\n        let from_u8s = Ipv6Addr::from([0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,\n                                       0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]);\n        assert_eq!(from_u16s, from_u8s);\n    }\n\n    #[test]\n    fn cmp() {\n        let v41 = Ipv4Addr::new(100, 64, 3, 3);\n        let v42 = Ipv4Addr::new(192, 0, 2, 2);\n        let v61 = \"2001:db8:f00::1002\".parse::<Ipv6Addr>().unwrap();\n        let v62 = \"2001:db8:f00::2001\".parse::<Ipv6Addr>().unwrap();\n        assert!(v41 < v42);\n        assert!(v61 < v62);\n\n        assert_eq!(v41, IpAddr::V4(v41));\n        assert_eq!(v61, IpAddr::V6(v61));\n        assert!(v41 != IpAddr::V4(v42));\n        assert!(v61 != IpAddr::V6(v62));\n\n        assert!(v41 < IpAddr::V4(v42));\n        assert!(v61 < IpAddr::V6(v62));\n        assert!(IpAddr::V4(v41) < v42);\n        assert!(IpAddr::V6(v61) < v62);\n\n        assert!(v41 < IpAddr::V6(v61));\n        assert!(IpAddr::V4(v41) < v61);\n    }\n\n    #[test]\n    fn is_v4() {\n        let ip = IpAddr::V4(Ipv4Addr::new(100, 64, 3, 3));\n        assert!(ip.is_ipv4());\n        assert!(!ip.is_ipv6());\n    }\n\n    #[test]\n    fn is_v6() {\n        let ip = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0x1234, 0x5678));\n        assert!(!ip.is_ipv4());\n        assert!(ip.is_ipv6());\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt;\nuse hash;\nuse io;\nuse mem;\nuse net::{ntoh, hton, IpAddr, Ipv4Addr, Ipv6Addr};\nuse option;\nuse sys::net::netc as c;\nuse sys_common::{FromInner, AsInner, IntoInner};\nuse sys_common::net::lookup_host;\nuse vec;\nuse iter;\nuse slice;\n\n/// An internet socket address, either IPv4 or IPv6.\n///\n/// Internet socket addresses consist of an [IP address], a 16-bit port number, as well\n/// as possibly some version-dependent additional information. See [`SocketAddrV4`]'s and\n/// [`SocketAddrV6`]'s respective documentation for more details.\n///\n/// The size of a `SocketAddr` instance may vary depending on the target operating\n/// system.\n///\n/// [IP address]: ../../std/net/enum.IpAddr.html\n/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html\n/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html\n///\n/// # Examples\n///\n/// ```\n/// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n///\n/// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n///\n/// assert_eq!(\"127.0.0.1:8080\".parse(), Ok(socket));\n/// assert_eq!(socket.port(), 8080);\n/// assert_eq!(socket.is_ipv4(), true);\n/// ```\n#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum SocketAddr {\n    /// An IPv4 socket address.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    V4(#[stable(feature = \"rust1\", since = \"1.0.0\")] SocketAddrV4),\n    /// An IPv6 socket address.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    V6(#[stable(feature = \"rust1\", since = \"1.0.0\")] SocketAddrV6),\n}\n\n/// An IPv4 socket address.\n///\n/// IPv4 socket addresses consist of an [IPv4 address] and a 16-bit port number, as\n/// stated in [IETF RFC 793].\n///\n/// See [`SocketAddr`] for a type encompassing both IPv4 and IPv6 socket addresses.\n///\n/// The size of a `SocketAddrV4` struct may vary depending on the target operating\n/// system.\n///\n/// [IETF RFC 793]: https://tools.ietf.org/html/rfc793\n/// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html\n/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html\n///\n/// # Examples\n///\n/// ```\n/// use std::net::{Ipv4Addr, SocketAddrV4};\n///\n/// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n///\n/// assert_eq!(\"127.0.0.1:8080\".parse(), Ok(socket));\n/// assert_eq!(socket.ip(), &Ipv4Addr::new(127, 0, 0, 1));\n/// assert_eq!(socket.port(), 8080);\n/// ```\n#[derive(Copy)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct SocketAddrV4 { inner: c::sockaddr_in }\n\n/// An IPv6 socket address.\n///\n/// IPv6 socket addresses consist of an [Ipv6 address], a 16-bit port number, as well\n/// as fields containing the traffic class, the flow label, and a scope identifier\n/// (see [IETF RFC 2553, Section 3.3] for more details).\n///\n/// See [`SocketAddr`] for a type encompassing both IPv4 and IPv6 socket addresses.\n///\n/// The size of a `SocketAddrV6` struct may vary depending on the target operating\n/// system.\n///\n/// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3\n/// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html\n/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html\n///\n/// # Examples\n///\n/// ```\n/// use std::net::{Ipv6Addr, SocketAddrV6};\n///\n/// let socket = SocketAddrV6::new(Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n///\n/// assert_eq!(\"[2001:db8::1]:8080\".parse(), Ok(socket));\n/// assert_eq!(socket.ip(), &Ipv6Addr::new(0x2001, 0xdb8, 0, 0, 0, 0, 0, 1));\n/// assert_eq!(socket.port(), 8080);\n/// ```\n#[derive(Copy)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct SocketAddrV6 { inner: c::sockaddr_in6 }\n\nimpl SocketAddr {\n    /// Creates a new socket address from an [IP address] and a port number.\n    ///\n    /// [IP address]: ../../std/net/enum.IpAddr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    /// assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));\n    /// assert_eq!(socket.port(), 8080);\n    /// ```\n    #[stable(feature = \"ip_addr\", since = \"1.7.0\")]\n    pub fn new(ip: IpAddr, port: u16) -> SocketAddr {\n        match ip {\n            IpAddr::V4(a) => SocketAddr::V4(SocketAddrV4::new(a, port)),\n            IpAddr::V6(a) => SocketAddr::V6(SocketAddrV6::new(a, port, 0, 0)),\n        }\n    }\n\n    /// Returns the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    /// assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)));\n    /// ```\n    #[stable(feature = \"ip_addr\", since = \"1.7.0\")]\n    pub fn ip(&self) -> IpAddr {\n        match *self {\n            SocketAddr::V4(ref a) => IpAddr::V4(*a.ip()),\n            SocketAddr::V6(ref a) => IpAddr::V6(*a.ip()),\n        }\n    }\n\n    /// Changes the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    /// socket.set_ip(IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));\n    /// assert_eq!(socket.ip(), IpAddr::V4(Ipv4Addr::new(10, 10, 0, 1)));\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_ip(&mut self, new_ip: IpAddr) {\n        // `match (*self, new_ip)` would have us mutate a copy of self only to throw it away.\n        match (self, new_ip) {\n            (&mut SocketAddr::V4(ref mut a), IpAddr::V4(new_ip)) => a.set_ip(new_ip),\n            (&mut SocketAddr::V6(ref mut a), IpAddr::V6(new_ip)) => a.set_ip(new_ip),\n            (self_, new_ip) => *self_ = Self::new(new_ip, self_.port()),\n        }\n    }\n\n    /// Returns the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    /// assert_eq!(socket.port(), 8080);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn port(&self) -> u16 {\n        match *self {\n            SocketAddr::V4(ref a) => a.port(),\n            SocketAddr::V6(ref a) => a.port(),\n        }\n    }\n\n    /// Changes the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// let mut socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    /// socket.set_port(1025);\n    /// assert_eq!(socket.port(), 1025);\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_port(&mut self, new_port: u16) {\n        match *self {\n            SocketAddr::V4(ref mut a) => a.set_port(new_port),\n            SocketAddr::V6(ref mut a) => a.set_port(new_port),\n        }\n    }\n\n    /// Returns [`true`] if the [IP address] in this `SocketAddr` is an\n    /// [IPv4 address], and [`false`] otherwise.\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    /// [`false`]: ../../std/primitive.bool.html\n    /// [IP address]: ../../std/net/enum.IpAddr.html\n    /// [IPv4 address]: ../../std/net/enum.IpAddr.html#variant.V4\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv4Addr, SocketAddr};\n    ///\n    /// fn main() {\n    ///     let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);\n    ///     assert_eq!(socket.is_ipv4(), true);\n    ///     assert_eq!(socket.is_ipv6(), false);\n    /// }\n    /// ```\n    #[stable(feature = \"sockaddr_checker\", since = \"1.16.0\")]\n    pub fn is_ipv4(&self) -> bool {\n        match *self {\n            SocketAddr::V4(_) => true,\n            SocketAddr::V6(_) => false,\n        }\n    }\n\n    /// Returns [`true`] if the [IP address] in this `SocketAddr` is an\n    /// [IPv6 address], and [`false`] otherwise.\n    ///\n    /// [`true`]: ../../std/primitive.bool.html\n    /// [`false`]: ../../std/primitive.bool.html\n    /// [IP address]: ../../std/net/enum.IpAddr.html\n    /// [IPv6 address]: ../../std/net/enum.IpAddr.html#variant.V6\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{IpAddr, Ipv6Addr, SocketAddr};\n    ///\n    /// fn main() {\n    ///     let socket = SocketAddr::new(\n    ///                      IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 65535, 0, 1)), 8080);\n    ///     assert_eq!(socket.is_ipv4(), false);\n    ///     assert_eq!(socket.is_ipv6(), true);\n    /// }\n    /// ```\n    #[stable(feature = \"sockaddr_checker\", since = \"1.16.0\")]\n    pub fn is_ipv6(&self) -> bool {\n        match *self {\n            SocketAddr::V4(_) => false,\n            SocketAddr::V6(_) => true,\n        }\n    }\n}\n\nimpl SocketAddrV4 {\n    /// Creates a new socket address from an [IPv4 address] and a port number.\n    ///\n    /// [IPv4 address]: ../../std/net/struct.Ipv4Addr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV4, Ipv4Addr};\n    ///\n    /// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(ip: Ipv4Addr, port: u16) -> SocketAddrV4 {\n        SocketAddrV4 {\n            inner: c::sockaddr_in {\n                sin_family: c::AF_INET as c::sa_family_t,\n                sin_port: hton(port),\n                sin_addr: *ip.as_inner(),\n                .. unsafe { mem::zeroed() }\n            },\n        }\n    }\n\n    /// Returns the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV4, Ipv4Addr};\n    ///\n    /// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n    /// assert_eq!(socket.ip(), &Ipv4Addr::new(127, 0, 0, 1));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ip(&self) -> &Ipv4Addr {\n        unsafe {\n            &*(&self.inner.sin_addr as *const c::in_addr as *const Ipv4Addr)\n        }\n    }\n\n    /// Changes the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV4, Ipv4Addr};\n    ///\n    /// let mut socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n    /// socket.set_ip(Ipv4Addr::new(192, 168, 0, 1));\n    /// assert_eq!(socket.ip(), &Ipv4Addr::new(192, 168, 0, 1));\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_ip(&mut self, new_ip: Ipv4Addr) {\n        self.inner.sin_addr = *new_ip.as_inner()\n    }\n\n    /// Returns the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV4, Ipv4Addr};\n    ///\n    /// let socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n    /// assert_eq!(socket.port(), 8080);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn port(&self) -> u16 {\n        ntoh(self.inner.sin_port)\n    }\n\n    /// Changes the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV4, Ipv4Addr};\n    ///\n    /// let mut socket = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);\n    /// socket.set_port(4242);\n    /// assert_eq!(socket.port(), 4242);\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_port(&mut self, new_port: u16) {\n        self.inner.sin_port = hton(new_port);\n    }\n}\n\nimpl SocketAddrV6 {\n    /// Creates a new socket address from an [IPv6 address], a 16-bit port number,\n    /// and the `flowinfo` and `scope_id` fields.\n    ///\n    /// For more information on the meaning and layout of the `flowinfo` and `scope_id`\n    /// parameters, see [IETF RFC 2553, Section 3.3].\n    ///\n    /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3\n    /// [IPv6 address]: ../../std/net/struct.Ipv6Addr.html\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn new(ip: Ipv6Addr, port: u16, flowinfo: u32, scope_id: u32)\n               -> SocketAddrV6 {\n        SocketAddrV6 {\n            inner: c::sockaddr_in6 {\n                sin6_family: c::AF_INET6 as c::sa_family_t,\n                sin6_port: hton(port),\n                sin6_addr: *ip.as_inner(),\n                sin6_flowinfo: flowinfo,\n                sin6_scope_id: scope_id,\n                .. unsafe { mem::zeroed() }\n            },\n        }\n    }\n\n    /// Returns the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n    /// assert_eq!(socket.ip(), &Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn ip(&self) -> &Ipv6Addr {\n        unsafe {\n            &*(&self.inner.sin6_addr as *const c::in6_addr as *const Ipv6Addr)\n        }\n    }\n\n    /// Changes the IP address associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n    /// socket.set_ip(Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));\n    /// assert_eq!(socket.ip(), &Ipv6Addr::new(76, 45, 0, 0, 0, 0, 0, 0));\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_ip(&mut self, new_ip: Ipv6Addr) {\n        self.inner.sin6_addr = *new_ip.as_inner()\n    }\n\n    /// Returns the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n    /// assert_eq!(socket.port(), 8080);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn port(&self) -> u16 {\n        ntoh(self.inner.sin6_port)\n    }\n\n    /// Changes the port number associated with this socket address.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 0);\n    /// socket.set_port(4242);\n    /// assert_eq!(socket.port(), 4242);\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_port(&mut self, new_port: u16) {\n        self.inner.sin6_port = hton(new_port);\n    }\n\n    /// Returns the flow information associated with this address.\n    ///\n    /// This information corresponds to the `sin6_flowinfo` field in C's `netinet/in.h`,\n    /// as specified in [IETF RFC 2553, Section 3.3].\n    /// It combines information about the flow label and the traffic class as specified\n    /// in [IETF RFC 2460], respectively [Section 6] and [Section 7].\n    ///\n    /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3\n    /// [IETF RFC 2460]: https://tools.ietf.org/html/rfc2460\n    /// [Section 6]: https://tools.ietf.org/html/rfc2460#section-6\n    /// [Section 7]: https://tools.ietf.org/html/rfc2460#section-7\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);\n    /// assert_eq!(socket.flowinfo(), 10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn flowinfo(&self) -> u32 {\n        self.inner.sin6_flowinfo\n    }\n\n    /// Changes the flow information associated with this socket address.\n    ///\n    /// See the [`flowinfo`] method's documentation for more details.\n    ///\n    /// [`flowinfo`]: #method.flowinfo\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 10, 0);\n    /// socket.set_flowinfo(56);\n    /// assert_eq!(socket.flowinfo(), 56);\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_flowinfo(&mut self, new_flowinfo: u32) {\n        self.inner.sin6_flowinfo = new_flowinfo;\n    }\n\n    /// Returns the scope ID associated with this address.\n    ///\n    /// This information corresponds to the `sin6_scope_id` field in C's `netinet/in.h`,\n    /// as specified in [IETF RFC 2553, Section 3.3].\n    ///\n    /// [IETF RFC 2553, Section 3.3]: https://tools.ietf.org/html/rfc2553#section-3.3\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);\n    /// assert_eq!(socket.scope_id(), 78);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn scope_id(&self) -> u32 {\n        self.inner.sin6_scope_id\n    }\n\n    /// Change the scope ID associated with this socket address.\n    ///\n    /// See the [`scope_id`] method's documentation for more details.\n    ///\n    /// [`scope_id`]: #method.scope_id\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::net::{SocketAddrV6, Ipv6Addr};\n    ///\n    /// let mut socket = SocketAddrV6::new(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1), 8080, 0, 78);\n    /// socket.set_scope_id(42);\n    /// assert_eq!(socket.scope_id(), 42);\n    /// ```\n    #[stable(feature = \"sockaddr_setters\", since = \"1.9.0\")]\n    pub fn set_scope_id(&mut self, new_scope_id: u32) {\n        self.inner.sin6_scope_id = new_scope_id;\n    }\n}\n\nimpl FromInner<c::sockaddr_in> for SocketAddrV4 {\n    fn from_inner(addr: c::sockaddr_in) -> SocketAddrV4 {\n        SocketAddrV4 { inner: addr }\n    }\n}\n\nimpl FromInner<c::sockaddr_in6> for SocketAddrV6 {\n    fn from_inner(addr: c::sockaddr_in6) -> SocketAddrV6 {\n        SocketAddrV6 { inner: addr }\n    }\n}\n\n#[stable(feature = \"ip_from_ip\", since = \"1.16.0\")]\nimpl From<SocketAddrV4> for SocketAddr {\n    /// Converts a [`SocketAddrV4`] into a [`SocketAddr::V4`].\n    fn from(sock4: SocketAddrV4) -> SocketAddr {\n        SocketAddr::V4(sock4)\n    }\n}\n\n#[stable(feature = \"ip_from_ip\", since = \"1.16.0\")]\nimpl From<SocketAddrV6> for SocketAddr {\n    /// Converts a [`SocketAddrV6`] into a [`SocketAddr::V6`].\n    fn from(sock6: SocketAddrV6) -> SocketAddr {\n        SocketAddr::V6(sock6)\n    }\n}\n\n#[stable(feature = \"addr_from_into_ip\", since = \"1.17.0\")]\nimpl<I: Into<IpAddr>> From<(I, u16)> for SocketAddr {\n    /// Converts a tuple struct (Into<[`IpAddr`]>, `u16`) into a [`SocketAddr`].\n    ///\n    /// This conversion creates a [`SocketAddr::V4`] for a [`IpAddr::V4`]\n    /// and creates a [`SocketAddr::V6`] for a [`IpAddr::V6`].\n    ///\n    /// `u16` is treated as port of the newly created [`SocketAddr`].\n    fn from(pieces: (I, u16)) -> SocketAddr {\n        SocketAddr::new(pieces.0.into(), pieces.1)\n    }\n}\n\nimpl<'a> IntoInner<(*const c::sockaddr, c::socklen_t)> for &'a SocketAddr {\n    fn into_inner(self) -> (*const c::sockaddr, c::socklen_t) {\n        match *self {\n            SocketAddr::V4(ref a) => {\n                (a as *const _ as *const _, mem::size_of_val(a) as c::socklen_t)\n            }\n            SocketAddr::V6(ref a) => {\n                (a as *const _ as *const _, mem::size_of_val(a) as c::socklen_t)\n            }\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for SocketAddr {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            SocketAddr::V4(ref a) => a.fmt(f),\n            SocketAddr::V6(ref a) => a.fmt(f),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for SocketAddrV4 {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"{}:{}\", self.ip(), self.port())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for SocketAddrV4 {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self, fmt)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for SocketAddrV6 {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"[{}]:{}\", self.ip(), self.port())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Debug for SocketAddrV6 {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt::Display::fmt(self, fmt)\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Clone for SocketAddrV4 {\n    fn clone(&self) -> SocketAddrV4 { *self }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Clone for SocketAddrV6 {\n    fn clone(&self) -> SocketAddrV6 { *self }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for SocketAddrV4 {\n    fn eq(&self, other: &SocketAddrV4) -> bool {\n        self.inner.sin_port == other.inner.sin_port &&\n            self.inner.sin_addr.s_addr == other.inner.sin_addr.s_addr\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl PartialEq for SocketAddrV6 {\n    fn eq(&self, other: &SocketAddrV6) -> bool {\n        self.inner.sin6_port == other.inner.sin6_port &&\n            self.inner.sin6_addr.s6_addr == other.inner.sin6_addr.s6_addr &&\n            self.inner.sin6_flowinfo == other.inner.sin6_flowinfo &&\n            self.inner.sin6_scope_id == other.inner.sin6_scope_id\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for SocketAddrV4 {}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Eq for SocketAddrV6 {}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl hash::Hash for SocketAddrV4 {\n    fn hash<H: hash::Hasher>(&self, s: &mut H) {\n        (self.inner.sin_port, self.inner.sin_addr.s_addr).hash(s)\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl hash::Hash for SocketAddrV6 {\n    fn hash<H: hash::Hasher>(&self, s: &mut H) {\n        (self.inner.sin6_port, &self.inner.sin6_addr.s6_addr,\n         self.inner.sin6_flowinfo, self.inner.sin6_scope_id).hash(s)\n    }\n}\n\n/// A trait for objects which can be converted or resolved to one or more\n/// [`SocketAddr`] values.\n///\n/// This trait is used for generic address resolution when constructing network\n/// objects.  By default it is implemented for the following types:\n///\n///  * [`SocketAddr`]: [`to_socket_addrs`] is the identity function.\n///\n///  * [`SocketAddrV4`], [`SocketAddrV6`], `(`[`IpAddr`]`, `[`u16`]`)`,\n///    `(`[`Ipv4Addr`]`, `[`u16`]`)`, `(`[`Ipv6Addr`]`, `[`u16`]`)`:\n///    [`to_socket_addrs`] constructs a [`SocketAddr`] trivially.\n///\n///  * `(`[`&str`]`, `[`u16`]`)`: the string should be either a string representation\n///    of an [`IpAddr`] address as expected by [`FromStr`] implementation or a host\n///    name.\n///\n///  * [`&str`]: the string should be either a string representation of a\n///    [`SocketAddr`] as expected by its [`FromStr`] implementation or a string like\n///    `<host_name>:<port>` pair where `<port>` is a [`u16`] value.\n///\n/// This trait allows constructing network objects like [`TcpStream`] or\n/// [`UdpSocket`] easily with values of various types for the bind/connection\n/// address. It is needed because sometimes one type is more appropriate than\n/// the other: for simple uses a string like `\"localhost:12345\"` is much nicer\n/// than manual construction of the corresponding [`SocketAddr`], but sometimes\n/// [`SocketAddr`] value is *the* main source of the address, and converting it to\n/// some other type (e.g. a string) just for it to be converted back to\n/// [`SocketAddr`] in constructor methods is pointless.\n///\n/// Addresses returned by the operating system that are not IP addresses are\n/// silently ignored.\n///\n/// [`FromStr`]: ../../std/str/trait.FromStr.html\n/// [`IpAddr`]: ../../std/net/enum.IpAddr.html\n/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html\n/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html\n/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html\n/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html\n/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html\n/// [`&str`]: ../../std/primitive.str.html\n/// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n/// [`to_socket_addrs`]: #tymethod.to_socket_addrs\n/// [`UdpSocket`]: ../../std/net/struct.UdpSocket.html\n/// [`u16`]: ../../std/primitive.u16.html\n///\n/// # Examples\n///\n/// Creating a [`SocketAddr`] iterator that yields one item:\n///\n/// ```\n/// use std::net::{ToSocketAddrs, SocketAddr};\n///\n/// let addr = SocketAddr::from(([127, 0, 0, 1], 443));\n/// let mut addrs_iter = addr.to_socket_addrs().unwrap();\n///\n/// assert_eq!(Some(addr), addrs_iter.next());\n/// assert!(addrs_iter.next().is_none());\n/// ```\n///\n/// Creating a [`SocketAddr`] iterator from a hostname:\n///\n/// ```no_run\n/// use std::net::{SocketAddr, ToSocketAddrs};\n///\n/// // assuming 'localhost' resolves to 127.0.0.1\n/// let mut addrs_iter = \"localhost:443\".to_socket_addrs().unwrap();\n/// assert_eq!(addrs_iter.next(), Some(SocketAddr::from(([127, 0, 0, 1], 443))));\n/// assert!(addrs_iter.next().is_none());\n///\n/// // assuming 'foo' does not resolve\n/// assert!(\"foo:443\".to_socket_addrs().is_err());\n/// ```\n///\n/// Creating a [`SocketAddr`] iterator that yields multiple items:\n///\n/// ```\n/// use std::net::{SocketAddr, ToSocketAddrs};\n///\n/// let addr1 = SocketAddr::from(([0, 0, 0, 0], 80));\n/// let addr2 = SocketAddr::from(([127, 0, 0, 1], 443));\n/// let addrs = vec![addr1, addr2];\n///\n/// let mut addrs_iter = (&addrs[..]).to_socket_addrs().unwrap();\n///\n/// assert_eq!(Some(addr1), addrs_iter.next());\n/// assert_eq!(Some(addr2), addrs_iter.next());\n/// assert!(addrs_iter.next().is_none());\n/// ```\n///\n/// Attempting to create a [`SocketAddr`] iterator from an improperly formatted\n/// socket address `&str` (missing the port):\n///\n/// ```\n/// use std::io;\n/// use std::net::ToSocketAddrs;\n///\n/// let err = \"127.0.0.1\".to_socket_addrs().unwrap_err();\n/// assert_eq!(err.kind(), io::ErrorKind::InvalidInput);\n/// ```\n///\n/// [`TcpStream::connect`] is an example of an function that utilizes\n/// `ToSocketAddrs` as a trait bound on its parameter in order to accept\n/// different types:\n///\n/// ```no_run\n/// use std::net::{TcpStream, Ipv4Addr};\n///\n/// let stream = TcpStream::connect((\"127.0.0.1\", 443));\n/// // or\n/// let stream = TcpStream::connect(\"127.0.0.1:443\");\n/// // or\n/// let stream = TcpStream::connect((Ipv4Addr::new(127, 0, 0, 1), 443));\n/// ```\n///\n/// [`TcpStream::connect`]: ../../std/net/struct.TcpStream.html#method.connect\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait ToSocketAddrs {\n    /// Returned iterator over socket addresses which this type may correspond\n    /// to.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Iter: Iterator<Item=SocketAddr>;\n\n    /// Converts this object to an iterator of resolved `SocketAddr`s.\n    ///\n    /// The returned iterator may not actually yield any values depending on the\n    /// outcome of any resolution performed.\n    ///\n    /// Note that this function may block the current thread while resolution is\n    /// performed.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn to_socket_addrs(&self) -> io::Result<Self::Iter>;\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for SocketAddr {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        Ok(Some(*self).into_iter())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for SocketAddrV4 {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        SocketAddr::V4(*self).to_socket_addrs()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for SocketAddrV6 {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        SocketAddr::V6(*self).to_socket_addrs()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for (IpAddr, u16) {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        let (ip, port) = *self;\n        match ip {\n            IpAddr::V4(ref a) => (*a, port).to_socket_addrs(),\n            IpAddr::V6(ref a) => (*a, port).to_socket_addrs(),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for (Ipv4Addr, u16) {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        let (ip, port) = *self;\n        SocketAddrV4::new(ip, port).to_socket_addrs()\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for (Ipv6Addr, u16) {\n    type Iter = option::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<option::IntoIter<SocketAddr>> {\n        let (ip, port) = *self;\n        SocketAddrV6::new(ip, port, 0, 0).to_socket_addrs()\n    }\n}\n\nfn resolve_socket_addr(s: &str, p: u16) -> io::Result<vec::IntoIter<SocketAddr>> {\n    let ips = lookup_host(s)?;\n    let v: Vec<_> = ips.map(|mut a| { a.set_port(p); a }).collect();\n    Ok(v.into_iter())\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a> ToSocketAddrs for (&'a str, u16) {\n    type Iter = vec::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {\n        let (host, port) = *self;\n\n        // try to parse the host as a regular IP address first\n        if let Ok(addr) = host.parse::<Ipv4Addr>() {\n            let addr = SocketAddrV4::new(addr, port);\n            return Ok(vec![SocketAddr::V4(addr)].into_iter())\n        }\n        if let Ok(addr) = host.parse::<Ipv6Addr>() {\n            let addr = SocketAddrV6::new(addr, port, 0, 0);\n            return Ok(vec![SocketAddr::V6(addr)].into_iter())\n        }\n\n        resolve_socket_addr(host, port)\n    }\n}\n\n// accepts strings like 'localhost:12345'\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ToSocketAddrs for str {\n    type Iter = vec::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {\n        // try to parse as a regular SocketAddr first\n        if let Some(addr) = self.parse().ok() {\n            return Ok(vec![addr].into_iter());\n        }\n\n        macro_rules! try_opt {\n            ($e:expr, $msg:expr) => (\n                match $e {\n                    Some(r) => r,\n                    None => return Err(io::Error::new(io::ErrorKind::InvalidInput,\n                                                      $msg)),\n                }\n            )\n        }\n\n        // split the string by ':' and convert the second part to u16\n        let mut parts_iter = self.rsplitn(2, ':');\n        let port_str = try_opt!(parts_iter.next(), \"invalid socket address\");\n        let host = try_opt!(parts_iter.next(), \"invalid socket address\");\n        let port: u16 = try_opt!(port_str.parse().ok(), \"invalid port value\");\n        resolve_socket_addr(host, port)\n    }\n}\n\n#[stable(feature = \"slice_to_socket_addrs\", since = \"1.8.0\")]\nimpl<'a> ToSocketAddrs for &'a [SocketAddr] {\n    type Iter = iter::Cloned<slice::Iter<'a, SocketAddr>>;\n\n    fn to_socket_addrs(&self) -> io::Result<Self::Iter> {\n        Ok(self.iter().cloned())\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl<'a, T: ToSocketAddrs + ?Sized> ToSocketAddrs for &'a T {\n    type Iter = T::Iter;\n    fn to_socket_addrs(&self) -> io::Result<T::Iter> {\n        (**self).to_socket_addrs()\n    }\n}\n\n#[stable(feature = \"string_to_socket_addrs\", since = \"1.16.0\")]\nimpl ToSocketAddrs for String {\n    type Iter = vec::IntoIter<SocketAddr>;\n    fn to_socket_addrs(&self) -> io::Result<vec::IntoIter<SocketAddr>> {\n        (&**self).to_socket_addrs()\n    }\n}\n\n#[cfg(all(test, not(target_os = \"emscripten\")))]\nmod tests {\n    use net::*;\n    use net::test::{tsa, sa6, sa4};\n\n    #[test]\n    fn to_socket_addr_ipaddr_u16() {\n        let a = Ipv4Addr::new(77, 88, 21, 11);\n        let p = 12345;\n        let e = SocketAddr::V4(SocketAddrV4::new(a, p));\n        assert_eq!(Ok(vec![e]), tsa((a, p)));\n    }\n\n    #[test]\n    fn to_socket_addr_str_u16() {\n        let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);\n        assert_eq!(Ok(vec![a]), tsa((\"77.88.21.11\", 24352)));\n\n        let a = sa6(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);\n        assert_eq!(Ok(vec![a]), tsa((\"2a02:6b8:0:1::1\", 53)));\n\n        let a = sa4(Ipv4Addr::new(127, 0, 0, 1), 23924);\n        assert!(tsa((\"localhost\", 23924)).unwrap().contains(&a));\n    }\n\n    #[test]\n    fn to_socket_addr_str() {\n        let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);\n        assert_eq!(Ok(vec![a]), tsa(\"77.88.21.11:24352\"));\n\n        let a = sa6(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 53);\n        assert_eq!(Ok(vec![a]), tsa(\"[2a02:6b8:0:1::1]:53\"));\n\n        let a = sa4(Ipv4Addr::new(127, 0, 0, 1), 23924);\n        assert!(tsa(\"localhost:23924\").unwrap().contains(&a));\n    }\n\n    #[test]\n    fn to_socket_addr_string() {\n        let a = sa4(Ipv4Addr::new(77, 88, 21, 11), 24352);\n        assert_eq!(Ok(vec![a]), tsa(&*format!(\"{}:{}\", \"77.88.21.11\", \"24352\")));\n        assert_eq!(Ok(vec![a]), tsa(&format!(\"{}:{}\", \"77.88.21.11\", \"24352\")));\n        assert_eq!(Ok(vec![a]), tsa(format!(\"{}:{}\", \"77.88.21.11\", \"24352\")));\n\n        let s = format!(\"{}:{}\", \"77.88.21.11\", \"24352\");\n        assert_eq!(Ok(vec![a]), tsa(s));\n        // s has been moved into the tsa call\n    }\n\n    // FIXME: figure out why this fails on openbsd and bitrig and fix it\n    #[test]\n    #[cfg(not(any(windows, target_os = \"openbsd\", target_os = \"bitrig\")))]\n    fn to_socket_addr_str_bad() {\n        assert!(tsa(\"1200::AB00:1234::2552:7777:1313:34300\").is_err());\n    }\n\n    #[test]\n    fn set_ip() {\n        fn ip4(low: u8) -> Ipv4Addr { Ipv4Addr::new(77, 88, 21, low) }\n        fn ip6(low: u16) -> Ipv6Addr { Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, low) }\n\n        let mut v4 = SocketAddrV4::new(ip4(11), 80);\n        assert_eq!(v4.ip(), &ip4(11));\n        v4.set_ip(ip4(12));\n        assert_eq!(v4.ip(), &ip4(12));\n\n        let mut addr = SocketAddr::V4(v4);\n        assert_eq!(addr.ip(), IpAddr::V4(ip4(12)));\n        addr.set_ip(IpAddr::V4(ip4(13)));\n        assert_eq!(addr.ip(), IpAddr::V4(ip4(13)));\n        addr.set_ip(IpAddr::V6(ip6(14)));\n        assert_eq!(addr.ip(), IpAddr::V6(ip6(14)));\n\n        let mut v6 = SocketAddrV6::new(ip6(1), 80, 0, 0);\n        assert_eq!(v6.ip(), &ip6(1));\n        v6.set_ip(ip6(2));\n        assert_eq!(v6.ip(), &ip6(2));\n\n        let mut addr = SocketAddr::V6(v6);\n        assert_eq!(addr.ip(), IpAddr::V6(ip6(2)));\n        addr.set_ip(IpAddr::V6(ip6(3)));\n        assert_eq!(addr.ip(), IpAddr::V6(ip6(3)));\n        addr.set_ip(IpAddr::V4(ip4(4)));\n        assert_eq!(addr.ip(), IpAddr::V4(ip4(4)));\n    }\n\n    #[test]\n    fn set_port() {\n        let mut v4 = SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80);\n        assert_eq!(v4.port(), 80);\n        v4.set_port(443);\n        assert_eq!(v4.port(), 443);\n\n        let mut addr = SocketAddr::V4(v4);\n        assert_eq!(addr.port(), 443);\n        addr.set_port(8080);\n        assert_eq!(addr.port(), 8080);\n\n        let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 0);\n        assert_eq!(v6.port(), 80);\n        v6.set_port(443);\n        assert_eq!(v6.port(), 443);\n\n        let mut addr = SocketAddr::V6(v6);\n        assert_eq!(addr.port(), 443);\n        addr.set_port(8080);\n        assert_eq!(addr.port(), 8080);\n    }\n\n    #[test]\n    fn set_flowinfo() {\n        let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 10, 0);\n        assert_eq!(v6.flowinfo(), 10);\n        v6.set_flowinfo(20);\n        assert_eq!(v6.flowinfo(), 20);\n    }\n\n    #[test]\n    fn set_scope_id() {\n        let mut v6 = SocketAddrV6::new(Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 0, 10);\n        assert_eq!(v6.scope_id(), 10);\n        v6.set_scope_id(20);\n        assert_eq!(v6.scope_id(), 20);\n    }\n\n    #[test]\n    fn is_v4() {\n        let v4 = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(77, 88, 21, 11), 80));\n        assert!(v4.is_ipv4());\n        assert!(!v4.is_ipv6());\n    }\n\n    #[test]\n    fn is_v6() {\n        let v6 = SocketAddr::V6(SocketAddrV6::new(\n                Ipv6Addr::new(0x2a02, 0x6b8, 0, 1, 0, 0, 0, 1), 80, 10, 0));\n        assert!(!v6.is_ipv4());\n        assert!(v6.is_ipv6());\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Networking primitives for TCP/UDP communication.\n//!\n//! This module provides networking functionality for the Transmission Control and User\n//! Datagram Protocols, as well as types for IP and socket addresses.\n//!\n//! # Organization\n//!\n//! * [`TcpListener`] and [`TcpStream`] provide functionality for communication over TCP\n//! * [`UdpSocket`] provides functionality for communication over UDP\n//! * [`IpAddr`] represents IP addresses of either IPv4 or IPv6; [`Ipv4Addr`] and\n//!   [`Ipv6Addr`] are respectively IPv4 and IPv6 addresses\n//! * [`SocketAddr`] represents socket addresses of either IPv4 or IPv6; [`SocketAddrV4`]\n//!   and [`SocketAddrV6`] are respectively IPv4 and IPv6 socket addresses\n//! * [`ToSocketAddrs`] is a trait that used for generic address resolution when interacting\n//!   with networking objects like [`TcpListener`], [`TcpStream`] or [`UdpSocket`]\n//! * Other types are return or parameter types for various methods in this module\n//!\n//! [`IpAddr`]: ../../std/net/enum.IpAddr.html\n//! [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html\n//! [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html\n//! [`SocketAddr`]: ../../std/net/enum.SocketAddr.html\n//! [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html\n//! [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html\n//! [`TcpListener`]: ../../std/net/struct.TcpListener.html\n//! [`TcpStream`]: ../../std/net/struct.TcpStream.html\n//! [`ToSocketAddrs`]: ../../std/net/trait.ToSocketAddrs.html\n//! [`UdpSocket`]: ../../std/net/struct.UdpSocket.html\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse io::{self, Error, ErrorKind};\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::ip::{IpAddr, Ipv4Addr, Ipv6Addr, Ipv6MulticastScope};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::addr::{SocketAddr, SocketAddrV4, SocketAddrV6, ToSocketAddrs};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::tcp::{TcpStream, TcpListener, Incoming};\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::udp::UdpSocket;\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub use self::parser::AddrParseError;\n\nmod ip;\nmod addr;\nmod tcp;\nmod udp;\nmod parser;\n#[cfg(test)]\nmod test;\n\n/// Possible values which can be passed to the [`shutdown`] method of\n/// [`TcpStream`].\n///\n/// [`shutdown`]: struct.TcpStream.html#method.shutdown\n/// [`TcpStream`]: struct.TcpStream.html\n#[derive(Copy, Clone, PartialEq, Eq, Debug)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub enum Shutdown {\n    /// The reading portion of the [`TcpStream`] should be shut down.\n    ///\n    /// All currently blocked and future [reads] will return [`Ok(0)`].\n    ///\n    /// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n    /// [reads]: ../../std/io/trait.Read.html\n    /// [`Ok(0)`]: ../../std/result/enum.Result.html#variant.Ok\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Read,\n    /// The writing portion of the [`TcpStream`] should be shut down.\n    ///\n    /// All currently blocked and future [writes] will return an error.\n    ///\n    /// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n    /// [writes]: ../../std/io/trait.Write.html\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Write,\n    /// Both the reading and the writing portions of the [`TcpStream`] should be shut down.\n    ///\n    /// See [`Shutdown::Read`] and [`Shutdown::Write`] for more information.\n    ///\n    /// [`TcpStream`]: ../../std/net/struct.TcpStream.html\n    /// [`Shutdown::Read`]: #variant.Read\n    /// [`Shutdown::Write`]: #variant.Write\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    Both,\n}\n\n#[doc(hidden)]\ntrait NetInt {\n    fn from_be(i: Self) -> Self;\n    fn to_be(&self) -> Self;\n}\nmacro_rules! doit {\n    ($($t:ident)*) => ($(impl NetInt for $t {\n        fn from_be(i: Self) -> Self { <$t>::from_be(i) }\n        fn to_be(&self) -> Self { <$t>::to_be(*self) }\n    })*)\n}\ndoit! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize }\n\nfn hton<I: NetInt>(i: I) -> I { i.to_be() }\nfn ntoh<I: NetInt>(i: I) -> I { I::from_be(i) }\n\nfn each_addr<A: ToSocketAddrs, F, T>(addr: A, mut f: F) -> io::Result<T>\n    where F: FnMut(&SocketAddr) -> io::Result<T>\n{\n    let mut last_err = None;\n    for addr in addr.to_socket_addrs()? {\n        match f(&addr) {\n            Ok(l) => return Ok(l),\n            Err(e) => last_err = Some(e),\n        }\n    }\n    Err(last_err.unwrap_or_else(|| {\n        Error::new(ErrorKind::InvalidInput,\n                   \"could not resolve to any addresses\")\n    }))\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! A private parser implementation of IPv4, IPv6, and socket addresses.\n//!\n//! This module is \"publicly exported\" through the `FromStr` implementations\n//! below.\n\nuse error::Error;\nuse fmt;\nuse net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};\nuse str::FromStr;\n\nstruct Parser<'a> {\n    // parsing as ASCII, so can use byte array\n    s: &'a [u8],\n    pos: usize,\n}\n\nimpl<'a> Parser<'a> {\n    fn new(s: &'a str) -> Parser<'a> {\n        Parser {\n            s: s.as_bytes(),\n            pos: 0,\n        }\n    }\n\n    fn is_eof(&self) -> bool {\n        self.pos == self.s.len()\n    }\n\n    // Commit only if parser returns Some\n    fn read_atomically<T, F>(&mut self, cb: F) -> Option<T> where\n        F: FnOnce(&mut Parser) -> Option<T>,\n    {\n        let pos = self.pos;\n        let r = cb(self);\n        if r.is_none() {\n            self.pos = pos;\n        }\n        r\n    }\n\n    // Commit only if parser read till EOF\n    fn read_till_eof<T, F>(&mut self, cb: F) -> Option<T> where\n        F: FnOnce(&mut Parser) -> Option<T>,\n    {\n        self.read_atomically(move |p| {\n            cb(p).filter(|_| p.is_eof())\n        })\n    }\n\n    // Return result of first successful parser\n    fn read_or<T>(&mut self, parsers: &mut [Box<dyn FnMut(&mut Parser) -> Option<T> + 'static>])\n               -> Option<T> {\n        for pf in parsers {\n            if let Some(r) = self.read_atomically(|p: &mut Parser| pf(p)) {\n                return Some(r);\n            }\n        }\n        None\n    }\n\n    // Apply 3 parsers sequentially\n    fn read_seq_3<A, B, C, PA, PB, PC>(&mut self,\n                                       pa: PA,\n                                       pb: PB,\n                                       pc: PC)\n                                       -> Option<(A, B, C)> where\n        PA: FnOnce(&mut Parser) -> Option<A>,\n        PB: FnOnce(&mut Parser) -> Option<B>,\n        PC: FnOnce(&mut Parser) -> Option<C>,\n    {\n        self.read_atomically(move |p| {\n            let a = pa(p);\n            let b = if a.is_some() { pb(p) } else { None };\n            let c = if b.is_some() { pc(p) } else { None };\n            match (a, b, c) {\n                (Some(a), Some(b), Some(c)) => Some((a, b, c)),\n                _ => None\n            }\n        })\n    }\n\n    // Read next char\n    fn read_char(&mut self) -> Option<char> {\n        if self.is_eof() {\n            None\n        } else {\n            let r = self.s[self.pos] as char;\n            self.pos += 1;\n            Some(r)\n        }\n    }\n\n    // Return char and advance iff next char is equal to requested\n    fn read_given_char(&mut self, c: char) -> Option<char> {\n        self.read_atomically(|p| {\n            match p.read_char() {\n                Some(next) if next == c => Some(next),\n                _ => None,\n            }\n        })\n    }\n\n    // Read digit\n    fn read_digit(&mut self, radix: u8) -> Option<u8> {\n        fn parse_digit(c: char, radix: u8) -> Option<u8> {\n            let c = c as u8;\n            // assuming radix is either 10 or 16\n            if c >= b'0' && c <= b'9' {\n                Some(c - b'0')\n            } else if radix > 10 && c >= b'a' && c < b'a' + (radix - 10) {\n                Some(c - b'a' + 10)\n            } else if radix > 10 && c >= b'A' && c < b'A' + (radix - 10) {\n                Some(c - b'A' + 10)\n            } else {\n                None\n            }\n        }\n\n        self.read_atomically(|p| {\n            p.read_char().and_then(|c| parse_digit(c, radix))\n        })\n    }\n\n    fn read_number_impl(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {\n        let mut r = 0;\n        let mut digit_count = 0;\n        loop {\n            match self.read_digit(radix) {\n                Some(d) => {\n                    r = r * (radix as u32) + (d as u32);\n                    digit_count += 1;\n                    if digit_count > max_digits || r >= upto {\n                        return None\n                    }\n                }\n                None => {\n                    if digit_count == 0 {\n                        return None\n                    } else {\n                        return Some(r)\n                    }\n                }\n            };\n        }\n    }\n\n    // Read number, failing if max_digits of number value exceeded\n    fn read_number(&mut self, radix: u8, max_digits: u32, upto: u32) -> Option<u32> {\n        self.read_atomically(|p| p.read_number_impl(radix, max_digits, upto))\n    }\n\n    fn read_ipv4_addr_impl(&mut self) -> Option<Ipv4Addr> {\n        let mut bs = [0; 4];\n        let mut i = 0;\n        while i < 4 {\n            if i != 0 && self.read_given_char('.').is_none() {\n                return None;\n            }\n\n            bs[i] = self.read_number(10, 3, 0x100).map(|n| n as u8)?;\n            i += 1;\n        }\n        Some(Ipv4Addr::new(bs[0], bs[1], bs[2], bs[3]))\n    }\n\n    // Read IPv4 address\n    fn read_ipv4_addr(&mut self) -> Option<Ipv4Addr> {\n        self.read_atomically(|p| p.read_ipv4_addr_impl())\n    }\n\n    fn read_ipv6_addr_impl(&mut self) -> Option<Ipv6Addr> {\n        fn ipv6_addr_from_head_tail(head: &[u16], tail: &[u16]) -> Ipv6Addr {\n            assert!(head.len() + tail.len() <= 8);\n            let mut gs = [0; 8];\n            gs[..head.len()].copy_from_slice(head);\n            gs[(8 - tail.len()) .. 8].copy_from_slice(tail);\n            Ipv6Addr::new(gs[0], gs[1], gs[2], gs[3], gs[4], gs[5], gs[6], gs[7])\n        }\n\n        fn read_groups(p: &mut Parser, groups: &mut [u16; 8], limit: usize)\n                       -> (usize, bool) {\n            let mut i = 0;\n            while i < limit {\n                if i < limit - 1 {\n                    let ipv4 = p.read_atomically(|p| {\n                        if i == 0 || p.read_given_char(':').is_some() {\n                            p.read_ipv4_addr()\n                        } else {\n                            None\n                        }\n                    });\n                    if let Some(v4_addr) = ipv4 {\n                        let octets = v4_addr.octets();\n                        groups[i + 0] = ((octets[0] as u16) << 8) | (octets[1] as u16);\n                        groups[i + 1] = ((octets[2] as u16) << 8) | (octets[3] as u16);\n                        return (i + 2, true);\n                    }\n                }\n\n                let group = p.read_atomically(|p| {\n                    if i == 0 || p.read_given_char(':').is_some() {\n                        p.read_number(16, 4, 0x10000).map(|n| n as u16)\n                    } else {\n                        None\n                    }\n                });\n                match group {\n                    Some(g) => groups[i] = g,\n                    None => return (i, false)\n                }\n                i += 1;\n            }\n            (i, false)\n        }\n\n        let mut head = [0; 8];\n        let (head_size, head_ipv4) = read_groups(self, &mut head, 8);\n\n        if head_size == 8 {\n            return Some(Ipv6Addr::new(\n                head[0], head[1], head[2], head[3],\n                head[4], head[5], head[6], head[7]))\n        }\n\n        // IPv4 part is not allowed before `::`\n        if head_ipv4 {\n            return None\n        }\n\n        // read `::` if previous code parsed less than 8 groups\n        if !self.read_given_char(':').is_some() || !self.read_given_char(':').is_some() {\n            return None;\n        }\n\n        let mut tail = [0; 8];\n        // `::` indicates one or more groups of 16 bits of zeros\n        let limit = 8 - (head_size + 1);\n        let (tail_size, _) = read_groups(self, &mut tail, limit);\n        Some(ipv6_addr_from_head_tail(&head[..head_size], &tail[..tail_size]))\n    }\n\n    fn read_ipv6_addr(&mut self) -> Option<Ipv6Addr> {\n        self.read_atomically(|p| p.read_ipv6_addr_impl())\n    }\n\n    fn read_ip_addr(&mut self) -> Option<IpAddr> {\n        let ipv4_addr = |p: &mut Parser| p.read_ipv4_addr().map(IpAddr::V4);\n        let ipv6_addr = |p: &mut Parser| p.read_ipv6_addr().map(IpAddr::V6);\n        self.read_or(&mut [Box::new(ipv4_addr), Box::new(ipv6_addr)])\n    }\n\n    fn read_socket_addr_v4(&mut self) -> Option<SocketAddrV4> {\n        let ip_addr = |p: &mut Parser| p.read_ipv4_addr();\n        let colon = |p: &mut Parser| p.read_given_char(':');\n        let port = |p: &mut Parser| {\n            p.read_number(10, 5, 0x10000).map(|n| n as u16)\n        };\n\n        self.read_seq_3(ip_addr, colon, port).map(|t| {\n            let (ip, _, port): (Ipv4Addr, char, u16) = t;\n            SocketAddrV4::new(ip, port)\n        })\n    }\n\n    fn read_socket_addr_v6(&mut self) -> Option<SocketAddrV6> {\n        let ip_addr = |p: &mut Parser| {\n            let open_br = |p: &mut Parser| p.read_given_char('[');\n            let ip_addr = |p: &mut Parser| p.read_ipv6_addr();\n            let clos_br = |p: &mut Parser| p.read_given_char(']');\n            p.read_seq_3(open_br, ip_addr, clos_br).map(|t| t.1)\n        };\n        let colon = |p: &mut Parser| p.read_given_char(':');\n        let port = |p: &mut Parser| {\n            p.read_number(10, 5, 0x10000).map(|n| n as u16)\n        };\n\n        self.read_seq_3(ip_addr, colon, port).map(|t| {\n            let (ip, _, port): (Ipv6Addr, char, u16) = t;\n            SocketAddrV6::new(ip, port, 0, 0)\n        })\n    }\n\n    fn read_socket_addr(&mut self) -> Option<SocketAddr> {\n        let v4 = |p: &mut Parser| p.read_socket_addr_v4().map(SocketAddr::V4);\n        let v6 = |p: &mut Parser| p.read_socket_addr_v6().map(SocketAddr::V6);\n        self.read_or(&mut [Box::new(v4), Box::new(v6)])\n    }\n}\n\n#[stable(feature = \"ip_addr\", since = \"1.7.0\")]\nimpl FromStr for IpAddr {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<IpAddr, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_ip_addr()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(()))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromStr for Ipv4Addr {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<Ipv4Addr, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_ipv4_addr()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(()))\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromStr for Ipv6Addr {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<Ipv6Addr, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_ipv6_addr()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(()))\n        }\n    }\n}\n\n#[stable(feature = \"socket_addr_from_str\", since = \"1.5.0\")]\nimpl FromStr for SocketAddrV4 {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<SocketAddrV4, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v4()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(())),\n        }\n    }\n}\n\n#[stable(feature = \"socket_addr_from_str\", since = \"1.5.0\")]\nimpl FromStr for SocketAddrV6 {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<SocketAddrV6, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_socket_addr_v6()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(())),\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl FromStr for SocketAddr {\n    type Err = AddrParseError;\n    fn from_str(s: &str) -> Result<SocketAddr, AddrParseError> {\n        match Parser::new(s).read_till_eof(|p| p.read_socket_addr()) {\n            Some(s) => Ok(s),\n            None => Err(AddrParseError(())),\n        }\n    }\n}\n\n/// An error which can be returned when parsing an IP address or a socket address.\n///\n/// This error is used as the error type for the [`FromStr`] implementation for\n/// [`IpAddr`], [`Ipv4Addr`], [`Ipv6Addr`], [`SocketAddr`], [`SocketAddrV4`], and\n/// [`SocketAddrV6`].\n///\n/// # Potential causes\n///\n/// `AddrParseError` may be thrown because the provided string does not parse as the given type,\n/// often because it includes information only handled by a different address type.\n///\n/// ```should_panic\n/// use std::net::IpAddr;\n/// let _foo: IpAddr = \"127.0.0.1:8080\".parse().expect(\"Cannot handle the socket port\");\n/// ```\n///\n/// [`IpAddr`] doesn't handle the port. Use [`SocketAddr`] instead.\n///\n/// ```\n/// use std::net::SocketAddr;\n///\n/// // No problem, the `panic!` message has disappeared.\n/// let _foo: SocketAddr = \"127.0.0.1:8080\".parse().expect(\"unreachable panic\");\n/// ```\n///\n/// [`FromStr`]: ../../std/str/trait.FromStr.html\n/// [`IpAddr`]: ../../std/net/enum.IpAddr.html\n/// [`Ipv4Addr`]: ../../std/net/struct.Ipv4Addr.html\n/// [`Ipv6Addr`]: ../../std/net/struct.Ipv6Addr.html\n/// [`SocketAddr`]: ../../std/net/enum.SocketAddr.html\n/// [`SocketAddrV4`]: ../../std/net/struct.SocketAddrV4.html\n/// [`SocketAddrV6`]: ../../std/net/struct.SocketAddrV6.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[derive(Debug, Clone, PartialEq, Eq)]\npub struct AddrParseError(());\n\n#[stable(feature = \"addr_parse_error_error\", since = \"1.4.0\")]\nimpl fmt::Display for AddrParseError {\n    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {\n        fmt.write_str(self.description())\n    }\n}\n\n#[stable(feature = \"addr_parse_error_error\", since = \"1.4.0\")]\nimpl Error for AddrParseError {\n    fn description(&self) -> &str {\n        \"invalid IP address syntax\"\n    }\n}\n","// Copyright 2018 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Asynchronous values.\n\nuse core::cell::Cell;\nuse core::marker::Unpin;\nuse core::pin::Pin;\nuse core::option::Option;\nuse core::ptr::NonNull;\nuse core::task::{LocalWaker, Poll};\nuse core::ops::{Drop, Generator, GeneratorState};\n\n#[doc(inline)]\npub use core::future::*;\n\n/// Wrap a future in a generator.\n///\n/// This function returns a `GenFuture` underneath, but hides it in `impl Trait` to give\n/// better error messages (`impl Future` rather than `GenFuture<[closure.....]>`).\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\npub fn from_generator<T: Generator<Yield = ()>>(x: T) -> impl Future<Output = T::Return> {\n    GenFuture(x)\n}\n\n/// A wrapper around generators used to implement `Future` for `async`/`await` code.\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\n#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]\nstruct GenFuture<T: Generator<Yield = ()>>(T);\n\n// We rely on the fact that async/await futures are immovable in order to create\n// self-referential borrows in the underlying generator.\nimpl<T: Generator<Yield = ()>> !Unpin for GenFuture<T> {}\n\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\nimpl<T: Generator<Yield = ()>> Future for GenFuture<T> {\n    type Output = T::Return;\n    fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {\n        set_task_waker(lw, || match unsafe { Pin::get_mut_unchecked(self).0.resume() } {\n            GeneratorState::Yielded(()) => Poll::Pending,\n            GeneratorState::Complete(x) => Poll::Ready(x),\n        })\n    }\n}\n\nthread_local! {\n    static TLS_WAKER: Cell<Option<NonNull<LocalWaker>>> = Cell::new(None);\n}\n\nstruct SetOnDrop(Option<NonNull<LocalWaker>>);\n\nimpl Drop for SetOnDrop {\n    fn drop(&mut self) {\n        TLS_WAKER.with(|tls_waker| {\n            tls_waker.set(self.0.take());\n        });\n    }\n}\n\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\n/// Sets the thread-local task context used by async/await futures.\npub fn set_task_waker<F, R>(lw: &LocalWaker, f: F) -> R\nwhere\n    F: FnOnce() -> R\n{\n    let old_waker = TLS_WAKER.with(|tls_waker| {\n        tls_waker.replace(Some(NonNull::from(lw)))\n    });\n    let _reset_waker = SetOnDrop(old_waker);\n    f()\n}\n\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\n/// Retrieves the thread-local task waker used by async/await futures.\n///\n/// This function acquires exclusive access to the task waker.\n///\n/// Panics if no waker has been set or if the waker has already been\n/// retrieved by a surrounding call to get_task_waker.\npub fn get_task_waker<F, R>(f: F) -> R\nwhere\n    F: FnOnce(&LocalWaker) -> R\n{\n    let waker_ptr = TLS_WAKER.with(|tls_waker| {\n        // Clear the entry so that nested `get_task_waker` calls\n        // will fail or set their own value.\n        tls_waker.replace(None)\n    });\n    let _reset_waker = SetOnDrop(waker_ptr);\n\n    let mut waker_ptr = waker_ptr.expect(\n        \"TLS LocalWaker not set. This is a rustc bug. \\\n        Please file an issue on https://github.com/rust-lang/rust.\");\n    unsafe { f(waker_ptr.as_mut()) }\n}\n\n#[unstable(feature = \"gen_future\", issue = \"50547\")]\n/// Polls a future in the current thread-local task waker.\npub fn poll_with_tls_waker<F>(f: Pin<&mut F>) -> Poll<F::Output>\nwhere\n    F: Future\n{\n    get_task_waker(|lw| F::poll(f, lw))\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n//\n// Original implementation taken from rust-memchr\n// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch\n\n/// A safe interface to `memchr`.\n///\n/// Returns the index corresponding to the first occurrence of `needle` in\n/// `haystack`, or `None` if one is not found.\n///\n/// memchr reduces to super-optimized machine code at around an order of\n/// magnitude faster than `haystack.iter().position(|&b| b == needle)`.\n/// (See benchmarks.)\n///\n/// # Examples\n///\n/// This shows how to find the first position of a byte in a byte string.\n///\n/// ```ignore (cannot-doctest-private-modules)\n/// use memchr::memchr;\n///\n/// let haystack = b\"the quick brown fox\";\n/// assert_eq!(memchr(b'k', haystack), Some(8));\n/// ```\n#[inline]\npub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {\n    ::sys::memchr::memchr(needle, haystack)\n}\n\n/// A safe interface to `memrchr`.\n///\n/// Returns the index corresponding to the last occurrence of `needle` in\n/// `haystack`, or `None` if one is not found.\n///\n/// # Examples\n///\n/// This shows how to find the last position of a byte in a byte string.\n///\n/// ```ignore (cannot-doctest-private-modules)\n/// use memchr::memrchr;\n///\n/// let haystack = b\"the quick brown fox\";\n/// assert_eq!(memrchr(b'o', haystack), Some(17));\n/// ```\n#[inline]\npub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> {\n    ::sys::memchr::memrchr(needle, haystack)\n}\n\n#[cfg(test)]\nmod tests {\n    // test the implementations for the current platform\n    use super::{memchr, memrchr};\n\n    #[test]\n    fn matches_one() {\n        assert_eq!(Some(0), memchr(b'a', b\"a\"));\n    }\n\n    #[test]\n    fn matches_begin() {\n        assert_eq!(Some(0), memchr(b'a', b\"aaaa\"));\n    }\n\n    #[test]\n    fn matches_end() {\n        assert_eq!(Some(4), memchr(b'z', b\"aaaaz\"));\n    }\n\n    #[test]\n    fn matches_nul() {\n        assert_eq!(Some(4), memchr(b'\\x00', b\"aaaa\\x00\"));\n    }\n\n    #[test]\n    fn matches_past_nul() {\n        assert_eq!(Some(5), memchr(b'z', b\"aaaa\\x00z\"));\n    }\n\n    #[test]\n    fn no_match_empty() {\n        assert_eq!(None, memchr(b'a', b\"\"));\n    }\n\n    #[test]\n    fn no_match() {\n        assert_eq!(None, memchr(b'a', b\"xyz\"));\n    }\n\n    #[test]\n    fn matches_one_reversed() {\n        assert_eq!(Some(0), memrchr(b'a', b\"a\"));\n    }\n\n    #[test]\n    fn matches_begin_reversed() {\n        assert_eq!(Some(3), memrchr(b'a', b\"aaaa\"));\n    }\n\n    #[test]\n    fn matches_end_reversed() {\n        assert_eq!(Some(0), memrchr(b'z', b\"zaaaa\"));\n    }\n\n    #[test]\n    fn matches_nul_reversed() {\n        assert_eq!(Some(4), memrchr(b'\\x00', b\"aaaa\\x00\"));\n    }\n\n    #[test]\n    fn matches_past_nul_reversed() {\n        assert_eq!(Some(0), memrchr(b'z', b\"z\\x00aaaa\"));\n    }\n\n    #[test]\n    fn no_match_empty_reversed() {\n        assert_eq!(None, memrchr(b'a', b\"\"));\n    }\n\n    #[test]\n    fn no_match_reversed() {\n        assert_eq!(None, memrchr(b'a', b\"xyz\"));\n    }\n\n    #[test]\n    fn each_alignment() {\n        let mut data = [1u8; 64];\n        let needle = 2;\n        let pos = 40;\n        data[pos] = needle;\n        for start in 0..16 {\n            assert_eq!(Some(pos - start), memchr(needle, &data[start..]));\n        }\n    }\n}\n","// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Inspection and manipulation of the process's environment.\n//!\n//! This module contains functions to inspect various aspects such as\n//! environment variables, process arguments, the current directory, and various\n//! other important directories.\n//!\n//! There are several functions and structs in this module that have a\n//! counterpart ending in `os`. Those ending in `os` will return an [`OsString`]\n//! and those without will be returning a [`String`].\n//!\n//! [`OsString`]: ../../std/ffi/struct.OsString.html\n//! [`String`]: ../string/struct.String.html\n\n#![stable(feature = \"env\", since = \"1.0.0\")]\n\nuse error::Error;\nuse ffi::{OsStr, OsString};\nuse fmt;\nuse io;\nuse path::{Path, PathBuf};\nuse sys;\nuse sys::os as os_imp;\n\n/// Returns the current working directory as a [`PathBuf`].\n///\n/// # Errors\n///\n/// Returns an [`Err`] if the current working directory value is invalid.\n/// Possible cases:\n///\n/// * Current directory does not exist.\n/// * There are insufficient permissions to access the current directory.\n///\n/// [`PathBuf`]: ../../std/path/struct.PathBuf.html\n/// [`Err`]: ../../std/result/enum.Result.html#method.err\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// fn main() -> std::io::Result<()> {\n///     let path = env::current_dir()?;\n///     println!(\"The current directory is {}\", path.display());\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn current_dir() -> io::Result<PathBuf> {\n    os_imp::getcwd()\n}\n\n/// Changes the current working directory to the specified path.\n///\n/// Returns an [`Err`] if the operation fails.\n///\n/// [`Err`]: ../../std/result/enum.Result.html#method.err\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n/// use std::path::Path;\n///\n/// let root = Path::new(\"/\");\n/// assert!(env::set_current_dir(&root).is_ok());\n/// println!(\"Successfully changed working directory to {}!\", root.display());\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {\n    os_imp::chdir(path.as_ref())\n}\n\n/// An iterator over a snapshot of the environment variables of this process.\n///\n/// This structure is created by the [`std::env::vars`] function. See its\n/// documentation for more.\n///\n/// [`std::env::vars`]: fn.vars.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct Vars { inner: VarsOs }\n\n/// An iterator over a snapshot of the environment variables of this process.\n///\n/// This structure is created by the [`std::env::vars_os`] function. See\n/// its documentation for more.\n///\n/// [`std::env::vars_os`]: fn.vars_os.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct VarsOs { inner: os_imp::Env }\n\n/// Returns an iterator of (variable, value) pairs of strings, for all the\n/// environment variables of the current process.\n///\n/// The returned iterator contains a snapshot of the process's environment\n/// variables at the time of this invocation. Modifications to environment\n/// variables afterwards will not be reflected in the returned iterator.\n///\n/// # Panics\n///\n/// While iterating, the returned iterator will panic if any key or value in the\n/// environment is not valid unicode. If this is not desired, consider using the\n/// [`env::vars_os`] function.\n///\n/// [`env::vars_os`]: fn.vars_os.html\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// // We will iterate through the references to the element returned by\n/// // env::vars();\n/// for (key, value) in env::vars() {\n///     println!(\"{}: {}\", key, value);\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn vars() -> Vars {\n    Vars { inner: vars_os() }\n}\n\n/// Returns an iterator of (variable, value) pairs of OS strings, for all the\n/// environment variables of the current process.\n///\n/// The returned iterator contains a snapshot of the process's environment\n/// variables at the time of this invocation. Modifications to environment\n/// variables afterwards will not be reflected in the returned iterator.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// // We will iterate through the references to the element returned by\n/// // env::vars_os();\n/// for (key, value) in env::vars_os() {\n///     println!(\"{:?}: {:?}\", key, value);\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn vars_os() -> VarsOs {\n    VarsOs { inner: os_imp::env() }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Iterator for Vars {\n    type Item = (String, String);\n    fn next(&mut self) -> Option<(String, String)> {\n        self.inner.next().map(|(a, b)| {\n            (a.into_string().unwrap(), b.into_string().unwrap())\n        })\n    }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Vars {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"Vars { .. }\")\n    }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Iterator for VarsOs {\n    type Item = (OsString, OsString);\n    fn next(&mut self) -> Option<(OsString, OsString)> { self.inner.next() }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for VarsOs {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"VarsOs { .. }\")\n    }\n}\n\n/// Fetches the environment variable `key` from the current process.\n///\n/// # Errors\n///\n/// * Environment variable is not present\n/// * Environment variable is not valid unicode\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// let key = \"HOME\";\n/// match env::var(key) {\n///     Ok(val) => println!(\"{}: {:?}\", key, val),\n///     Err(e) => println!(\"couldn't interpret {}: {}\", key, e),\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn var<K: AsRef<OsStr>>(key: K) -> Result<String, VarError> {\n    _var(key.as_ref())\n}\n\nfn _var(key: &OsStr) -> Result<String, VarError> {\n    match var_os(key) {\n        Some(s) => s.into_string().map_err(VarError::NotUnicode),\n        None => Err(VarError::NotPresent),\n    }\n}\n\n/// Fetches the environment variable `key` from the current process, returning\n/// [`None`] if the variable isn't set.\n///\n/// [`None`]: ../option/enum.Option.html#variant.None\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// let key = \"HOME\";\n/// match env::var_os(key) {\n///     Some(val) => println!(\"{}: {:?}\", key, val),\n///     None => println!(\"{} is not defined in the environment.\", key)\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn var_os<K: AsRef<OsStr>>(key: K) -> Option<OsString> {\n    _var_os(key.as_ref())\n}\n\nfn _var_os(key: &OsStr) -> Option<OsString> {\n    os_imp::getenv(key).unwrap_or_else(|e| {\n        panic!(\"failed to get environment variable `{:?}`: {}\", key, e)\n    })\n}\n\n/// The error type for operations interacting with environment variables.\n/// Possibly returned from the [`env::var`] function.\n///\n/// [`env::var`]: fn.var.html\n#[derive(Debug, PartialEq, Eq, Clone)]\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub enum VarError {\n    /// The specified environment variable was not present in the current\n    /// process's environment.\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    NotPresent,\n\n    /// The specified environment variable was found, but it did not contain\n    /// valid unicode data. The found data is returned as a payload of this\n    /// variant.\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    NotUnicode(#[stable(feature = \"env\", since = \"1.0.0\")] OsString),\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl fmt::Display for VarError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        match *self {\n            VarError::NotPresent => write!(f, \"environment variable not found\"),\n            VarError::NotUnicode(ref s) => {\n                write!(f, \"environment variable was not valid unicode: {:?}\", s)\n            }\n        }\n    }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Error for VarError {\n    fn description(&self) -> &str {\n        match *self {\n            VarError::NotPresent => \"environment variable not found\",\n            VarError::NotUnicode(..) => \"environment variable was not valid unicode\",\n        }\n    }\n}\n\n/// Sets the environment variable `k` to the value `v` for the currently running\n/// process.\n///\n/// Note that while concurrent access to environment variables is safe in Rust,\n/// some platforms only expose inherently unsafe non-threadsafe APIs for\n/// inspecting the environment. As a result extra care needs to be taken when\n/// auditing calls to unsafe external FFI functions to ensure that any external\n/// environment accesses are properly synchronized with accesses in Rust.\n///\n/// Discussion of this unsafety on Unix may be found in:\n///\n///  - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)\n///  - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)\n///\n/// # Panics\n///\n/// This function may panic if `key` is empty, contains an ASCII equals sign\n/// `'='` or the NUL character `'\\0'`, or when the value contains the NUL\n/// character.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// let key = \"KEY\";\n/// env::set_var(key, \"VALUE\");\n/// assert_eq!(env::var(key), Ok(\"VALUE\".to_string()));\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(k: K, v: V) {\n    _set_var(k.as_ref(), v.as_ref())\n}\n\nfn _set_var(k: &OsStr, v: &OsStr) {\n    os_imp::setenv(k, v).unwrap_or_else(|e| {\n        panic!(\"failed to set environment variable `{:?}` to `{:?}`: {}\",\n               k, v, e)\n    })\n}\n\n/// Removes an environment variable from the environment of the currently running process.\n///\n/// Note that while concurrent access to environment variables is safe in Rust,\n/// some platforms only expose inherently unsafe non-threadsafe APIs for\n/// inspecting the environment. As a result extra care needs to be taken when\n/// auditing calls to unsafe external FFI functions to ensure that any external\n/// environment accesses are properly synchronized with accesses in Rust.\n///\n/// Discussion of this unsafety on Unix may be found in:\n///\n///  - [Austin Group Bugzilla](http://austingroupbugs.net/view.php?id=188)\n///  - [GNU C library Bugzilla](https://sourceware.org/bugzilla/show_bug.cgi?id=15607#c2)\n///\n/// # Panics\n///\n/// This function may panic if `key` is empty, contains an ASCII equals sign\n/// `'='` or the NUL character `'\\0'`, or when the value contains the NUL\n/// character.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// let key = \"KEY\";\n/// env::set_var(key, \"VALUE\");\n/// assert_eq!(env::var(key), Ok(\"VALUE\".to_string()));\n///\n/// env::remove_var(key);\n/// assert!(env::var(key).is_err());\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn remove_var<K: AsRef<OsStr>>(k: K) {\n    _remove_var(k.as_ref())\n}\n\nfn _remove_var(k: &OsStr) {\n    os_imp::unsetenv(k).unwrap_or_else(|e| {\n        panic!(\"failed to remove environment variable `{:?}`: {}\", k, e)\n    })\n}\n\n/// An iterator that splits an environment variable into paths according to\n/// platform-specific conventions.\n///\n/// This structure is created by the [`std::env::split_paths`] function. See its\n/// documentation for more.\n///\n/// [`std::env::split_paths`]: fn.split_paths.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct SplitPaths<'a> { inner: os_imp::SplitPaths<'a> }\n\n/// Parses input according to platform conventions for the `PATH`\n/// environment variable.\n///\n/// Returns an iterator over the paths contained in `unparsed`.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// let key = \"PATH\";\n/// match env::var_os(key) {\n///     Some(paths) => {\n///         for path in env::split_paths(&paths) {\n///             println!(\"'{}'\", path.display());\n///         }\n///     }\n///     None => println!(\"{} is not defined in the environment.\", key)\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths {\n    SplitPaths { inner: os_imp::split_paths(unparsed.as_ref()) }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl<'a> Iterator for SplitPaths<'a> {\n    type Item = PathBuf;\n    fn next(&mut self) -> Option<PathBuf> { self.inner.next() }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<'a> fmt::Debug for SplitPaths<'a> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"SplitPaths { .. }\")\n    }\n}\n\n/// The error type for operations on the `PATH` variable. Possibly returned from\n/// the [`env::join_paths`] function.\n///\n/// [`env::join_paths`]: fn.join_paths.html\n#[derive(Debug)]\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct JoinPathsError {\n    inner: os_imp::JoinPathsError\n}\n\n/// Joins a collection of [`Path`]s appropriately for the `PATH`\n/// environment variable.\n///\n/// # Errors\n///\n/// Returns an [`Err`][err] (containing an error message) if one of the input\n/// [`Path`]s contains an invalid character for constructing the `PATH`\n/// variable (a double quote on Windows or a colon on Unix).\n///\n/// [`Path`]: ../../std/path/struct.Path.html\n/// [`OsString`]: ../../std/ffi/struct.OsString.html\n/// [err]: ../../std/result/enum.Result.html#variant.Err\n///\n/// # Examples\n///\n/// Joining paths on a Unix-like platform:\n///\n/// ```\n/// use std::env;\n/// use std::ffi::OsString;\n/// use std::path::Path;\n///\n/// fn main() -> Result<(), env::JoinPathsError> {\n/// # if cfg!(unix) {\n///     let paths = [Path::new(\"/bin\"), Path::new(\"/usr/bin\")];\n///     let path_os_string = env::join_paths(paths.iter())?;\n///     assert_eq!(path_os_string, OsString::from(\"/bin:/usr/bin\"));\n/// # }\n///     Ok(())\n/// }\n/// ```\n///\n/// Joining a path containing a colon on a Unix-like platform results in an error:\n///\n/// ```\n/// # if cfg!(unix) {\n/// use std::env;\n/// use std::path::Path;\n///\n/// let paths = [Path::new(\"/bin\"), Path::new(\"/usr/bi:n\")];\n/// assert!(env::join_paths(paths.iter()).is_err());\n/// # }\n/// ```\n///\n/// Using `env::join_paths` with `env::spit_paths` to append an item to the `PATH` environment\n/// variable:\n///\n/// ```\n/// use std::env;\n/// use std::path::PathBuf;\n///\n/// fn main() -> Result<(), env::JoinPathsError> {\n///     if let Some(path) = env::var_os(\"PATH\") {\n///         let mut paths = env::split_paths(&path).collect::<Vec<_>>();\n///         paths.push(PathBuf::from(\"/home/xyz/bin\"));\n///         let new_path = env::join_paths(paths)?;\n///         env::set_var(\"PATH\", &new_path);\n///     }\n///\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>\n    where I: IntoIterator<Item=T>, T: AsRef<OsStr>\n{\n    os_imp::join_paths(paths.into_iter()).map_err(|e| {\n        JoinPathsError { inner: e }\n    })\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl fmt::Display for JoinPathsError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.inner.fmt(f)\n    }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Error for JoinPathsError {\n    fn description(&self) -> &str { self.inner.description() }\n}\n\n/// Returns the path of the current user's home directory if known.\n///\n/// # Unix\n///\n/// - Returns the value of the 'HOME' environment variable if it is set\n///   (including to an empty string).\n/// - Otherwise, it tries to determine the home directory by invoking the `getpwuid_r` function\n///   using the UID of the current user. An empty home directory field returned from the\n///   `getpwuid_r` function is considered to be a valid value.\n/// - Returns `None` if the current user has no entry in the /etc/passwd file.\n///\n/// # Windows\n///\n/// - Returns the value of the 'HOME' environment variable if it is set\n///   (including to an empty string).\n/// - Otherwise, returns the value of the 'USERPROFILE' environment variable if it is set\n///   (including to an empty string).\n/// - If both do not exist, [`GetUserProfileDirectory`][msdn] is used to return the path.\n///\n/// [msdn]: https://msdn.microsoft.com/en-us/library/windows/desktop/bb762280(v=vs.85).aspx\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// match env::home_dir() {\n///     Some(path) => println!(\"Your home directory, probably: {}\", path.display()),\n///     None => println!(\"Impossible to get your home dir!\"),\n/// }\n/// ```\n#[rustc_deprecated(since = \"1.29.0\",\n    reason = \"This function's behavior is unexpected and probably not what you want. \\\n              Consider using the home_dir function from https://crates.io/crates/dirs instead.\")]\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn home_dir() -> Option<PathBuf> {\n    os_imp::home_dir()\n}\n\n/// Returns the path of a temporary directory.\n///\n/// # Unix\n///\n/// Returns the value of the `TMPDIR` environment variable if it is\n/// set, otherwise for non-Android it returns `/tmp`. If Android, since there\n/// is no global temporary folder (it is usually allocated per-app), it returns\n/// `/data/local/tmp`.\n///\n/// # Windows\n///\n/// Returns the value of, in order, the `TMP`, `TEMP`,\n/// `USERPROFILE` environment variable if any are set and not the empty\n/// string. Otherwise, `temp_dir` returns the path of the Windows directory.\n/// This behavior is identical to that of [`GetTempPath`][msdn], which this\n/// function uses internally.\n///\n/// [msdn]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa364992(v=vs.85).aspx\n///\n/// ```no_run\n/// use std::env;\n/// use std::fs::File;\n///\n/// fn main() -> std::io::Result<()> {\n///     let mut dir = env::temp_dir();\n///     dir.push(\"foo.txt\");\n///\n///     let f = File::create(dir)?;\n///     Ok(())\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn temp_dir() -> PathBuf {\n    os_imp::temp_dir()\n}\n\n/// Returns the full filesystem path of the current running executable.\n///\n/// # Platform-specific behavior\n///\n/// If the executable was invoked through a symbolic link, some platforms will\n/// return the path of the symbolic link and other platforms will return the\n/// path of the symbolic link\u2019s target.\n///\n/// # Errors\n///\n/// Acquiring the path of the current executable is a platform-specific operation\n/// that can fail for a good number of reasons. Some errors can include, but not\n/// be limited to, filesystem operations failing or general syscall failures.\n///\n/// # Security\n///\n/// The output of this function should not be used in anything that might have\n/// security implications. For example:\n///\n/// ```\n/// fn main() {\n///     println!(\"{:?}\", std::env::current_exe());\n/// }\n/// ```\n///\n/// On Linux systems, if this is compiled as `foo`:\n///\n/// ```bash\n/// $ rustc foo.rs\n/// $ ./foo\n/// Ok(\"/home/alex/foo\")\n/// ```\n///\n/// And you make a hard link of the program:\n///\n/// ```bash\n/// $ ln foo bar\n/// ```\n///\n/// When you run it, you won\u2019t get the path of the original executable, you\u2019ll\n/// get the path of the hard link:\n///\n/// ```bash\n/// $ ./bar\n/// Ok(\"/home/alex/bar\")\n/// ```\n///\n/// This sort of behavior has been known to [lead to privilege escalation] when\n/// used incorrectly.\n///\n/// [lead to privilege escalation]: https://securityvulns.com/Wdocument183.html\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// match env::current_exe() {\n///     Ok(exe_path) => println!(\"Path of this executable is: {}\",\n///                              exe_path.display()),\n///     Err(e) => println!(\"failed to get current exe path: {}\", e),\n/// };\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn current_exe() -> io::Result<PathBuf> {\n    os_imp::current_exe()\n}\n\n/// An iterator over the arguments of a process, yielding a [`String`] value for\n/// each argument.\n///\n/// This struct is created by the [`std::env::args`] function. See its\n/// documentation for more.\n///\n/// The first element is traditionally the path of the executable, but it can be\n/// set to arbitrary text, and may not even exist. This means this property\n/// should not be relied upon for security purposes.\n///\n/// [`String`]: ../string/struct.String.html\n/// [`std::env::args`]: ./fn.args.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct Args { inner: ArgsOs }\n\n/// An iterator over the arguments of a process, yielding an [`OsString`] value\n/// for each argument.\n///\n/// This struct is created by the [`std::env::args_os`] function. See its\n/// documentation for more.\n///\n/// The first element is traditionally the path of the executable, but it can be\n/// set to arbitrary text, and may not even exist. This means this property\n/// should not be relied upon for security purposes.\n///\n/// [`OsString`]: ../ffi/struct.OsString.html\n/// [`std::env::args_os`]: ./fn.args_os.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub struct ArgsOs { inner: sys::args::Args }\n\n/// Returns the arguments which this program was started with (normally passed\n/// via the command line).\n///\n/// The first element is traditionally the path of the executable, but it can be\n/// set to arbitrary text, and may not even exist. This means this property should\n/// not be relied upon for security purposes.\n///\n/// On Unix systems shell usually expands unquoted arguments with glob patterns\n/// (such as `*` and `?`). On Windows this is not done, and such arguments are\n/// passed as-is.\n///\n/// # Panics\n///\n/// The returned iterator will panic during iteration if any argument to the\n/// process is not valid unicode. If this is not desired,\n/// use the [`args_os`] function instead.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// // Prints each argument on a separate line\n/// for argument in env::args() {\n///     println!(\"{}\", argument);\n/// }\n/// ```\n///\n/// [`args_os`]: ./fn.args_os.html\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn args() -> Args {\n    Args { inner: args_os() }\n}\n\n/// Returns the arguments which this program was started with (normally passed\n/// via the command line).\n///\n/// The first element is traditionally the path of the executable, but it can be\n/// set to arbitrary text, and it may not even exist, so this property should\n/// not be relied upon for security purposes.\n///\n/// # Examples\n///\n/// ```\n/// use std::env;\n///\n/// // Prints each argument on a separate line\n/// for argument in env::args_os() {\n///     println!(\"{:?}\", argument);\n/// }\n/// ```\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub fn args_os() -> ArgsOs {\n    ArgsOs { inner: sys::args::args() }\n}\n\n#[stable(feature = \"env_unimpl_send_sync\", since = \"1.26.0\")]\nimpl !Send for Args {}\n\n#[stable(feature = \"env_unimpl_send_sync\", since = \"1.26.0\")]\nimpl !Sync for Args {}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Iterator for Args {\n    type Item = String;\n    fn next(&mut self) -> Option<String> {\n        self.inner.next().map(|s| s.into_string().unwrap())\n    }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl ExactSizeIterator for Args {\n    fn len(&self) -> usize { self.inner.len() }\n    fn is_empty(&self) -> bool { self.inner.is_empty() }\n}\n\n#[stable(feature = \"env_iterators\", since = \"1.12.0\")]\nimpl DoubleEndedIterator for Args {\n    fn next_back(&mut self) -> Option<String> {\n        self.inner.next_back().map(|s| s.into_string().unwrap())\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for Args {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"Args\")\n            .field(\"inner\", &self.inner.inner.inner_debug())\n            .finish()\n    }\n}\n\n#[stable(feature = \"env_unimpl_send_sync\", since = \"1.26.0\")]\nimpl !Send for ArgsOs {}\n\n#[stable(feature = \"env_unimpl_send_sync\", since = \"1.26.0\")]\nimpl !Sync for ArgsOs {}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl Iterator for ArgsOs {\n    type Item = OsString;\n    fn next(&mut self) -> Option<OsString> { self.inner.next() }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }\n}\n\n#[stable(feature = \"env\", since = \"1.0.0\")]\nimpl ExactSizeIterator for ArgsOs {\n    fn len(&self) -> usize { self.inner.len() }\n    fn is_empty(&self) -> bool { self.inner.is_empty() }\n}\n\n#[stable(feature = \"env_iterators\", since = \"1.12.0\")]\nimpl DoubleEndedIterator for ArgsOs {\n    fn next_back(&mut self) -> Option<OsString> { self.inner.next_back() }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for ArgsOs {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_struct(\"ArgsOs\")\n            .field(\"inner\", &self.inner.inner_debug())\n            .finish()\n    }\n}\n\n/// Constants associated with the current target\n#[stable(feature = \"env\", since = \"1.0.0\")]\npub mod consts {\n    use sys::env::os;\n\n    /// A string describing the architecture of the CPU that is currently\n    /// in use.\n    ///\n    /// Some possible values:\n    ///\n    /// - x86\n    /// - x86_64\n    /// - arm\n    /// - aarch64\n    /// - mips\n    /// - mips64\n    /// - powerpc\n    /// - powerpc64\n    /// - s390x\n    /// - sparc64\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const ARCH: &'static str = super::arch::ARCH;\n\n    /// The family of the operating system. Example value is `unix`.\n    ///\n    /// Some possible values:\n    ///\n    /// - unix\n    /// - windows\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const FAMILY: &'static str = os::FAMILY;\n\n    /// A string describing the specific operating system in use.\n    /// Example value is `linux`.\n    ///\n    /// Some possible values:\n    ///\n    /// - linux\n    /// - macos\n    /// - ios\n    /// - freebsd\n    /// - dragonfly\n    /// - bitrig\n    /// - netbsd\n    /// - openbsd\n    /// - solaris\n    /// - android\n    /// - windows\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const OS: &'static str = os::OS;\n\n    /// Specifies the filename prefix used for shared libraries on this\n    /// platform. Example value is `lib`.\n    ///\n    /// Some possible values:\n    ///\n    /// - lib\n    /// - `\"\"` (an empty string)\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const DLL_PREFIX: &'static str = os::DLL_PREFIX;\n\n    /// Specifies the filename suffix used for shared libraries on this\n    /// platform. Example value is `.so`.\n    ///\n    /// Some possible values:\n    ///\n    /// - .so\n    /// - .dylib\n    /// - .dll\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const DLL_SUFFIX: &'static str = os::DLL_SUFFIX;\n\n    /// Specifies the file extension used for shared libraries on this\n    /// platform that goes after the dot. Example value is `so`.\n    ///\n    /// Some possible values:\n    ///\n    /// - so\n    /// - dylib\n    /// - dll\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const DLL_EXTENSION: &'static str = os::DLL_EXTENSION;\n\n    /// Specifies the filename suffix used for executable binaries on this\n    /// platform. Example value is `.exe`.\n    ///\n    /// Some possible values:\n    ///\n    /// - .exe\n    /// - .nexe\n    /// - .pexe\n    /// - `\"\"` (an empty string)\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const EXE_SUFFIX: &'static str = os::EXE_SUFFIX;\n\n    /// Specifies the file extension, if any, used for executable binaries\n    /// on this platform. Example value is `exe`.\n    ///\n    /// Some possible values:\n    ///\n    /// - exe\n    /// - `\"\"` (an empty string)\n    #[stable(feature = \"env\", since = \"1.0.0\")]\n    pub const EXE_EXTENSION: &'static str = os::EXE_EXTENSION;\n}\n\n#[cfg(target_arch = \"x86\")]\nmod arch {\n    pub const ARCH: &'static str = \"x86\";\n}\n\n#[cfg(target_arch = \"x86_64\")]\nmod arch {\n    pub const ARCH: &'static str = \"x86_64\";\n}\n\n#[cfg(target_arch = \"arm\")]\nmod arch {\n    pub const ARCH: &'static str = \"arm\";\n}\n\n#[cfg(target_arch = \"aarch64\")]\nmod arch {\n    pub const ARCH: &'static str = \"aarch64\";\n}\n\n#[cfg(target_arch = \"mips\")]\nmod arch {\n    pub const ARCH: &'static str = \"mips\";\n}\n\n#[cfg(target_arch = \"mips64\")]\nmod arch {\n    pub const ARCH: &'static str = \"mips64\";\n}\n\n#[cfg(target_arch = \"powerpc\")]\nmod arch {\n    pub const ARCH: &'static str = \"powerpc\";\n}\n\n#[cfg(target_arch = \"powerpc64\")]\nmod arch {\n    pub const ARCH: &'static str = \"powerpc64\";\n}\n\n#[cfg(target_arch = \"s390x\")]\nmod arch {\n    pub const ARCH: &'static str = \"s390x\";\n}\n\n#[cfg(target_arch = \"sparc64\")]\nmod arch {\n    pub const ARCH: &'static str = \"sparc64\";\n}\n\n#[cfg(target_arch = \"le32\")]\nmod arch {\n    pub const ARCH: &'static str = \"le32\";\n}\n\n#[cfg(target_arch = \"asmjs\")]\nmod arch {\n    pub const ARCH: &'static str = \"asmjs\";\n}\n\n#[cfg(target_arch = \"wasm32\")]\nmod arch {\n    pub const ARCH: &'static str = \"wasm32\";\n}\n\n#[cfg(test)]\nmod tests {\n    use super::*;\n\n    use path::Path;\n\n    #[test]\n    #[cfg_attr(target_os = \"emscripten\", ignore)]\n    fn test_self_exe_path() {\n        let path = current_exe();\n        assert!(path.is_ok());\n        let path = path.unwrap();\n\n        // Hard to test this function\n        assert!(path.is_absolute());\n    }\n\n    #[test]\n    fn test() {\n        assert!((!Path::new(\"test-path\").is_absolute()));\n\n        current_dir().unwrap();\n    }\n\n    #[test]\n    #[cfg(windows)]\n    fn split_paths_windows() {\n        use path::PathBuf;\n\n        fn check_parse(unparsed: &str, parsed: &[&str]) -> bool {\n            split_paths(unparsed).collect::<Vec<_>>() ==\n                parsed.iter().map(|s| PathBuf::from(*s)).collect::<Vec<_>>()\n        }\n\n        assert!(check_parse(\"\", &mut [\"\"]));\n        assert!(check_parse(r#\"\"\"\"#, &mut [\"\"]));\n        assert!(check_parse(\";;\", &mut [\"\", \"\", \"\"]));\n        assert!(check_parse(r\"c:\\\", &mut [r\"c:\\\"]));\n        assert!(check_parse(r\"c:\\;\", &mut [r\"c:\\\", \"\"]));\n        assert!(check_parse(r\"c:\\;c:\\Program Files\\\",\n                            &mut [r\"c:\\\", r\"c:\\Program Files\\\"]));\n        assert!(check_parse(r#\"c:\\;c:\\\"foo\"\\\"#, &mut [r\"c:\\\", r\"c:\\foo\\\"]));\n        assert!(check_parse(r#\"c:\\;c:\\\"foo;bar\"\\;c:\\baz\"#,\n                            &mut [r\"c:\\\", r\"c:\\foo;bar\\\", r\"c:\\baz\"]));\n    }\n\n    #[test]\n    #[cfg(unix)]\n    fn split_paths_unix() {\n        use path::PathBuf;\n\n        fn check_parse(unparsed: &str, parsed: &[&str]) -> bool {\n            split_paths(unparsed).collect::<Vec<_>>() ==\n                parsed.iter().map(|s| PathBuf::from(*s)).collect::<Vec<_>>()\n        }\n\n        assert!(check_parse(\"\", &mut [\"\"]));\n        assert!(check_parse(\"::\", &mut [\"\", \"\", \"\"]));\n        assert!(check_parse(\"/\", &mut [\"/\"]));\n        assert!(check_parse(\"/:\", &mut [\"/\", \"\"]));\n        assert!(check_parse(\"/:/usr/local\", &mut [\"/\", \"/usr/local\"]));\n    }\n\n    #[test]\n    #[cfg(unix)]\n    fn join_paths_unix() {\n        use ffi::OsStr;\n\n        fn test_eq(input: &[&str], output: &str) -> bool {\n            &*join_paths(input.iter().cloned()).unwrap() ==\n                OsStr::new(output)\n        }\n\n        assert!(test_eq(&[], \"\"));\n        assert!(test_eq(&[\"/bin\", \"/usr/bin\", \"/usr/local/bin\"],\n                         \"/bin:/usr/bin:/usr/local/bin\"));\n        assert!(test_eq(&[\"\", \"/bin\", \"\", \"\", \"/usr/bin\", \"\"],\n                         \":/bin:::/usr/bin:\"));\n        assert!(join_paths([\"/te:st\"].iter().cloned()).is_err());\n    }\n\n    #[test]\n    #[cfg(windows)]\n    fn join_paths_windows() {\n        use ffi::OsStr;\n\n        fn test_eq(input: &[&str], output: &str) -> bool {\n            &*join_paths(input.iter().cloned()).unwrap() ==\n                OsStr::new(output)\n        }\n\n        assert!(test_eq(&[], \"\"));\n        assert!(test_eq(&[r\"c:\\windows\", r\"c:\\\"],\n                        r\"c:\\windows;c:\\\"));\n        assert!(test_eq(&[\"\", r\"c:\\windows\", \"\", \"\", r\"c:\\\", \"\"],\n                        r\";c:\\windows;;;c:\\;\"));\n        assert!(test_eq(&[r\"c:\\te;st\", r\"c:\\\"],\n                        r#\"\"c:\\te;st\";c:\\\"#));\n        assert!(join_paths([r#\"c:\\te\"st\"#].iter().cloned()).is_err());\n    }\n\n    #[test]\n    fn args_debug() {\n        assert_eq!(\n            format!(\"Args {{ inner: {:?} }}\", args().collect::<Vec<_>>()),\n            format!(\"{:?}\", args()));\n        assert_eq!(\n            format!(\"ArgsOs {{ inner: {:?} }}\", args_os().collect::<Vec<_>>()),\n            format!(\"{:?}\", args_os()));\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Panic support in the standard library.\n\n#![stable(feature = \"std_panic\", since = \"1.9.0\")]\n\nuse any::Any;\nuse cell::UnsafeCell;\nuse fmt;\nuse future::Future;\nuse pin::Pin;\nuse ops::{Deref, DerefMut};\nuse panicking;\nuse ptr::{Unique, NonNull};\nuse rc::Rc;\nuse sync::{Arc, Mutex, RwLock, atomic};\nuse task::{LocalWaker, Poll};\nuse thread::Result;\n\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\npub use panicking::{take_hook, set_hook};\n\n#[stable(feature = \"panic_hooks\", since = \"1.10.0\")]\npub use core::panic::{PanicInfo, Location};\n\n/// A marker trait which represents \"panic safe\" types in Rust.\n///\n/// This trait is implemented by default for many types and behaves similarly in\n/// terms of inference of implementation to the [`Send`] and [`Sync`] traits. The\n/// purpose of this trait is to encode what types are safe to cross a [`catch_unwind`]\n/// boundary with no fear of unwind safety.\n///\n/// [`Send`]: ../marker/trait.Send.html\n/// [`Sync`]: ../marker/trait.Sync.html\n/// [`catch_unwind`]: ./fn.catch_unwind.html\n///\n/// ## What is unwind safety?\n///\n/// In Rust a function can \"return\" early if it either panics or calls a\n/// function which transitively panics. This sort of control flow is not always\n/// anticipated, and has the possibility of causing subtle bugs through a\n/// combination of two critical components:\n///\n/// 1. A data structure is in a temporarily invalid state when the thread\n///    panics.\n/// 2. This broken invariant is then later observed.\n///\n/// Typically in Rust, it is difficult to perform step (2) because catching a\n/// panic involves either spawning a thread (which in turns makes it difficult\n/// to later witness broken invariants) or using the `catch_unwind` function in this\n/// module. Additionally, even if an invariant is witnessed, it typically isn't a\n/// problem in Rust because there are no uninitialized values (like in C or C++).\n///\n/// It is possible, however, for **logical** invariants to be broken in Rust,\n/// which can end up causing behavioral bugs. Another key aspect of unwind safety\n/// in Rust is that, in the absence of `unsafe` code, a panic cannot lead to\n/// memory unsafety.\n///\n/// That was a bit of a whirlwind tour of unwind safety, but for more information\n/// about unwind safety and how it applies to Rust, see an [associated RFC][rfc].\n///\n/// [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/1236-stabilize-catch-panic.md\n///\n/// ## What is `UnwindSafe`?\n///\n/// Now that we've got an idea of what unwind safety is in Rust, it's also\n/// important to understand what this trait represents. As mentioned above, one\n/// way to witness broken invariants is through the `catch_unwind` function in this\n/// module as it allows catching a panic and then re-using the environment of\n/// the closure.\n///\n/// Simply put, a type `T` implements `UnwindSafe` if it cannot easily allow\n/// witnessing a broken invariant through the use of `catch_unwind` (catching a\n/// panic). This trait is an auto trait, so it is automatically implemented for\n/// many types, and it is also structurally composed (e.g. a struct is unwind\n/// safe if all of its components are unwind safe).\n///\n/// Note, however, that this is not an unsafe trait, so there is not a succinct\n/// contract that this trait is providing. Instead it is intended as more of a\n/// \"speed bump\" to alert users of `catch_unwind` that broken invariants may be\n/// witnessed and may need to be accounted for.\n///\n/// ## Who implements `UnwindSafe`?\n///\n/// Types such as `&mut T` and `&RefCell<T>` are examples which are **not**\n/// unwind safe. The general idea is that any mutable state which can be shared\n/// across `catch_unwind` is not unwind safe by default. This is because it is very\n/// easy to witness a broken invariant outside of `catch_unwind` as the data is\n/// simply accessed as usual.\n///\n/// Types like `&Mutex<T>`, however, are unwind safe because they implement\n/// poisoning by default. They still allow witnessing a broken invariant, but\n/// they already provide their own \"speed bumps\" to do so.\n///\n/// ## When should `UnwindSafe` be used?\n///\n/// It is not intended that most types or functions need to worry about this trait.\n/// It is only used as a bound on the `catch_unwind` function and as mentioned\n/// above, the lack of `unsafe` means it is mostly an advisory. The\n/// [`AssertUnwindSafe`] wrapper struct can be used to force this trait to be\n/// implemented for any closed over variables passed to `catch_unwind`.\n///\n/// [`AssertUnwindSafe`]: ./struct.AssertUnwindSafe.html\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\n#[rustc_on_unimplemented(\n    message=\"the type `{Self}` may not be safely transferred across an unwind boundary\",\n    label=\"`{Self}` may not be safely transferred across an unwind boundary\",\n)]\npub auto trait UnwindSafe {}\n\n/// A marker trait representing types where a shared reference is considered\n/// unwind safe.\n///\n/// This trait is namely not implemented by [`UnsafeCell`], the root of all\n/// interior mutability.\n///\n/// This is a \"helper marker trait\" used to provide impl blocks for the\n/// [`UnwindSafe`] trait, for more information see that documentation.\n///\n/// [`UnsafeCell`]: ../cell/struct.UnsafeCell.html\n/// [`UnwindSafe`]: ./trait.UnwindSafe.html\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\n#[rustc_on_unimplemented(\n    message=\"the type `{Self}` may contain interior mutability and a reference may not be safely \\\n             transferrable across a catch_unwind boundary\",\n    label=\"`{Self}` may contain interior mutability and a reference may not be safely \\\n           transferrable across a catch_unwind boundary\",\n)]\npub auto trait RefUnwindSafe {}\n\n/// A simple wrapper around a type to assert that it is unwind safe.\n///\n/// When using [`catch_unwind`] it may be the case that some of the closed over\n/// variables are not unwind safe. For example if `&mut T` is captured the\n/// compiler will generate a warning indicating that it is not unwind safe. It\n/// may not be the case, however, that this is actually a problem due to the\n/// specific usage of [`catch_unwind`] if unwind safety is specifically taken into\n/// account. This wrapper struct is useful for a quick and lightweight\n/// annotation that a variable is indeed unwind safe.\n///\n/// [`catch_unwind`]: ./fn.catch_unwind.html\n/// # Examples\n///\n/// One way to use `AssertUnwindSafe` is to assert that the entire closure\n/// itself is unwind safe, bypassing all checks for all variables:\n///\n/// ```\n/// use std::panic::{self, AssertUnwindSafe};\n///\n/// let mut variable = 4;\n///\n/// // This code will not compile because the closure captures `&mut variable`\n/// // which is not considered unwind safe by default.\n///\n/// // panic::catch_unwind(|| {\n/// //     variable += 3;\n/// // });\n///\n/// // This, however, will compile due to the `AssertUnwindSafe` wrapper\n/// let result = panic::catch_unwind(AssertUnwindSafe(|| {\n///     variable += 3;\n/// }));\n/// // ...\n/// ```\n///\n/// Wrapping the entire closure amounts to a blanket assertion that all captured\n/// variables are unwind safe. This has the downside that if new captures are\n/// added in the future, they will also be considered unwind safe. Therefore,\n/// you may prefer to just wrap individual captures, as shown below. This is\n/// more annotation, but it ensures that if a new capture is added which is not\n/// unwind safe, you will get a compilation error at that time, which will\n/// allow you to consider whether that new capture in fact represent a bug or\n/// not.\n///\n/// ```\n/// use std::panic::{self, AssertUnwindSafe};\n///\n/// let mut variable = 4;\n/// let other_capture = 3;\n///\n/// let result = {\n///     let mut wrapper = AssertUnwindSafe(&mut variable);\n///     panic::catch_unwind(move || {\n///         **wrapper += other_capture;\n///     })\n/// };\n/// // ...\n/// ```\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\npub struct AssertUnwindSafe<T>(\n    #[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\n    pub T\n);\n\n// Implementations of the `UnwindSafe` trait:\n//\n// * By default everything is unwind safe\n// * pointers T contains mutability of some form are not unwind safe\n// * Unique, an owning pointer, lifts an implementation\n// * Types like Mutex/RwLock which are explicitly poisoned are unwind safe\n// * Our custom AssertUnwindSafe wrapper is indeed unwind safe\n\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<'a, T: ?Sized> !UnwindSafe for &'a mut T {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<'a, T: RefUnwindSafe + ?Sized> UnwindSafe for &'a T {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for *const T {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for *mut T {}\n#[unstable(feature = \"ptr_internals\", issue = \"0\")]\nimpl<T: UnwindSafe + ?Sized> UnwindSafe for Unique<T> {}\n#[stable(feature = \"nonnull\", since = \"1.25.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for NonNull<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: ?Sized> UnwindSafe for Mutex<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: ?Sized> UnwindSafe for RwLock<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T> UnwindSafe for AssertUnwindSafe<T> {}\n\n// not covered via the Shared impl above b/c the inner contents use\n// Cell/AtomicUsize, but the usage here is unwind safe so we can lift the\n// impl up one level to Arc/Rc itself\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Rc<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: RefUnwindSafe + ?Sized> UnwindSafe for Arc<T> {}\n\n// Pretty simple implementations for the `RefUnwindSafe` marker trait,\n// basically just saying that `UnsafeCell` is the\n// only thing which doesn't implement it (which then transitively applies to\n// everything else).\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T: ?Sized> !RefUnwindSafe for UnsafeCell<T> {}\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T> RefUnwindSafe for AssertUnwindSafe<T> {}\n\n#[stable(feature = \"unwind_safe_lock_refs\", since = \"1.12.0\")]\nimpl<T: ?Sized> RefUnwindSafe for Mutex<T> {}\n#[stable(feature = \"unwind_safe_lock_refs\", since = \"1.12.0\")]\nimpl<T: ?Sized> RefUnwindSafe for RwLock<T> {}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"unwind_safe_atomic_refs\", since = \"1.14.0\")]\nimpl RefUnwindSafe for atomic::AtomicIsize {}\n#[cfg(target_has_atomic = \"8\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicI8 {}\n#[cfg(target_has_atomic = \"16\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicI16 {}\n#[cfg(target_has_atomic = \"32\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicI32 {}\n#[cfg(target_has_atomic = \"64\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicI64 {}\n#[cfg(all(not(stage0), target_has_atomic = \"128\"))]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicI128 {}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"unwind_safe_atomic_refs\", since = \"1.14.0\")]\nimpl RefUnwindSafe for atomic::AtomicUsize {}\n#[cfg(target_has_atomic = \"8\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicU8 {}\n#[cfg(target_has_atomic = \"16\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicU16 {}\n#[cfg(target_has_atomic = \"32\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicU32 {}\n#[cfg(target_has_atomic = \"64\")]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicU64 {}\n#[cfg(all(not(stage0), target_has_atomic = \"128\"))]\n#[unstable(feature = \"integer_atomics\", issue = \"32976\")]\nimpl RefUnwindSafe for atomic::AtomicU128 {}\n\n#[cfg(target_has_atomic = \"8\")]\n#[stable(feature = \"unwind_safe_atomic_refs\", since = \"1.14.0\")]\nimpl RefUnwindSafe for atomic::AtomicBool {}\n\n#[cfg(target_has_atomic = \"ptr\")]\n#[stable(feature = \"unwind_safe_atomic_refs\", since = \"1.14.0\")]\nimpl<T> RefUnwindSafe for atomic::AtomicPtr<T> {}\n\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T> Deref for AssertUnwindSafe<T> {\n    type Target = T;\n\n    fn deref(&self) -> &T {\n        &self.0\n    }\n}\n\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<T> DerefMut for AssertUnwindSafe<T> {\n    fn deref_mut(&mut self) -> &mut T {\n        &mut self.0\n    }\n}\n\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\nimpl<R, F: FnOnce() -> R> FnOnce<()> for AssertUnwindSafe<F> {\n    type Output = R;\n\n    extern \"rust-call\" fn call_once(self, _args: ()) -> R {\n        (self.0)()\n    }\n}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl<T: fmt::Debug> fmt::Debug for AssertUnwindSafe<T> {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.debug_tuple(\"AssertUnwindSafe\")\n            .field(&self.0)\n            .finish()\n    }\n}\n\n#[unstable(feature = \"futures_api\", issue = \"50547\")]\nimpl<'a, F: Future> Future for AssertUnwindSafe<F> {\n    type Output = F::Output;\n\n    fn poll(self: Pin<&mut Self>, lw: &LocalWaker) -> Poll<Self::Output> {\n        let pinned_field = unsafe { Pin::map_unchecked_mut(self, |x| &mut x.0) };\n        F::poll(pinned_field, lw)\n    }\n}\n\n/// Invokes a closure, capturing the cause of an unwinding panic if one occurs.\n///\n/// This function will return `Ok` with the closure's result if the closure\n/// does not panic, and will return `Err(cause)` if the closure panics. The\n/// `cause` returned is the object with which panic was originally invoked.\n///\n/// It is currently undefined behavior to unwind from Rust code into foreign\n/// code, so this function is particularly useful when Rust is called from\n/// another language (normally C). This can run arbitrary Rust code, capturing a\n/// panic and allowing a graceful handling of the error.\n///\n/// It is **not** recommended to use this function for a general try/catch\n/// mechanism. The [`Result`] type is more appropriate to use for functions that\n/// can fail on a regular basis. Additionally, this function is not guaranteed\n/// to catch all panics, see the \"Notes\" section below.\n///\n/// [`Result`]: ../result/enum.Result.html\n///\n/// The closure provided is required to adhere to the [`UnwindSafe`] trait to ensure\n/// that all captured variables are safe to cross this boundary. The purpose of\n/// this bound is to encode the concept of [exception safety][rfc] in the type\n/// system. Most usage of this function should not need to worry about this\n/// bound as programs are naturally unwind safe without `unsafe` code. If it\n/// becomes a problem the [`AssertUnwindSafe`] wrapper struct can be used to quickly\n/// assert that the usage here is indeed unwind safe.\n///\n/// [`AssertUnwindSafe`]: ./struct.AssertUnwindSafe.html\n/// [`UnwindSafe`]: ./trait.UnwindSafe.html\n///\n/// [rfc]: https://github.com/rust-lang/rfcs/blob/master/text/1236-stabilize-catch-panic.md\n///\n/// # Notes\n///\n/// Note that this function **may not catch all panics** in Rust. A panic in\n/// Rust is not always implemented via unwinding, but can be implemented by\n/// aborting the process as well. This function *only* catches unwinding panics,\n/// not those that abort the process.\n///\n/// # Examples\n///\n/// ```\n/// use std::panic;\n///\n/// let result = panic::catch_unwind(|| {\n///     println!(\"hello!\");\n/// });\n/// assert!(result.is_ok());\n///\n/// let result = panic::catch_unwind(|| {\n///     panic!(\"oh no!\");\n/// });\n/// assert!(result.is_err());\n/// ```\n#[stable(feature = \"catch_unwind\", since = \"1.9.0\")]\npub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {\n    unsafe {\n        panicking::try(f)\n    }\n}\n\n/// Triggers a panic without invoking the panic hook.\n///\n/// This is designed to be used in conjunction with [`catch_unwind`] to, for\n/// example, carry a panic across a layer of C code.\n///\n/// [`catch_unwind`]: ./fn.catch_unwind.html\n///\n/// # Notes\n///\n/// Note that panics in Rust are not always implemented via unwinding, but they\n/// may be implemented by aborting the process. If this function is called when\n/// panics are implemented this way then this function will abort the process,\n/// not trigger an unwind.\n///\n/// # Examples\n///\n/// ```should_panic\n/// use std::panic;\n///\n/// let result = panic::catch_unwind(|| {\n///     panic!(\"oh no!\");\n/// });\n///\n/// if let Err(err) = result {\n///     panic::resume_unwind(err);\n/// }\n/// ```\n#[stable(feature = \"resume_unwind\", since = \"1.9.0\")]\npub fn resume_unwind(payload: Box<dyn Any + Send>) -> ! {\n    panicking::update_count_then_panic(payload)\n}\n","// Copyright 2013 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Runtime services\n//!\n//! The `rt` module provides a narrow set of runtime services,\n//! including the global heap (exported in `heap`) and unwinding and\n//! backtrace support. The APIs in this module are highly unstable,\n//! and should be considered as private implementation details for the\n//! time being.\n\n#![unstable(feature = \"rt\",\n            reason = \"this public module should not exist and is highly likely \\\n                      to disappear\",\n            issue = \"0\")]\n#![doc(hidden)]\n\n\n// Re-export some of our utilities which are expected by other crates.\npub use panicking::{begin_panic, begin_panic_fmt, update_panic_count};\n\n// To reduce the generated code of the new `lang_start`, this function is doing\n// the real work.\n#[cfg(not(test))]\nfn lang_start_internal(main: &(dyn Fn() -> i32 + Sync + ::panic::RefUnwindSafe),\n                       argc: isize, argv: *const *const u8) -> isize {\n    use panic;\n    use sys;\n    use sys_common;\n    use sys_common::thread_info;\n    use thread::Thread;\n\n    sys::init();\n\n    unsafe {\n        let main_guard = sys::thread::guard::init();\n        sys::stack_overflow::init();\n\n        // Next, set up the current Thread with the guard information we just\n        // created. Note that this isn't necessary in general for new threads,\n        // but we just do this to name the main thread and to give it correct\n        // info about the stack bounds.\n        let thread = Thread::new(Some(\"main\".to_owned()));\n        thread_info::set(main_guard, thread);\n\n        // Store our args if necessary in a squirreled away location\n        sys::args::init(argc, argv);\n\n        // Let's run some code!\n        #[cfg(feature = \"backtrace\")]\n        let exit_code = panic::catch_unwind(|| {\n            ::sys_common::backtrace::__rust_begin_short_backtrace(move || main())\n        });\n        #[cfg(not(feature = \"backtrace\"))]\n        let exit_code = panic::catch_unwind(move || main());\n\n        sys_common::cleanup();\n        exit_code.unwrap_or(101) as isize\n    }\n}\n\n#[cfg(not(test))]\n#[lang = \"start\"]\nfn lang_start<T: ::process::Termination + 'static>\n    (main: fn() -> T, argc: isize, argv: *const *const u8) -> isize\n{\n    lang_start_internal(&move || main().report(), argc, argv)\n}\n\n/// Function used for reverting changes to the main stack before setrlimit().\n/// This is POSIX (non-Linux) specific and unlikely to be directly stabilized.\n#[unstable(feature = \"rustc_stack_internals\", issue = \"0\")]\npub unsafe fn deinit_stack_guard() {\n    ::sys::thread::guard::deinit();\n}\n\n/// Function used for resetting the main stack guard address after setrlimit().\n/// This is POSIX specific and unlikely to be directly stabilized.\n#[unstable(feature = \"rustc_stack_internals\", issue = \"0\")]\npub unsafe fn update_stack_guard() {\n    let main_guard = ::sys::thread::guard::init();\n    ::sys_common::thread_info::reset_guard(main_guard);\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! UTF-8 and UTF-16 decoding iterators\n\nuse fmt;\nuse super::from_u32_unchecked;\n\n/// An iterator that decodes UTF-16 encoded code points from an iterator of `u16`s.\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\n#[derive(Clone, Debug)]\npub struct DecodeUtf16<I>\n    where I: Iterator<Item = u16>\n{\n    iter: I,\n    buf: Option<u16>,\n}\n\n/// An error that can be returned when decoding UTF-16 code points.\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\n#[derive(Debug, Clone, Eq, PartialEq)]\npub struct DecodeUtf16Error {\n    code: u16,\n}\n\n/// Create an iterator over the UTF-16 encoded code points in `iter`,\n/// returning unpaired surrogates as `Err`s.\n///\n/// # Examples\n///\n/// Basic usage:\n///\n/// ```\n/// use std::char::decode_utf16;\n///\n/// fn main() {\n///     // \ud834\udd1emus<invalid>ic<invalid>\n///     let v = [0xD834, 0xDD1E, 0x006d, 0x0075,\n///              0x0073, 0xDD1E, 0x0069, 0x0063,\n///              0xD834];\n///\n///     assert_eq!(decode_utf16(v.iter().cloned())\n///                            .map(|r| r.map_err(|e| e.unpaired_surrogate()))\n///                            .collect::<Vec<_>>(),\n///                vec![Ok('\ud834\udd1e'),\n///                     Ok('m'), Ok('u'), Ok('s'),\n///                     Err(0xDD1E),\n///                     Ok('i'), Ok('c'),\n///                     Err(0xD834)]);\n/// }\n/// ```\n///\n/// A lossy decoder can be obtained by replacing `Err` results with the replacement character:\n///\n/// ```\n/// use std::char::{decode_utf16, REPLACEMENT_CHARACTER};\n///\n/// fn main() {\n///     // \ud834\udd1emus<invalid>ic<invalid>\n///     let v = [0xD834, 0xDD1E, 0x006d, 0x0075,\n///              0x0073, 0xDD1E, 0x0069, 0x0063,\n///              0xD834];\n///\n///     assert_eq!(decode_utf16(v.iter().cloned())\n///                    .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))\n///                    .collect::<String>(),\n///                \"\ud834\udd1emus\ufffdic\ufffd\");\n/// }\n/// ```\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\n#[inline]\npub fn decode_utf16<I: IntoIterator<Item = u16>>(iter: I) -> DecodeUtf16<I::IntoIter> {\n    DecodeUtf16 {\n        iter: iter.into_iter(),\n        buf: None,\n    }\n}\n\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\nimpl<I: Iterator<Item = u16>> Iterator for DecodeUtf16<I> {\n    type Item = Result<char, DecodeUtf16Error>;\n\n    fn next(&mut self) -> Option<Result<char, DecodeUtf16Error>> {\n        let u = match self.buf.take() {\n            Some(buf) => buf,\n            None => self.iter.next()?\n        };\n\n        if u < 0xD800 || 0xDFFF < u {\n            // not a surrogate\n            Some(Ok(unsafe { from_u32_unchecked(u as u32) }))\n        } else if u >= 0xDC00 {\n            // a trailing surrogate\n            Some(Err(DecodeUtf16Error { code: u }))\n        } else {\n            let u2 = match self.iter.next() {\n                Some(u2) => u2,\n                // eof\n                None => return Some(Err(DecodeUtf16Error { code: u })),\n            };\n            if u2 < 0xDC00 || u2 > 0xDFFF {\n                // not a trailing surrogate so we're not a valid\n                // surrogate pair, so rewind to redecode u2 next time.\n                self.buf = Some(u2);\n                return Some(Err(DecodeUtf16Error { code: u }));\n            }\n\n            // all ok, so lets decode it.\n            let c = (((u - 0xD800) as u32) << 10 | (u2 - 0xDC00) as u32) + 0x1_0000;\n            Some(Ok(unsafe { from_u32_unchecked(c) }))\n        }\n    }\n\n    #[inline]\n    fn size_hint(&self) -> (usize, Option<usize>) {\n        let (low, high) = self.iter.size_hint();\n        // we could be entirely valid surrogates (2 elements per\n        // char), or entirely non-surrogates (1 element per char)\n        (low / 2, high)\n    }\n}\n\nimpl DecodeUtf16Error {\n    /// Returns the unpaired surrogate which caused this error.\n    #[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\n    pub fn unpaired_surrogate(&self) -> u16 {\n        self.code\n    }\n}\n\n#[stable(feature = \"decode_utf16\", since = \"1.9.0\")]\nimpl fmt::Display for DecodeUtf16Error {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        write!(f, \"unpaired surrogate found: {:x}\", self.code)\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Almost direct (but slightly optimized) Rust translation of Figure 3 of \"Printing\n//! Floating-Point Numbers Quickly and Accurately\"[^1].\n//!\n//! [^1]: Burger, R. G. and Dybvig, R. K. 1996. Printing floating-point numbers\n//!   quickly and accurately. SIGPLAN Not. 31, 5 (May. 1996), 108-116.\n\nuse cmp::Ordering;\n\nuse num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up};\nuse num::flt2dec::estimator::estimate_scaling_factor;\nuse num::bignum::Digit32 as Digit;\nuse num::bignum::Big32x40 as Big;\n\nstatic POW10: [Digit; 10] = [1, 10, 100, 1000, 10000, 100000,\n                             1000000, 10000000, 100000000, 1000000000];\nstatic TWOPOW10: [Digit; 10] = [2, 20, 200, 2000, 20000, 200000,\n                                2000000, 20000000, 200000000, 2000000000];\n\n// precalculated arrays of `Digit`s for 10^(2^n)\nstatic POW10TO16: [Digit; 2] = [0x6fc10000, 0x2386f2];\nstatic POW10TO32: [Digit; 4] = [0, 0x85acef81, 0x2d6d415b, 0x4ee];\nstatic POW10TO64: [Digit; 7] = [0, 0, 0xbf6a1f01, 0x6e38ed64, 0xdaa797ed, 0xe93ff9f4, 0x184f03];\nstatic POW10TO128: [Digit; 14] =\n    [0, 0, 0, 0, 0x2e953e01, 0x3df9909, 0xf1538fd, 0x2374e42f, 0xd3cff5ec, 0xc404dc08,\n     0xbccdb0da, 0xa6337f19, 0xe91f2603, 0x24e];\nstatic POW10TO256: [Digit; 27] =\n    [0, 0, 0, 0, 0, 0, 0, 0, 0x982e7c01, 0xbed3875b, 0xd8d99f72, 0x12152f87, 0x6bde50c6,\n     0xcf4a6e70, 0xd595d80f, 0x26b2716e, 0xadc666b0, 0x1d153624, 0x3c42d35a, 0x63ff540e,\n     0xcc5573c0, 0x65f9ef17, 0x55bc28f2, 0x80dcc7f7, 0xf46eeddc, 0x5fdcefce, 0x553f7];\n\n#[doc(hidden)]\npub fn mul_pow10(x: &mut Big, n: usize) -> &mut Big {\n    debug_assert!(n < 512);\n    if n &   7 != 0 { x.mul_small(POW10[n & 7]); }\n    if n &   8 != 0 { x.mul_small(POW10[8]); }\n    if n &  16 != 0 { x.mul_digits(&POW10TO16); }\n    if n &  32 != 0 { x.mul_digits(&POW10TO32); }\n    if n &  64 != 0 { x.mul_digits(&POW10TO64); }\n    if n & 128 != 0 { x.mul_digits(&POW10TO128); }\n    if n & 256 != 0 { x.mul_digits(&POW10TO256); }\n    x\n}\n\nfn div_2pow10(x: &mut Big, mut n: usize) -> &mut Big {\n    let largest = POW10.len() - 1;\n    while n > largest {\n        x.div_rem_small(POW10[largest]);\n        n -= largest;\n    }\n    x.div_rem_small(TWOPOW10[n]);\n    x\n}\n\n// only usable when `x < 16 * scale`; `scaleN` should be `scale.mul_small(N)`\nfn div_rem_upto_16<'a>(x: &'a mut Big, scale: &Big,\n                       scale2: &Big, scale4: &Big, scale8: &Big) -> (u8, &'a mut Big) {\n    let mut d = 0;\n    if *x >= *scale8 { x.sub(scale8); d += 8; }\n    if *x >= *scale4 { x.sub(scale4); d += 4; }\n    if *x >= *scale2 { x.sub(scale2); d += 2; }\n    if *x >= *scale  { x.sub(scale);  d += 1; }\n    debug_assert!(*x < *scale);\n    (d, x)\n}\n\n/// The shortest mode implementation for Dragon.\npub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp*/ i16) {\n    // the number `v` to format is known to be:\n    // - equal to `mant * 2^exp`;\n    // - preceded by `(mant - 2 * minus) * 2^exp` in the original type; and\n    // - followed by `(mant + 2 * plus) * 2^exp` in the original type.\n    //\n    // obviously, `minus` and `plus` cannot be zero. (for infinities, we use out-of-range values.)\n    // also we assume that at least one digit is generated, i.e. `mant` cannot be zero too.\n    //\n    // this also means that any number between `low = (mant - minus) * 2^exp` and\n    // `high = (mant + plus) * 2^exp` will map to this exact floating point number,\n    // with bounds included when the original mantissa was even (i.e. `!mant_was_odd`).\n\n    assert!(d.mant > 0);\n    assert!(d.minus > 0);\n    assert!(d.plus > 0);\n    assert!(d.mant.checked_add(d.plus).is_some());\n    assert!(d.mant.checked_sub(d.minus).is_some());\n    assert!(buf.len() >= MAX_SIG_DIGITS);\n\n    // `a.cmp(&b) < rounding` is `if d.inclusive {a <= b} else {a < b}`\n    let rounding = if d.inclusive {Ordering::Greater} else {Ordering::Equal};\n\n    // estimate `k_0` from original inputs satisfying `10^(k_0-1) < high <= 10^(k_0+1)`.\n    // the tight bound `k` satisfying `10^(k-1) < high <= 10^k` is calculated later.\n    let mut k = estimate_scaling_factor(d.mant + d.plus, d.exp);\n\n    // convert `{mant, plus, minus} * 2^exp` into the fractional form so that:\n    // - `v = mant / scale`\n    // - `low = (mant - minus) / scale`\n    // - `high = (mant + plus) / scale`\n    let mut mant = Big::from_u64(d.mant);\n    let mut minus = Big::from_u64(d.minus);\n    let mut plus = Big::from_u64(d.plus);\n    let mut scale = Big::from_small(1);\n    if d.exp < 0 {\n        scale.mul_pow2(-d.exp as usize);\n    } else {\n        mant.mul_pow2(d.exp as usize);\n        minus.mul_pow2(d.exp as usize);\n        plus.mul_pow2(d.exp as usize);\n    }\n\n    // divide `mant` by `10^k`. now `scale / 10 < mant + plus <= scale * 10`.\n    if k >= 0 {\n        mul_pow10(&mut scale, k as usize);\n    } else {\n        mul_pow10(&mut mant, -k as usize);\n        mul_pow10(&mut minus, -k as usize);\n        mul_pow10(&mut plus, -k as usize);\n    }\n\n    // fixup when `mant + plus > scale` (or `>=`).\n    // we are not actually modifying `scale`, since we can skip the initial multiplication instead.\n    // now `scale < mant + plus <= scale * 10` and we are ready to generate digits.\n    //\n    // note that `d[0]` *can* be zero, when `scale - plus < mant < scale`.\n    // in this case rounding-up condition (`up` below) will be triggered immediately.\n    if scale.cmp(mant.clone().add(&plus)) < rounding {\n        // equivalent to scaling `scale` by 10\n        k += 1;\n    } else {\n        mant.mul_small(10);\n        minus.mul_small(10);\n        plus.mul_small(10);\n    }\n\n    // cache `(2, 4, 8) * scale` for digit generation.\n    let mut scale2 = scale.clone(); scale2.mul_pow2(1);\n    let mut scale4 = scale.clone(); scale4.mul_pow2(2);\n    let mut scale8 = scale.clone(); scale8.mul_pow2(3);\n\n    let mut down;\n    let mut up;\n    let mut i = 0;\n    loop {\n        // invariants, where `d[0..n-1]` are digits generated so far:\n        // - `v = mant / scale * 10^(k-n-1) + d[0..n-1] * 10^(k-n)`\n        // - `v - low = minus / scale * 10^(k-n-1)`\n        // - `high - v = plus / scale * 10^(k-n-1)`\n        // - `(mant + plus) / scale <= 10` (thus `mant / scale < 10`)\n        // where `d[i..j]` is a shorthand for `d[i] * 10^(j-i) + ... + d[j-1] * 10 + d[j]`.\n\n        // generate one digit: `d[n] = floor(mant / scale) < 10`.\n        let (d, _) = div_rem_upto_16(&mut mant, &scale, &scale2, &scale4, &scale8);\n        debug_assert!(d < 10);\n        buf[i] = b'0' + d;\n        i += 1;\n\n        // this is a simplified description of the modified Dragon algorithm.\n        // many intermediate derivations and completeness arguments are omitted for convenience.\n        //\n        // start with modified invariants, as we've updated `n`:\n        // - `v = mant / scale * 10^(k-n) + d[0..n-1] * 10^(k-n)`\n        // - `v - low = minus / scale * 10^(k-n)`\n        // - `high - v = plus / scale * 10^(k-n)`\n        //\n        // assume that `d[0..n-1]` is the shortest representation between `low` and `high`,\n        // i.e. `d[0..n-1]` satisfies both of the following but `d[0..n-2]` doesn't:\n        // - `low < d[0..n-1] * 10^(k-n) < high` (bijectivity: digits round to `v`); and\n        // - `abs(v / 10^(k-n) - d[0..n-1]) <= 1/2` (the last digit is correct).\n        //\n        // the second condition simplifies to `2 * mant <= scale`.\n        // solving invariants in terms of `mant`, `low` and `high` yields\n        // a simpler version of the first condition: `-plus < mant < minus`.\n        // since `-plus < 0 <= mant`, we have the correct shortest representation\n        // when `mant < minus` and `2 * mant <= scale`.\n        // (the former becomes `mant <= minus` when the original mantissa is even.)\n        //\n        // when the second doesn't hold (`2 * mant > scale`), we need to increase the last digit.\n        // this is enough for restoring that condition: we already know that\n        // the digit generation guarantees `0 <= v / 10^(k-n) - d[0..n-1] < 1`.\n        // in this case, the first condition becomes `-plus < mant - scale < minus`.\n        // since `mant < scale` after the generation, we have `scale < mant + plus`.\n        // (again, this becomes `scale <= mant + plus` when the original mantissa is even.)\n        //\n        // in short:\n        // - stop and round `down` (keep digits as is) when `mant < minus` (or `<=`).\n        // - stop and round `up` (increase the last digit) when `scale < mant + plus` (or `<=`).\n        // - keep generating otherwise.\n        down = mant.cmp(&minus) < rounding;\n        up = scale.cmp(mant.clone().add(&plus)) < rounding;\n        if down || up { break; } // we have the shortest representation, proceed to the rounding\n\n        // restore the invariants.\n        // this makes the algorithm always terminating: `minus` and `plus` always increases,\n        // but `mant` is clipped modulo `scale` and `scale` is fixed.\n        mant.mul_small(10);\n        minus.mul_small(10);\n        plus.mul_small(10);\n    }\n\n    // rounding up happens when\n    // i) only the rounding-up condition was triggered, or\n    // ii) both conditions were triggered and tie breaking prefers rounding up.\n    if up && (!down || *mant.mul_pow2(1) >= scale) {\n        // if rounding up changes the length, the exponent should also change.\n        // it seems that this condition is very hard to satisfy (possibly impossible),\n        // but we are just being safe and consistent here.\n        if let Some(c) = round_up(buf, i) {\n            buf[i] = c;\n            i += 1;\n            k += 1;\n        }\n    }\n\n    (i, k)\n}\n\n/// The exact and fixed mode implementation for Dragon.\npub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usize, /*exp*/ i16) {\n    assert!(d.mant > 0);\n    assert!(d.minus > 0);\n    assert!(d.plus > 0);\n    assert!(d.mant.checked_add(d.plus).is_some());\n    assert!(d.mant.checked_sub(d.minus).is_some());\n\n    // estimate `k_0` from original inputs satisfying `10^(k_0-1) < v <= 10^(k_0+1)`.\n    let mut k = estimate_scaling_factor(d.mant, d.exp);\n\n    // `v = mant / scale`.\n    let mut mant = Big::from_u64(d.mant);\n    let mut scale = Big::from_small(1);\n    if d.exp < 0 {\n        scale.mul_pow2(-d.exp as usize);\n    } else {\n        mant.mul_pow2(d.exp as usize);\n    }\n\n    // divide `mant` by `10^k`. now `scale / 10 < mant <= scale * 10`.\n    if k >= 0 {\n        mul_pow10(&mut scale, k as usize);\n    } else {\n        mul_pow10(&mut mant, -k as usize);\n    }\n\n    // fixup when `mant + plus >= scale`, where `plus / scale = 10^-buf.len() / 2`.\n    // in order to keep the fixed-size bignum, we actually use `mant + floor(plus) >= scale`.\n    // we are not actually modifying `scale`, since we can skip the initial multiplication instead.\n    // again with the shortest algorithm, `d[0]` can be zero but will be eventually rounded up.\n    if *div_2pow10(&mut scale.clone(), buf.len()).add(&mant) >= scale {\n        // equivalent to scaling `scale` by 10\n        k += 1;\n    } else {\n        mant.mul_small(10);\n    }\n\n    // if we are working with the last-digit limitation, we need to shorten the buffer\n    // before the actual rendering in order to avoid double rounding.\n    // note that we have to enlarge the buffer again when rounding up happens!\n    let mut len = if k < limit {\n        // oops, we cannot even produce *one* digit.\n        // this is possible when, say, we've got something like 9.5 and it's being rounded to 10.\n        // we return an empty buffer, with an exception of the later rounding-up case\n        // which occurs when `k == limit` and has to produce exactly one digit.\n        0\n    } else if ((k as i32 - limit as i32) as usize) < buf.len() {\n        (k - limit) as usize\n    } else {\n        buf.len()\n    };\n\n    if len > 0 {\n        // cache `(2, 4, 8) * scale` for digit generation.\n        // (this can be expensive, so do not calculate them when the buffer is empty.)\n        let mut scale2 = scale.clone(); scale2.mul_pow2(1);\n        let mut scale4 = scale.clone(); scale4.mul_pow2(2);\n        let mut scale8 = scale.clone(); scale8.mul_pow2(3);\n\n        for i in 0..len {\n            if mant.is_zero() { // following digits are all zeroes, we stop here\n                // do *not* try to perform rounding! rather, fill remaining digits.\n                for c in &mut buf[i..len] { *c = b'0'; }\n                return (len, k);\n            }\n\n            let mut d = 0;\n            if mant >= scale8 { mant.sub(&scale8); d += 8; }\n            if mant >= scale4 { mant.sub(&scale4); d += 4; }\n            if mant >= scale2 { mant.sub(&scale2); d += 2; }\n            if mant >= scale  { mant.sub(&scale);  d += 1; }\n            debug_assert!(mant < scale);\n            debug_assert!(d < 10);\n            buf[i] = b'0' + d;\n            mant.mul_small(10);\n        }\n    }\n\n    // rounding up if we stop in the middle of digits\n    // if the following digits are exactly 5000..., check the prior digit and try to\n    // round to even (i.e. avoid rounding up when the prior digit is even).\n    let order = mant.cmp(scale.mul_small(5));\n    if order == Ordering::Greater || (order == Ordering::Equal &&\n                                      (len == 0 || buf[len-1] & 1 == 1)) {\n        // if rounding up changes the length, the exponent should also change.\n        // but we've been requested a fixed number of digits, so do not alter the buffer...\n        if let Some(c) = round_up(buf, len) {\n            // ...unless we've been requested the fixed precision instead.\n            // we also need to check that, if the original buffer was empty,\n            // the additional digit can only be added when `k == limit` (edge case).\n            k += 1;\n            if k > limit && len < buf.len() {\n                buf[len] = c;\n                len += 1;\n            }\n        }\n    }\n\n    (len, k)\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Rust adaptation of the Grisu3 algorithm described in \"Printing Floating-Point Numbers Quickly\n//! and Accurately with Integers\"[^1]. It uses about 1KB of precomputed table, and in turn, it's\n//! very quick for most inputs.\n//!\n//! [^1]: Florian Loitsch. 2010. Printing floating-point numbers quickly and\n//!   accurately with integers. SIGPLAN Not. 45, 6 (June 2010), 233-243.\n\nuse num::diy_float::Fp;\nuse num::flt2dec::{Decoded, MAX_SIG_DIGITS, round_up};\n\n\n// see the comments in `format_shortest_opt` for the rationale.\n#[doc(hidden)] pub const ALPHA: i16 = -60;\n#[doc(hidden)] pub const GAMMA: i16 = -32;\n\n/*\n# the following Python code generates this table:\nfor i in xrange(-308, 333, 8):\n    if i >= 0: f = 10**i; e = 0\n    else: f = 2**(80-4*i) // 10**-i; e = 4 * i - 80\n    l = f.bit_length()\n    f = ((f << 64 >> (l-1)) + 1) >> 1; e += l - 64\n    print '    (%#018x, %5d, %4d),' % (f, e, i)\n*/\n\n#[doc(hidden)]\npub static CACHED_POW10: [(u64, i16, i16); 81] = [ // (f, e, k)\n    (0xe61acf033d1a45df, -1087, -308),\n    (0xab70fe17c79ac6ca, -1060, -300),\n    (0xff77b1fcbebcdc4f, -1034, -292),\n    (0xbe5691ef416bd60c, -1007, -284),\n    (0x8dd01fad907ffc3c,  -980, -276),\n    (0xd3515c2831559a83,  -954, -268),\n    (0x9d71ac8fada6c9b5,  -927, -260),\n    (0xea9c227723ee8bcb,  -901, -252),\n    (0xaecc49914078536d,  -874, -244),\n    (0x823c12795db6ce57,  -847, -236),\n    (0xc21094364dfb5637,  -821, -228),\n    (0x9096ea6f3848984f,  -794, -220),\n    (0xd77485cb25823ac7,  -768, -212),\n    (0xa086cfcd97bf97f4,  -741, -204),\n    (0xef340a98172aace5,  -715, -196),\n    (0xb23867fb2a35b28e,  -688, -188),\n    (0x84c8d4dfd2c63f3b,  -661, -180),\n    (0xc5dd44271ad3cdba,  -635, -172),\n    (0x936b9fcebb25c996,  -608, -164),\n    (0xdbac6c247d62a584,  -582, -156),\n    (0xa3ab66580d5fdaf6,  -555, -148),\n    (0xf3e2f893dec3f126,  -529, -140),\n    (0xb5b5ada8aaff80b8,  -502, -132),\n    (0x87625f056c7c4a8b,  -475, -124),\n    (0xc9bcff6034c13053,  -449, -116),\n    (0x964e858c91ba2655,  -422, -108),\n    (0xdff9772470297ebd,  -396, -100),\n    (0xa6dfbd9fb8e5b88f,  -369,  -92),\n    (0xf8a95fcf88747d94,  -343,  -84),\n    (0xb94470938fa89bcf,  -316,  -76),\n    (0x8a08f0f8bf0f156b,  -289,  -68),\n    (0xcdb02555653131b6,  -263,  -60),\n    (0x993fe2c6d07b7fac,  -236,  -52),\n    (0xe45c10c42a2b3b06,  -210,  -44),\n    (0xaa242499697392d3,  -183,  -36),\n    (0xfd87b5f28300ca0e,  -157,  -28),\n    (0xbce5086492111aeb,  -130,  -20),\n    (0x8cbccc096f5088cc,  -103,  -12),\n    (0xd1b71758e219652c,   -77,   -4),\n    (0x9c40000000000000,   -50,    4),\n    (0xe8d4a51000000000,   -24,   12),\n    (0xad78ebc5ac620000,     3,   20),\n    (0x813f3978f8940984,    30,   28),\n    (0xc097ce7bc90715b3,    56,   36),\n    (0x8f7e32ce7bea5c70,    83,   44),\n    (0xd5d238a4abe98068,   109,   52),\n    (0x9f4f2726179a2245,   136,   60),\n    (0xed63a231d4c4fb27,   162,   68),\n    (0xb0de65388cc8ada8,   189,   76),\n    (0x83c7088e1aab65db,   216,   84),\n    (0xc45d1df942711d9a,   242,   92),\n    (0x924d692ca61be758,   269,  100),\n    (0xda01ee641a708dea,   295,  108),\n    (0xa26da3999aef774a,   322,  116),\n    (0xf209787bb47d6b85,   348,  124),\n    (0xb454e4a179dd1877,   375,  132),\n    (0x865b86925b9bc5c2,   402,  140),\n    (0xc83553c5c8965d3d,   428,  148),\n    (0x952ab45cfa97a0b3,   455,  156),\n    (0xde469fbd99a05fe3,   481,  164),\n    (0xa59bc234db398c25,   508,  172),\n    (0xf6c69a72a3989f5c,   534,  180),\n    (0xb7dcbf5354e9bece,   561,  188),\n    (0x88fcf317f22241e2,   588,  196),\n    (0xcc20ce9bd35c78a5,   614,  204),\n    (0x98165af37b2153df,   641,  212),\n    (0xe2a0b5dc971f303a,   667,  220),\n    (0xa8d9d1535ce3b396,   694,  228),\n    (0xfb9b7cd9a4a7443c,   720,  236),\n    (0xbb764c4ca7a44410,   747,  244),\n    (0x8bab8eefb6409c1a,   774,  252),\n    (0xd01fef10a657842c,   800,  260),\n    (0x9b10a4e5e9913129,   827,  268),\n    (0xe7109bfba19c0c9d,   853,  276),\n    (0xac2820d9623bf429,   880,  284),\n    (0x80444b5e7aa7cf85,   907,  292),\n    (0xbf21e44003acdd2d,   933,  300),\n    (0x8e679c2f5e44ff8f,   960,  308),\n    (0xd433179d9c8cb841,   986,  316),\n    (0x9e19db92b4e31ba9,  1013,  324),\n    (0xeb96bf6ebadf77d9,  1039,  332),\n];\n\n#[doc(hidden)] pub const CACHED_POW10_FIRST_E: i16 = -1087;\n#[doc(hidden)] pub const CACHED_POW10_LAST_E: i16 = 1039;\n\n#[doc(hidden)]\npub fn cached_power(alpha: i16, gamma: i16) -> (i16, Fp) {\n    let offset = CACHED_POW10_FIRST_E as i32;\n    let range = (CACHED_POW10.len() as i32) - 1;\n    let domain = (CACHED_POW10_LAST_E - CACHED_POW10_FIRST_E) as i32;\n    let idx = ((gamma as i32) - offset) * range / domain;\n    let (f, e, k) = CACHED_POW10[idx as usize];\n    debug_assert!(alpha <= e && e <= gamma);\n    (k, Fp { f, e })\n}\n\n/// Given `x > 0`, returns `(k, 10^k)` such that `10^k <= x < 10^(k+1)`.\n#[doc(hidden)]\npub fn max_pow10_no_more_than(x: u32) -> (u8, u32) {\n    debug_assert!(x > 0);\n\n    const X9: u32 = 10_0000_0000;\n    const X8: u32 =  1_0000_0000;\n    const X7: u32 =    1000_0000;\n    const X6: u32 =     100_0000;\n    const X5: u32 =      10_0000;\n    const X4: u32 =       1_0000;\n    const X3: u32 =         1000;\n    const X2: u32 =          100;\n    const X1: u32 =           10;\n\n    if x < X4 {\n        if x < X2 { if x < X1 {(0,  1)} else {(1, X1)} }\n        else      { if x < X3 {(2, X2)} else {(3, X3)} }\n    } else {\n        if x < X6      { if x < X5 {(4, X4)} else {(5, X5)} }\n        else if x < X8 { if x < X7 {(6, X6)} else {(7, X7)} }\n        else           { if x < X9 {(8, X8)} else {(9, X9)} }\n    }\n}\n\n/// The shortest mode implementation for Grisu.\n///\n/// It returns `None` when it would return an inexact representation otherwise.\npub fn format_shortest_opt(d: &Decoded,\n                           buf: &mut [u8]) -> Option<(/*#digits*/ usize, /*exp*/ i16)> {\n    assert!(d.mant > 0);\n    assert!(d.minus > 0);\n    assert!(d.plus > 0);\n    assert!(d.mant.checked_add(d.plus).is_some());\n    assert!(d.mant.checked_sub(d.minus).is_some());\n    assert!(buf.len() >= MAX_SIG_DIGITS);\n    assert!(d.mant + d.plus < (1 << 61)); // we need at least three bits of additional precision\n\n    // start with the normalized values with the shared exponent\n    let plus = Fp { f: d.mant + d.plus, e: d.exp }.normalize();\n    let minus = Fp { f: d.mant - d.minus, e: d.exp }.normalize_to(plus.e);\n    let v = Fp { f: d.mant, e: d.exp }.normalize_to(plus.e);\n\n    // find any `cached = 10^minusk` such that `ALPHA <= minusk + plus.e + 64 <= GAMMA`.\n    // since `plus` is normalized, this means `2^(62 + ALPHA) <= plus * cached < 2^(64 + GAMMA)`;\n    // given our choices of `ALPHA` and `GAMMA`, this puts `plus * cached` into `[4, 2^32)`.\n    //\n    // it is obviously desirable to maximize `GAMMA - ALPHA`,\n    // so that we don't need many cached powers of 10, but there are some considerations:\n    //\n    // 1. we want to keep `floor(plus * cached)` within `u32` since it needs a costly division.\n    //    (this is not really avoidable, remainder is required for accuracy estimation.)\n    // 2. the remainder of `floor(plus * cached)` repeatedly gets multiplied by 10,\n    //    and it should not overflow.\n    //\n    // the first gives `64 + GAMMA <= 32`, while the second gives `10 * 2^-ALPHA <= 2^64`;\n    // -60 and -32 is the maximal range with this constraint, and V8 also uses them.\n    let (minusk, cached) = cached_power(ALPHA - plus.e - 64, GAMMA - plus.e - 64);\n\n    // scale fps. this gives the maximal error of 1 ulp (proved from Theorem 5.1).\n    let plus = plus.mul(&cached);\n    let minus = minus.mul(&cached);\n    let v = v.mul(&cached);\n    debug_assert_eq!(plus.e, minus.e);\n    debug_assert_eq!(plus.e, v.e);\n\n    //         +- actual range of minus\n    //   | <---|---------------------- unsafe region --------------------------> |\n    //   |     |                                                                 |\n    //   |  |<--->|  | <--------------- safe region ---------------> |           |\n    //   |  |     |  |                                               |           |\n    //   |1 ulp|1 ulp|                 |1 ulp|1 ulp|                 |1 ulp|1 ulp|\n    //   |<--->|<--->|                 |<--->|<--->|                 |<--->|<--->|\n    //   |-----|-----|-------...-------|-----|-----|-------...-------|-----|-----|\n    //   |   minus   |                 |     v     |                 |   plus    |\n    // minus1     minus0           v - 1 ulp   v + 1 ulp           plus0       plus1\n    //\n    // above `minus`, `v` and `plus` are *quantized* approximations (error < 1 ulp).\n    // as we don't know the error is positive or negative, we use two approximations spaced equally\n    // and have the maximal error of 2 ulps.\n    //\n    // the \"unsafe region\" is a liberal interval which we initially generate.\n    // the \"safe region\" is a conservative interval which we only accept.\n    // we start with the correct repr within the unsafe region, and try to find the closest repr\n    // to `v` which is also within the safe region. if we can't, we give up.\n    let plus1 = plus.f + 1;\n//  let plus0 = plus.f - 1; // only for explanation\n//  let minus0 = minus.f + 1; // only for explanation\n    let minus1 = minus.f - 1;\n    let e = -plus.e as usize; // shared exponent\n\n    // divide `plus1` into integral and fractional parts.\n    // integral parts are guaranteed to fit in u32, since cached power guarantees `plus < 2^32`\n    // and normalized `plus.f` is always less than `2^64 - 2^4` due to the precision requirement.\n    let plus1int = (plus1 >> e) as u32;\n    let plus1frac = plus1 & ((1 << e) - 1);\n\n    // calculate the largest `10^max_kappa` no more than `plus1` (thus `plus1 < 10^(max_kappa+1)`).\n    // this is an upper bound of `kappa` below.\n    let (max_kappa, max_ten_kappa) = max_pow10_no_more_than(plus1int);\n\n    let mut i = 0;\n    let exp = max_kappa as i16 - minusk + 1;\n\n    // Theorem 6.2: if `k` is the greatest integer s.t. `0 <= y mod 10^k <= y - x`,\n    //              then `V = floor(y / 10^k) * 10^k` is in `[x, y]` and one of the shortest\n    //              representations (with the minimal number of significant digits) in that range.\n    //\n    // find the digit length `kappa` between `(minus1, plus1)` as per Theorem 6.2.\n    // Theorem 6.2 can be adopted to exclude `x` by requiring `y mod 10^k < y - x` instead.\n    // (e.g. `x` = 32000, `y` = 32777; `kappa` = 2 since `y mod 10^3 = 777 < y - x = 777`.)\n    // the algorithm relies on the later verification phase to exclude `y`.\n    let delta1 = plus1 - minus1;\n//  let delta1int = (delta1 >> e) as usize; // only for explanation\n    let delta1frac = delta1 & ((1 << e) - 1);\n\n    // render integral parts, while checking for the accuracy at each step.\n    let mut kappa = max_kappa as i16;\n    let mut ten_kappa = max_ten_kappa; // 10^kappa\n    let mut remainder = plus1int; // digits yet to be rendered\n    loop { // we always have at least one digit to render, as `plus1 >= 10^kappa`\n        // invariants:\n        // - `delta1int <= remainder < 10^(kappa+1)`\n        // - `plus1int = d[0..n-1] * 10^(kappa+1) + remainder`\n        //   (it follows that `remainder = plus1int % 10^(kappa+1)`)\n\n        // divide `remainder` by `10^kappa`. both are scaled by `2^-e`.\n        let q = remainder / ten_kappa;\n        let r = remainder % ten_kappa;\n        debug_assert!(q < 10);\n        buf[i] = b'0' + q as u8;\n        i += 1;\n\n        let plus1rem = ((r as u64) << e) + plus1frac; // == (plus1 % 10^kappa) * 2^e\n        if plus1rem < delta1 {\n            // `plus1 % 10^kappa < delta1 = plus1 - minus1`; we've found the correct `kappa`.\n            let ten_kappa = (ten_kappa as u64) << e; // scale 10^kappa back to the shared exponent\n            return round_and_weed(&mut buf[..i], exp, plus1rem, delta1, plus1 - v.f, ten_kappa, 1);\n        }\n\n        // break the loop when we have rendered all integral digits.\n        // the exact number of digits is `max_kappa + 1` as `plus1 < 10^(max_kappa+1)`.\n        if i > max_kappa as usize {\n            debug_assert_eq!(ten_kappa, 1);\n            debug_assert_eq!(kappa, 0);\n            break;\n        }\n\n        // restore invariants\n        kappa -= 1;\n        ten_kappa /= 10;\n        remainder = r;\n    }\n\n    // render fractional parts, while checking for the accuracy at each step.\n    // this time we rely on repeated multiplications, as division will lose the precision.\n    let mut remainder = plus1frac;\n    let mut threshold = delta1frac;\n    let mut ulp = 1;\n    loop { // the next digit should be significant as we've tested that before breaking out\n        // invariants, where `m = max_kappa + 1` (# of digits in the integral part):\n        // - `remainder < 2^e`\n        // - `plus1frac * 10^(n-m) = d[m..n-1] * 2^e + remainder`\n\n        remainder *= 10; // won't overflow, `2^e * 10 < 2^64`\n        threshold *= 10;\n        ulp *= 10;\n\n        // divide `remainder` by `10^kappa`.\n        // both are scaled by `2^e / 10^kappa`, so the latter is implicit here.\n        let q = remainder >> e;\n        let r = remainder & ((1 << e) - 1);\n        debug_assert!(q < 10);\n        buf[i] = b'0' + q as u8;\n        i += 1;\n\n        if r < threshold {\n            let ten_kappa = 1 << e; // implicit divisor\n            return round_and_weed(&mut buf[..i], exp, r, threshold,\n                                  (plus1 - v.f) * ulp, ten_kappa, ulp);\n        }\n\n        // restore invariants\n        kappa -= 1;\n        remainder = r;\n    }\n\n    // we've generated all significant digits of `plus1`, but not sure if it's the optimal one.\n    // for example, if `minus1` is 3.14153... and `plus1` is 3.14158..., there are 5 different\n    // shortest representation from 3.14154 to 3.14158 but we only have the greatest one.\n    // we have to successively decrease the last digit and check if this is the optimal repr.\n    // there are at most 9 candidates (..1 to ..9), so this is fairly quick. (\"rounding\" phase)\n    //\n    // the function checks if this \"optimal\" repr is actually within the ulp ranges,\n    // and also, it is possible that the \"second-to-optimal\" repr can actually be optimal\n    // due to the rounding error. in either cases this returns `None`. (\"weeding\" phase)\n    //\n    // all arguments here are scaled by the common (but implicit) value `k`, so that:\n    // - `remainder = (plus1 % 10^kappa) * k`\n    // - `threshold = (plus1 - minus1) * k` (and also, `remainder < threshold`)\n    // - `plus1v = (plus1 - v) * k` (and also, `threshold > plus1v` from prior invariants)\n    // - `ten_kappa = 10^kappa * k`\n    // - `ulp = 2^-e * k`\n    fn round_and_weed(buf: &mut [u8], exp: i16, remainder: u64, threshold: u64, plus1v: u64,\n                      ten_kappa: u64, ulp: u64) -> Option<(usize, i16)> {\n        assert!(!buf.is_empty());\n\n        // produce two approximations to `v` (actually `plus1 - v`) within 1.5 ulps.\n        // the resulting representation should be the closest representation to both.\n        //\n        // here `plus1 - v` is used since calculations are done with respect to `plus1`\n        // in order to avoid overflow/underflow (hence the seemingly swapped names).\n        let plus1v_down = plus1v + ulp; // plus1 - (v - 1 ulp)\n        let plus1v_up = plus1v - ulp; // plus1 - (v + 1 ulp)\n\n        // decrease the last digit and stop at the closest representation to `v + 1 ulp`.\n        let mut plus1w = remainder; // plus1w(n) = plus1 - w(n)\n        {\n            let last = buf.last_mut().unwrap();\n\n            // we work with the approximated digits `w(n)`, which is initially equal to `plus1 -\n            // plus1 % 10^kappa`. after running the loop body `n` times, `w(n) = plus1 -\n            // plus1 % 10^kappa - n * 10^kappa`. we set `plus1w(n) = plus1 - w(n) =\n            // plus1 % 10^kappa + n * 10^kappa` (thus `remainder = plus1w(0)`) to simplify checks.\n            // note that `plus1w(n)` is always increasing.\n            //\n            // we have three conditions to terminate. any of them will make the loop unable to\n            // proceed, but we then have at least one valid representation known to be closest to\n            // `v + 1 ulp` anyway. we will denote them as TC1 through TC3 for brevity.\n            //\n            // TC1: `w(n) <= v + 1 ulp`, i.e. this is the last repr that can be the closest one.\n            // this is equivalent to `plus1 - w(n) = plus1w(n) >= plus1 - (v + 1 ulp) = plus1v_up`.\n            // combined with TC2 (which checks if `w(n+1)` is valid), this prevents the possible\n            // overflow on the calculation of `plus1w(n)`.\n            //\n            // TC2: `w(n+1) < minus1`, i.e. the next repr definitely does not round to `v`.\n            // this is equivalent to `plus1 - w(n) + 10^kappa = plus1w(n) + 10^kappa >\n            // plus1 - minus1 = threshold`. the left hand side can overflow, but we know\n            // `threshold > plus1v`, so if TC1 is false, `threshold - plus1w(n) >\n            // threshold - (plus1v - 1 ulp) > 1 ulp` and we can safely test if\n            // `threshold - plus1w(n) < 10^kappa` instead.\n            //\n            // TC3: `abs(w(n) - (v + 1 ulp)) <= abs(w(n+1) - (v + 1 ulp))`, i.e. the next repr is\n            // no closer to `v + 1 ulp` than the current repr. given `z(n) = plus1v_up - plus1w(n)`,\n            // this becomes `abs(z(n)) <= abs(z(n+1))`. again assuming that TC1 is false, we have\n            // `z(n) > 0`. we have two cases to consider:\n            //\n            // - when `z(n+1) >= 0`: TC3 becomes `z(n) <= z(n+1)`. as `plus1w(n)` is increasing,\n            //   `z(n)` should be decreasing and this is clearly false.\n            // - when `z(n+1) < 0`:\n            //   - TC3a: the precondition is `plus1v_up < plus1w(n) + 10^kappa`. assuming TC2 is\n            //     false, `threshold >= plus1w(n) + 10^kappa` so it cannot overflow.\n            //   - TC3b: TC3 becomes `z(n) <= -z(n+1)`, i.e. `plus1v_up - plus1w(n) >=\n            //     plus1w(n+1) - plus1v_up = plus1w(n) + 10^kappa - plus1v_up`. the negated TC1\n            //     gives `plus1v_up > plus1w(n)`, so it cannot overflow or underflow when\n            //     combined with TC3a.\n            //\n            // consequently, we should stop when `TC1 || TC2 || (TC3a && TC3b)`. the following is\n            // equal to its inverse, `!TC1 && !TC2 && (!TC3a || !TC3b)`.\n            while plus1w < plus1v_up &&\n                  threshold - plus1w >= ten_kappa &&\n                  (plus1w + ten_kappa < plus1v_up ||\n                   plus1v_up - plus1w >= plus1w + ten_kappa - plus1v_up) {\n                *last -= 1;\n                debug_assert!(*last > b'0'); // the shortest repr cannot end with `0`\n                plus1w += ten_kappa;\n            }\n        }\n\n        // check if this representation is also the closest representation to `v - 1 ulp`.\n        //\n        // this is simply same to the terminating conditions for `v + 1 ulp`, with all `plus1v_up`\n        // replaced by `plus1v_down` instead. overflow analysis equally holds.\n        if plus1w < plus1v_down &&\n           threshold - plus1w >= ten_kappa &&\n           (plus1w + ten_kappa < plus1v_down ||\n            plus1v_down - plus1w >= plus1w + ten_kappa - plus1v_down) {\n            return None;\n        }\n\n        // now we have the closest representation to `v` between `plus1` and `minus1`.\n        // this is too liberal, though, so we reject any `w(n)` not between `plus0` and `minus0`,\n        // i.e. `plus1 - plus1w(n) <= minus0` or `plus1 - plus1w(n) >= plus0`. we utilize the facts\n        // that `threshold = plus1 - minus1` and `plus1 - plus0 = minus0 - minus1 = 2 ulp`.\n        if 2 * ulp <= plus1w && plus1w <= threshold - 4 * ulp {\n            Some((buf.len(), exp))\n        } else {\n            None\n        }\n    }\n}\n\n/// The shortest mode implementation for Grisu with Dragon fallback.\n///\n/// This should be used for most cases.\npub fn format_shortest(d: &Decoded, buf: &mut [u8]) -> (/*#digits*/ usize, /*exp*/ i16) {\n    use num::flt2dec::strategy::dragon::format_shortest as fallback;\n    match format_shortest_opt(d, buf) {\n        Some(ret) => ret,\n        None => fallback(d, buf),\n    }\n}\n\n/// The exact and fixed mode implementation for Grisu.\n///\n/// It returns `None` when it would return an inexact representation otherwise.\npub fn format_exact_opt(d: &Decoded, buf: &mut [u8], limit: i16)\n                                -> Option<(/*#digits*/ usize, /*exp*/ i16)> {\n    assert!(d.mant > 0);\n    assert!(d.mant < (1 << 61)); // we need at least three bits of additional precision\n    assert!(!buf.is_empty());\n\n    // normalize and scale `v`.\n    let v = Fp { f: d.mant, e: d.exp }.normalize();\n    let (minusk, cached) = cached_power(ALPHA - v.e - 64, GAMMA - v.e - 64);\n    let v = v.mul(&cached);\n\n    // divide `v` into integral and fractional parts.\n    let e = -v.e as usize;\n    let vint = (v.f >> e) as u32;\n    let vfrac = v.f & ((1 << e) - 1);\n\n    // both old `v` and new `v` (scaled by `10^-k`) has an error of < 1 ulp (Theorem 5.1).\n    // as we don't know the error is positive or negative, we use two approximations\n    // spaced equally and have the maximal error of 2 ulps (same to the shortest case).\n    //\n    // the goal is to find the exactly rounded series of digits that are common to\n    // both `v - 1 ulp` and `v + 1 ulp`, so that we are maximally confident.\n    // if this is not possible, we don't know which one is the correct output for `v`,\n    // so we give up and fall back.\n    //\n    // `err` is defined as `1 ulp * 2^e` here (same to the ulp in `vfrac`),\n    // and we will scale it whenever `v` gets scaled.\n    let mut err = 1;\n\n    // calculate the largest `10^max_kappa` no more than `v` (thus `v < 10^(max_kappa+1)`).\n    // this is an upper bound of `kappa` below.\n    let (max_kappa, max_ten_kappa) = max_pow10_no_more_than(vint);\n\n    let mut i = 0;\n    let exp = max_kappa as i16 - minusk + 1;\n\n    // if we are working with the last-digit limitation, we need to shorten the buffer\n    // before the actual rendering in order to avoid double rounding.\n    // note that we have to enlarge the buffer again when rounding up happens!\n    let len = if exp <= limit {\n        // oops, we cannot even produce *one* digit.\n        // this is possible when, say, we've got something like 9.5 and it's being rounded to 10.\n        //\n        // in principle we can immediately call `possibly_round` with an empty buffer,\n        // but scaling `max_ten_kappa << e` by 10 can result in overflow.\n        // thus we are being sloppy here and widen the error range by a factor of 10.\n        // this will increase the false negative rate, but only very, *very* slightly;\n        // it can only matter noticeably when the mantissa is bigger than 60 bits.\n        return possibly_round(buf, 0, exp, limit, v.f / 10, (max_ten_kappa as u64) << e, err << e);\n    } else if ((exp as i32 - limit as i32) as usize) < buf.len() {\n        (exp - limit) as usize\n    } else {\n        buf.len()\n    };\n    debug_assert!(len > 0);\n\n    // render integral parts.\n    // the error is entirely fractional, so we don't need to check it in this part.\n    let mut kappa = max_kappa as i16;\n    let mut ten_kappa = max_ten_kappa; // 10^kappa\n    let mut remainder = vint; // digits yet to be rendered\n    loop { // we always have at least one digit to render\n        // invariants:\n        // - `remainder < 10^(kappa+1)`\n        // - `vint = d[0..n-1] * 10^(kappa+1) + remainder`\n        //   (it follows that `remainder = vint % 10^(kappa+1)`)\n\n        // divide `remainder` by `10^kappa`. both are scaled by `2^-e`.\n        let q = remainder / ten_kappa;\n        let r = remainder % ten_kappa;\n        debug_assert!(q < 10);\n        buf[i] = b'0' + q as u8;\n        i += 1;\n\n        // is the buffer full? run the rounding pass with the remainder.\n        if i == len {\n            let vrem = ((r as u64) << e) + vfrac; // == (v % 10^kappa) * 2^e\n            return possibly_round(buf, len, exp, limit, vrem, (ten_kappa as u64) << e, err << e);\n        }\n\n        // break the loop when we have rendered all integral digits.\n        // the exact number of digits is `max_kappa + 1` as `plus1 < 10^(max_kappa+1)`.\n        if i > max_kappa as usize {\n            debug_assert_eq!(ten_kappa, 1);\n            debug_assert_eq!(kappa, 0);\n            break;\n        }\n\n        // restore invariants\n        kappa -= 1;\n        ten_kappa /= 10;\n        remainder = r;\n    }\n\n    // render fractional parts.\n    //\n    // in principle we can continue to the last available digit and check for the accuracy.\n    // unfortunately we are working with the finite-sized integers, so we need some criterion\n    // to detect the overflow. V8 uses `remainder > err`, which becomes false when\n    // the first `i` significant digits of `v - 1 ulp` and `v` differ. however this rejects\n    // too many otherwise valid input.\n    //\n    // since the later phase has a correct overflow detection, we instead use tighter criterion:\n    // we continue til `err` exceeds `10^kappa / 2`, so that the range between `v - 1 ulp` and\n    // `v + 1 ulp` definitely contains two or more rounded representations. this is same to\n    // the first two comparisons from `possibly_round`, for the reference.\n    let mut remainder = vfrac;\n    let maxerr = 1 << (e - 1);\n    while err < maxerr {\n        // invariants, where `m = max_kappa + 1` (# of digits in the integral part):\n        // - `remainder < 2^e`\n        // - `vfrac * 10^(n-m) = d[m..n-1] * 2^e + remainder`\n        // - `err = 10^(n-m)`\n\n        remainder *= 10; // won't overflow, `2^e * 10 < 2^64`\n        err *= 10; // won't overflow, `err * 10 < 2^e * 5 < 2^64`\n\n        // divide `remainder` by `10^kappa`.\n        // both are scaled by `2^e / 10^kappa`, so the latter is implicit here.\n        let q = remainder >> e;\n        let r = remainder & ((1 << e) - 1);\n        debug_assert!(q < 10);\n        buf[i] = b'0' + q as u8;\n        i += 1;\n\n        // is the buffer full? run the rounding pass with the remainder.\n        if i == len {\n            return possibly_round(buf, len, exp, limit, r, 1 << e, err);\n        }\n\n        // restore invariants\n        remainder = r;\n    }\n\n    // further calculation is useless (`possibly_round` definitely fails), so we give up.\n    return None;\n\n    // we've generated all requested digits of `v`, which should be also same to corresponding\n    // digits of `v - 1 ulp`. now we check if there is a unique representation shared by\n    // both `v - 1 ulp` and `v + 1 ulp`; this can be either same to generated digits, or\n    // to the rounded-up version of those digits. if the range contains multiple representations\n    // of the same length, we cannot be sure and should return `None` instead.\n    //\n    // all arguments here are scaled by the common (but implicit) value `k`, so that:\n    // - `remainder = (v % 10^kappa) * k`\n    // - `ten_kappa = 10^kappa * k`\n    // - `ulp = 2^-e * k`\n    fn possibly_round(buf: &mut [u8], mut len: usize, mut exp: i16, limit: i16,\n                      remainder: u64, ten_kappa: u64, ulp: u64) -> Option<(usize, i16)> {\n        debug_assert!(remainder < ten_kappa);\n\n        //           10^kappa\n        //    :   :   :<->:   :\n        //    :   :   :   :   :\n        //    :|1 ulp|1 ulp|  :\n        //    :|<--->|<--->|  :\n        // ----|-----|-----|----\n        //     |     v     |\n        // v - 1 ulp   v + 1 ulp\n        //\n        // (for the reference, the dotted line indicates the exact value for\n        // possible representations in given number of digits.)\n        //\n        // error is too large that there are at least three possible representations\n        // between `v - 1 ulp` and `v + 1 ulp`. we cannot determine which one is correct.\n        if ulp >= ten_kappa { return None; }\n\n        //    10^kappa\n        //   :<------->:\n        //   :         :\n        //   : |1 ulp|1 ulp|\n        //   : |<--->|<--->|\n        // ----|-----|-----|----\n        //     |     v     |\n        // v - 1 ulp   v + 1 ulp\n        //\n        // in fact, 1/2 ulp is enough to introduce two possible representations.\n        // (remember that we need a unique representation for both `v - 1 ulp` and `v + 1 ulp`.)\n        // this won't overflow, as `ulp < ten_kappa` from the first check.\n        if ten_kappa - ulp <= ulp { return None; }\n\n        //     remainder\n        //       :<->|                           :\n        //       :   |                           :\n        //       :<--------- 10^kappa ---------->:\n        //     | :   |                           :\n        //     |1 ulp|1 ulp|                     :\n        //     |<--->|<--->|                     :\n        // ----|-----|-----|------------------------\n        //     |     v     |\n        // v - 1 ulp   v + 1 ulp\n        //\n        // if `v + 1 ulp` is closer to the rounded-down representation (which is already in `buf`),\n        // then we can safely return. note that `v - 1 ulp` *can* be less than the current\n        // representation, but as `1 ulp < 10^kappa / 2`, this condition is enough:\n        // the distance between `v - 1 ulp` and the current representation\n        // cannot exceed `10^kappa / 2`.\n        //\n        // the condition equals to `remainder + ulp < 10^kappa / 2`.\n        // since this can easily overflow, first check if `remainder < 10^kappa / 2`.\n        // we've already verified that `ulp < 10^kappa / 2`, so as long as\n        // `10^kappa` did not overflow after all, the second check is fine.\n        if ten_kappa - remainder > remainder && ten_kappa - 2 * remainder >= 2 * ulp {\n            return Some((len, exp));\n        }\n\n        //   :<------- remainder ------>|   :\n        //   :                          |   :\n        //   :<--------- 10^kappa --------->:\n        //   :                    |     |   : |\n        //   :                    |1 ulp|1 ulp|\n        //   :                    |<--->|<--->|\n        // -----------------------|-----|-----|-----\n        //                        |     v     |\n        //                    v - 1 ulp   v + 1 ulp\n        //\n        // on the other hands, if `v - 1 ulp` is closer to the rounded-up representation,\n        // we should round up and return. for the same reason we don't need to check `v + 1 ulp`.\n        //\n        // the condition equals to `remainder - ulp >= 10^kappa / 2`.\n        // again we first check if `remainder > ulp` (note that this is not `remainder >= ulp`,\n        // as `10^kappa` is never zero). also note that `remainder - ulp <= 10^kappa`,\n        // so the second check does not overflow.\n        if remainder > ulp && ten_kappa - (remainder - ulp) <= remainder - ulp {\n            if let Some(c) = round_up(buf, len) {\n                // only add an additional digit when we've been requested the fixed precision.\n                // we also need to check that, if the original buffer was empty,\n                // the additional digit can only be added when `exp == limit` (edge case).\n                exp += 1;\n                if exp > limit && len < buf.len() {\n                    buf[len] = c;\n                    len += 1;\n                }\n            }\n            return Some((len, exp));\n        }\n\n        // otherwise we are doomed (i.e. some values between `v - 1 ulp` and `v + 1 ulp` are\n        // rounding down and others are rounding up) and give up.\n        None\n    }\n}\n\n/// The exact and fixed mode implementation for Grisu with Dragon fallback.\n///\n/// This should be used for most cases.\npub fn format_exact(d: &Decoded, buf: &mut [u8], limit: i16) -> (/*#digits*/ usize, /*exp*/ i16) {\n    use num::flt2dec::strategy::dragon::format_exact as fallback;\n    match format_exact_opt(d, buf, limit) {\n        Some(ret) => ret,\n        None => fallback(d, buf, limit),\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Decodes a floating-point value into individual parts and error ranges.\n\nuse {f32, f64};\nuse num::FpCategory;\nuse num::dec2flt::rawfp::RawFloat;\n\n/// Decoded unsigned finite value, such that:\n///\n/// - The original value equals to `mant * 2^exp`.\n///\n/// - Any number from `(mant - minus) * 2^exp` to `(mant + plus) * 2^exp` will\n///   round to the original value. The range is inclusive only when\n///   `inclusive` is true.\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub struct Decoded {\n    /// The scaled mantissa.\n    pub mant: u64,\n    /// The lower error range.\n    pub minus: u64,\n    /// The upper error range.\n    pub plus: u64,\n    /// The shared exponent in base 2.\n    pub exp: i16,\n    /// True when the error range is inclusive.\n    ///\n    /// In IEEE 754, this is true when the original mantissa was even.\n    pub inclusive: bool,\n}\n\n/// Decoded unsigned value.\n#[derive(Copy, Clone, Debug, PartialEq, Eq)]\npub enum FullDecoded {\n    /// Not-a-number.\n    Nan,\n    /// Infinities, either positive or negative.\n    Infinite,\n    /// Zero, either positive or negative.\n    Zero,\n    /// Finite numbers with further decoded fields.\n    Finite(Decoded),\n}\n\n/// A floating point type which can be `decode`d.\npub trait DecodableFloat: RawFloat + Copy {\n    /// The minimum positive normalized value.\n    fn min_pos_norm_value() -> Self;\n}\n\nimpl DecodableFloat for f32 {\n    fn min_pos_norm_value() -> Self { f32::MIN_POSITIVE }\n}\n\nimpl DecodableFloat for f64 {\n    fn min_pos_norm_value() -> Self { f64::MIN_POSITIVE }\n}\n\n/// Returns a sign (true when negative) and `FullDecoded` value\n/// from given floating point number.\npub fn decode<T: DecodableFloat>(v: T) -> (/*negative?*/ bool, FullDecoded) {\n    let (mant, exp, sign) = v.integer_decode();\n    let even = (mant & 1) == 0;\n    let decoded = match v.classify() {\n        FpCategory::Nan => FullDecoded::Nan,\n        FpCategory::Infinite => FullDecoded::Infinite,\n        FpCategory::Zero => FullDecoded::Zero,\n        FpCategory::Subnormal => {\n            // neighbors: (mant - 2, exp) -- (mant, exp) -- (mant + 2, exp)\n            // Float::integer_decode always preserves the exponent,\n            // so the mantissa is scaled for subnormals.\n            FullDecoded::Finite(Decoded { mant, minus: 1, plus: 1,\n                                          exp, inclusive: even })\n        }\n        FpCategory::Normal => {\n            let minnorm = <T as DecodableFloat>::min_pos_norm_value().integer_decode();\n            if mant == minnorm.0 {\n                // neighbors: (maxmant, exp - 1) -- (minnormmant, exp) -- (minnormmant + 1, exp)\n                // where maxmant = minnormmant * 2 - 1\n                FullDecoded::Finite(Decoded { mant: mant << 2, minus: 1, plus: 2,\n                                              exp: exp - 2, inclusive: even })\n            } else {\n                // neighbors: (mant - 1, exp) -- (mant, exp) -- (mant + 1, exp)\n                FullDecoded::Finite(Decoded { mant: mant << 1, minus: 1, plus: 1,\n                                              exp: exp - 1, inclusive: even })\n            }\n        }\n    };\n    (sign < 0, decoded)\n}\n\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! The exponent estimator.\n\n/// Finds `k_0` such that `10^(k_0-1) < mant * 2^exp <= 10^(k_0+1)`.\n///\n/// This is used to approximate `k = ceil(log_10 (mant * 2^exp))`;\n/// the true `k` is either `k_0` or `k_0+1`.\n#[doc(hidden)]\npub fn estimate_scaling_factor(mant: u64, exp: i16) -> i16 {\n    // 2^(nbits-1) < mant <= 2^nbits if mant > 0\n    let nbits = 64 - (mant - 1).leading_zeros() as i64;\n    // 1292913986 = floor(2^32 * log_10 2)\n    // therefore this always underestimates (or is exact), but not much.\n    (((nbits + exp as i64) * 1292913986) >> 32) as i16\n}\n\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/*!\n\nFloating-point number to decimal conversion routines.\n\n# Problem statement\n\nWe are given the floating-point number `v = f * 2^e` with an integer `f`,\nand its bounds `minus` and `plus` such that any number between `v - minus` and\n`v + plus` will be rounded to `v`. For the simplicity we assume that\nthis range is exclusive. Then we would like to get the unique decimal\nrepresentation `V = 0.d[0..n-1] * 10^k` such that:\n\n- `d[0]` is non-zero.\n\n- It's correctly rounded when parsed back: `v - minus < V < v + plus`.\n  Furthermore it is shortest such one, i.e. there is no representation\n  with less than `n` digits that is correctly rounded.\n\n- It's closest to the original value: `abs(V - v) <= 10^(k-n) / 2`. Note that\n  there might be two representations satisfying this uniqueness requirement,\n  in which case some tie-breaking mechanism is used.\n\nWe will call this mode of operation as to the *shortest* mode. This mode is used\nwhen there is no additional constraint, and can be thought as a \"natural\" mode\nas it matches the ordinary intuition (it at least prints `0.1f32` as \"0.1\").\n\nWe have two more modes of operation closely related to each other. In these modes\nwe are given either the number of significant digits `n` or the last-digit\nlimitation `limit` (which determines the actual `n`), and we would like to get\nthe representation `V = 0.d[0..n-1] * 10^k` such that:\n\n- `d[0]` is non-zero, unless `n` was zero in which case only `k` is returned.\n\n- It's closest to the original value: `abs(V - v) <= 10^(k-n) / 2`. Again,\n  there might be some tie-breaking mechanism.\n\nWhen `limit` is given but not `n`, we set `n` such that `k - n = limit`\nso that the last digit `d[n-1]` is scaled by `10^(k-n) = 10^limit`.\nIf such `n` is negative, we clip it to zero so that we will only get `k`.\nWe are also limited by the supplied buffer. This limitation is used to print\nthe number up to given number of fractional digits without knowing\nthe correct `k` beforehand.\n\nWe will call the mode of operation requiring `n` as to the *exact* mode,\nand one requiring `limit` as to the *fixed* mode. The exact mode is a subset of\nthe fixed mode: the sufficiently large last-digit limitation will eventually fill\nthe supplied buffer and let the algorithm to return.\n\n# Implementation overview\n\nIt is easy to get the floating point printing correct but slow (Russ Cox has\n[demonstrated](http://research.swtch.com/ftoa) how it's easy), or incorrect but\nfast (na\u00efve division and modulo). But it is surprisingly hard to print\nfloating point numbers correctly *and* efficiently.\n\nThere are two classes of algorithms widely known to be correct.\n\n- The \"Dragon\" family of algorithm is first described by Guy L. Steele Jr. and\n  Jon L. White. They rely on the fixed-size big integer for their correctness.\n  A slight improvement was found later, which is posthumously described by\n  Robert G. Burger and R. Kent Dybvig. David Gay's `dtoa.c` routine is\n  a popular implementation of this strategy.\n\n- The \"Grisu\" family of algorithm is first described by Florian Loitsch.\n  They use very cheap integer-only procedure to determine the close-to-correct\n  representation which is at least guaranteed to be shortest. The variant,\n  Grisu3, actively detects if the resulting representation is incorrect.\n\nWe implement both algorithms with necessary tweaks to suit our requirements.\nIn particular, published literatures are short of the actual implementation\ndifficulties like how to avoid arithmetic overflows. Each implementation,\navailable in `strategy::dragon` and `strategy::grisu` respectively,\nextensively describes all necessary justifications and many proofs for them.\n(It is still difficult to follow though. You have been warned.)\n\nBoth implementations expose two public functions:\n\n- `format_shortest(decoded, buf)`, which always needs at least\n  `MAX_SIG_DIGITS` digits of buffer. Implements the shortest mode.\n\n- `format_exact(decoded, buf, limit)`, which accepts as small as\n  one digit of buffer. Implements exact and fixed modes.\n\nThey try to fill the `u8` buffer with digits and returns the number of digits\nwritten and the exponent `k`. They are total for all finite `f32` and `f64`\ninputs (Grisu internally falls back to Dragon if necessary).\n\nThe rendered digits are formatted into the actual string form with\nfour functions:\n\n- `to_shortest_str` prints the shortest representation, which can be padded by\n  zeroes to make *at least* given number of fractional digits.\n\n- `to_shortest_exp_str` prints the shortest representation, which can be\n  padded by zeroes when its exponent is in the specified ranges,\n  or can be printed in the exponential form such as `1.23e45`.\n\n- `to_exact_exp_str` prints the exact representation with given number of\n  digits in the exponential form.\n\n- `to_exact_fixed_str` prints the fixed representation with *exactly*\n  given number of fractional digits.\n\nThey all return a slice of preallocated `Part` array, which corresponds to\nthe individual part of strings: a fixed string, a part of rendered digits,\na number of zeroes or a small (`u16`) number. The caller is expected to\nprovide a large enough buffer and `Part` array, and to assemble the final\nstring from resulting `Part`s itself.\n\nAll algorithms and formatting functions are accompanied by extensive tests\nin `coretests::num::flt2dec` module. It also shows how to use individual\nfunctions.\n\n*/\n\n// while this is extensively documented, this is in principle private which is\n// only made public for testing. do not expose us.\n#![doc(hidden)]\n#![unstable(feature = \"flt2dec\",\n            reason = \"internal routines only exposed for testing\",\n            issue = \"0\")]\n\nuse i16;\npub use self::decoder::{decode, DecodableFloat, FullDecoded, Decoded};\n\npub mod estimator;\npub mod decoder;\n\n/// Digit-generation algorithms.\npub mod strategy {\n    pub mod dragon;\n    pub mod grisu;\n}\n\n/// The minimum size of buffer necessary for the shortest mode.\n///\n/// It is a bit non-trivial to derive, but this is one plus the maximal number of\n/// significant decimal digits from formatting algorithms with the shortest result.\n/// The exact formula is `ceil(# bits in mantissa * log_10 2 + 1)`.\npub const MAX_SIG_DIGITS: usize = 17;\n\n/// When `d[..n]` contains decimal digits, increase the last digit and propagate carry.\n/// Returns a next digit when it causes the length change.\n#[doc(hidden)]\npub fn round_up(d: &mut [u8], n: usize) -> Option<u8> {\n    match d[..n].iter().rposition(|&c| c != b'9') {\n        Some(i) => { // d[i+1..n] is all nines\n            d[i] += 1;\n            for j in i+1..n { d[j] = b'0'; }\n            None\n        }\n        None if n > 0 => { // 999..999 rounds to 1000..000 with an increased exponent\n            d[0] = b'1';\n            for j in 1..n { d[j] = b'0'; }\n            Some(b'0')\n        }\n        None => { // an empty buffer rounds up (a bit strange but reasonable)\n            Some(b'1')\n        }\n    }\n}\n\n/// Formatted parts.\n#[derive(Copy, Clone, PartialEq, Eq, Debug)]\npub enum Part<'a> {\n    /// Given number of zero digits.\n    Zero(usize),\n    /// A literal number up to 5 digits.\n    Num(u16),\n    /// A verbatim copy of given bytes.\n    Copy(&'a [u8]),\n}\n\nimpl<'a> Part<'a> {\n    /// Returns the exact byte length of given part.\n    pub fn len(&self) -> usize {\n        match *self {\n            Part::Zero(nzeroes) => nzeroes,\n            Part::Num(v) => if v < 1_000 { if v < 10 { 1 } else if v < 100 { 2 } else { 3 } }\n                            else { if v < 10_000 { 4 } else { 5 } },\n            Part::Copy(buf) => buf.len(),\n        }\n    }\n\n    /// Writes a part into the supplied buffer.\n    /// Returns the number of written bytes, or `None` if the buffer is not enough.\n    /// (It may still leave partially written bytes in the buffer; do not rely on that.)\n    pub fn write(&self, out: &mut [u8]) -> Option<usize> {\n        let len = self.len();\n        if out.len() >= len {\n            match *self {\n                Part::Zero(nzeroes) => {\n                    for c in &mut out[..nzeroes] { *c = b'0'; }\n                }\n                Part::Num(mut v) => {\n                    for c in out[..len].iter_mut().rev() {\n                        *c = b'0' + (v % 10) as u8;\n                        v /= 10;\n                    }\n                }\n                Part::Copy(buf) => {\n                    out[..buf.len()].copy_from_slice(buf);\n                }\n            }\n            Some(len)\n        } else {\n            None\n        }\n    }\n}\n\n/// Formatted result containing one or more parts.\n/// This can be written to the byte buffer or converted to the allocated string.\n#[allow(missing_debug_implementations)]\n#[derive(Clone)]\npub struct Formatted<'a> {\n    /// A byte slice representing a sign, either `\"\"`, `\"-\"` or `\"+\"`.\n    pub sign: &'static [u8],\n    /// Formatted parts to be rendered after a sign and optional zero padding.\n    pub parts: &'a [Part<'a>],\n}\n\nimpl<'a> Formatted<'a> {\n    /// Returns the exact byte length of combined formatted result.\n    pub fn len(&self) -> usize {\n        let mut len = self.sign.len();\n        for part in self.parts {\n            len += part.len();\n        }\n        len\n    }\n\n    /// Writes all formatted parts into the supplied buffer.\n    /// Returns the number of written bytes, or `None` if the buffer is not enough.\n    /// (It may still leave partially written bytes in the buffer; do not rely on that.)\n    pub fn write(&self, out: &mut [u8]) -> Option<usize> {\n        if out.len() < self.sign.len() { return None; }\n        out[..self.sign.len()].copy_from_slice(self.sign);\n\n        let mut written = self.sign.len();\n        for part in self.parts {\n            match part.write(&mut out[written..]) {\n                Some(len) => { written += len; }\n                None => { return None; }\n            }\n        }\n        Some(written)\n    }\n}\n\n/// Formats given decimal digits `0.<...buf...> * 10^exp` into the decimal form\n/// with at least given number of fractional digits. The result is stored to\n/// the supplied parts array and a slice of written parts is returned.\n///\n/// `frac_digits` can be less than the number of actual fractional digits in `buf`;\n/// it will be ignored and full digits will be printed. It is only used to print\n/// additional zeroes after rendered digits. Thus `frac_digits` of 0 means that\n/// it will only print given digits and nothing else.\nfn digits_to_dec_str<'a>(buf: &'a [u8], exp: i16, frac_digits: usize,\n                         parts: &'a mut [Part<'a>]) -> &'a [Part<'a>] {\n    assert!(!buf.is_empty());\n    assert!(buf[0] > b'0');\n    assert!(parts.len() >= 4);\n\n    // if there is the restriction on the last digit position, `buf` is assumed to be\n    // left-padded with the virtual zeroes. the number of virtual zeroes, `nzeroes`,\n    // equals to `max(0, exp + frac_digits - buf.len())`, so that the position of\n    // the last digit `exp - buf.len() - nzeroes` is no more than `-frac_digits`:\n    //\n    //                       |<-virtual->|\n    //       |<---- buf ---->|  zeroes   |     exp\n    //    0. 1 2 3 4 5 6 7 8 9 _ _ _ _ _ _ x 10\n    //    |                  |           |\n    // 10^exp    10^(exp-buf.len())   10^(exp-buf.len()-nzeroes)\n    //\n    // `nzeroes` is individually calculated for each case in order to avoid overflow.\n\n    if exp <= 0 {\n        // the decimal point is before rendered digits: [0.][000...000][1234][____]\n        let minus_exp = -(exp as i32) as usize;\n        parts[0] = Part::Copy(b\"0.\");\n        parts[1] = Part::Zero(minus_exp);\n        parts[2] = Part::Copy(buf);\n        if frac_digits > buf.len() && frac_digits - buf.len() > minus_exp {\n            parts[3] = Part::Zero((frac_digits - buf.len()) - minus_exp);\n            &parts[..4]\n        } else {\n            &parts[..3]\n        }\n    } else {\n        let exp = exp as usize;\n        if exp < buf.len() {\n            // the decimal point is inside rendered digits: [12][.][34][____]\n            parts[0] = Part::Copy(&buf[..exp]);\n            parts[1] = Part::Copy(b\".\");\n            parts[2] = Part::Copy(&buf[exp..]);\n            if frac_digits > buf.len() - exp {\n                parts[3] = Part::Zero(frac_digits - (buf.len() - exp));\n                &parts[..4]\n            } else {\n                &parts[..3]\n            }\n        } else {\n            // the decimal point is after rendered digits: [1234][____0000] or [1234][__][.][__].\n            parts[0] = Part::Copy(buf);\n            parts[1] = Part::Zero(exp - buf.len());\n            if frac_digits > 0 {\n                parts[2] = Part::Copy(b\".\");\n                parts[3] = Part::Zero(frac_digits);\n                &parts[..4]\n            } else {\n                &parts[..2]\n            }\n        }\n    }\n}\n\n/// Formats given decimal digits `0.<...buf...> * 10^exp` into the exponential form\n/// with at least given number of significant digits. When `upper` is true,\n/// the exponent will be prefixed by `E`; otherwise that's `e`. The result is\n/// stored to the supplied parts array and a slice of written parts is returned.\n///\n/// `min_digits` can be less than the number of actual significant digits in `buf`;\n/// it will be ignored and full digits will be printed. It is only used to print\n/// additional zeroes after rendered digits. Thus `min_digits` of 0 means that\n/// it will only print given digits and nothing else.\nfn digits_to_exp_str<'a>(buf: &'a [u8], exp: i16, min_ndigits: usize, upper: bool,\n                         parts: &'a mut [Part<'a>]) -> &'a [Part<'a>] {\n    assert!(!buf.is_empty());\n    assert!(buf[0] > b'0');\n    assert!(parts.len() >= 6);\n\n    let mut n = 0;\n\n    parts[n] = Part::Copy(&buf[..1]);\n    n += 1;\n\n    if buf.len() > 1 || min_ndigits > 1 {\n        parts[n] = Part::Copy(b\".\");\n        parts[n + 1] = Part::Copy(&buf[1..]);\n        n += 2;\n        if min_ndigits > buf.len() {\n            parts[n] = Part::Zero(min_ndigits - buf.len());\n            n += 1;\n        }\n    }\n\n    // 0.1234 x 10^exp = 1.234 x 10^(exp-1)\n    let exp = exp as i32 - 1; // avoid underflow when exp is i16::MIN\n    if exp < 0 {\n        parts[n] = Part::Copy(if upper { b\"E-\" } else { b\"e-\" });\n        parts[n + 1] = Part::Num(-exp as u16);\n    } else {\n        parts[n] = Part::Copy(if upper { b\"E\" } else { b\"e\" });\n        parts[n + 1] = Part::Num(exp as u16);\n    }\n    &parts[..n + 2]\n}\n\n/// Sign formatting options.\n#[derive(Copy, Clone, PartialEq, Eq, Debug)]\npub enum Sign {\n    /// Prints `-` only for the negative non-zero values.\n    Minus,        // -inf -1  0  0  1  inf nan\n    /// Prints `-` only for any negative values (including the negative zero).\n    MinusRaw,     // -inf -1 -0  0  1  inf nan\n    /// Prints `-` for the negative non-zero values, or `+` otherwise.\n    MinusPlus,    // -inf -1 +0 +0 +1 +inf nan\n    /// Prints `-` for any negative values (including the negative zero), or `+` otherwise.\n    MinusPlusRaw, // -inf -1 -0 +0 +1 +inf nan\n}\n\n/// Returns the static byte string corresponding to the sign to be formatted.\n/// It can be either `b\"\"`, `b\"+\"` or `b\"-\"`.\nfn determine_sign(sign: Sign, decoded: &FullDecoded, negative: bool) -> &'static [u8] {\n    match (*decoded, sign) {\n        (FullDecoded::Nan, _) => b\"\",\n        (FullDecoded::Zero, Sign::Minus) => b\"\",\n        (FullDecoded::Zero, Sign::MinusRaw) => if negative { b\"-\" } else { b\"\" },\n        (FullDecoded::Zero, Sign::MinusPlus) => b\"+\",\n        (FullDecoded::Zero, Sign::MinusPlusRaw) => if negative { b\"-\" } else { b\"+\" },\n        (_, Sign::Minus) | (_, Sign::MinusRaw) => if negative { b\"-\" } else { b\"\" },\n        (_, Sign::MinusPlus) | (_, Sign::MinusPlusRaw) => if negative { b\"-\" } else { b\"+\" },\n    }\n}\n\n/// Formats given floating point number into the decimal form with at least\n/// given number of fractional digits. The result is stored to the supplied parts\n/// array while utilizing given byte buffer as a scratch. `upper` is currently\n/// unused but left for the future decision to change the case of non-finite values,\n/// i.e. `inf` and `nan`. The first part to be rendered is always a `Part::Sign`\n/// (which can be an empty string if no sign is rendered).\n///\n/// `format_shortest` should be the underlying digit-generation function.\n/// You probably would want `strategy::grisu::format_shortest` for this.\n///\n/// `frac_digits` can be less than the number of actual fractional digits in `v`;\n/// it will be ignored and full digits will be printed. It is only used to print\n/// additional zeroes after rendered digits. Thus `frac_digits` of 0 means that\n/// it will only print given digits and nothing else.\n///\n/// The byte buffer should be at least `MAX_SIG_DIGITS` bytes long.\n/// There should be at least 4 parts available, due to the worst case like\n/// `[+][0.][0000][2][0000]` with `frac_digits = 10`.\npub fn to_shortest_str<'a, T, F>(mut format_shortest: F, v: T,\n                                 sign: Sign, frac_digits: usize, _upper: bool,\n                                 buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>\n        where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8]) -> (usize, i16) {\n    assert!(parts.len() >= 4);\n    assert!(buf.len() >= MAX_SIG_DIGITS);\n\n    let (negative, full_decoded) = decode(v);\n    let sign = determine_sign(sign, &full_decoded, negative);\n    match full_decoded {\n        FullDecoded::Nan => {\n            parts[0] = Part::Copy(b\"NaN\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Infinite => {\n            parts[0] = Part::Copy(b\"inf\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Zero => {\n            if frac_digits > 0 { // [0.][0000]\n                parts[0] = Part::Copy(b\"0.\");\n                parts[1] = Part::Zero(frac_digits);\n                Formatted { sign, parts: &parts[..2] }\n            } else {\n                parts[0] = Part::Copy(b\"0\");\n                Formatted { sign, parts: &parts[..1] }\n            }\n        }\n        FullDecoded::Finite(ref decoded) => {\n            let (len, exp) = format_shortest(decoded, buf);\n            Formatted { sign,\n                        parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) }\n        }\n    }\n}\n\n/// Formats given floating point number into the decimal form or\n/// the exponential form, depending on the resulting exponent. The result is\n/// stored to the supplied parts array while utilizing given byte buffer\n/// as a scratch. `upper` is used to determine the case of non-finite values\n/// (`inf` and `nan`) or the case of the exponent prefix (`e` or `E`).\n/// The first part to be rendered is always a `Part::Sign` (which can be\n/// an empty string if no sign is rendered).\n///\n/// `format_shortest` should be the underlying digit-generation function.\n/// You probably would want `strategy::grisu::format_shortest` for this.\n///\n/// The `dec_bounds` is a tuple `(lo, hi)` such that the number is formatted\n/// as decimal only when `10^lo <= V < 10^hi`. Note that this is the *apparent* `V`\n/// instead of the actual `v`! Thus any printed exponent in the exponential form\n/// cannot be in this range, avoiding any confusion.\n///\n/// The byte buffer should be at least `MAX_SIG_DIGITS` bytes long.\n/// There should be at least 6 parts available, due to the worst case like\n/// `[+][1][.][2345][e][-][6]`.\npub fn to_shortest_exp_str<'a, T, F>(mut format_shortest: F, v: T,\n                                     sign: Sign, dec_bounds: (i16, i16), upper: bool,\n                                     buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>\n        where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8]) -> (usize, i16) {\n    assert!(parts.len() >= 6);\n    assert!(buf.len() >= MAX_SIG_DIGITS);\n    assert!(dec_bounds.0 <= dec_bounds.1);\n\n    let (negative, full_decoded) = decode(v);\n    let sign = determine_sign(sign, &full_decoded, negative);\n    match full_decoded {\n        FullDecoded::Nan => {\n            parts[0] = Part::Copy(b\"NaN\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Infinite => {\n            parts[0] = Part::Copy(b\"inf\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Zero => {\n            parts[0] = if dec_bounds.0 <= 0 && 0 < dec_bounds.1 {\n                Part::Copy(b\"0\")\n            } else {\n                Part::Copy(if upper { b\"0E0\" } else { b\"0e0\" })\n            };\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Finite(ref decoded) => {\n            let (len, exp) = format_shortest(decoded, buf);\n            let vis_exp = exp as i32 - 1;\n            let parts = if dec_bounds.0 as i32 <= vis_exp && vis_exp < dec_bounds.1 as i32 {\n                digits_to_dec_str(&buf[..len], exp, 0, parts)\n            } else {\n                digits_to_exp_str(&buf[..len], exp, 0, upper, parts)\n            };\n            Formatted { sign, parts }\n        }\n    }\n}\n\n/// Returns rather crude approximation (upper bound) for the maximum buffer size\n/// calculated from the given decoded exponent.\n///\n/// The exact limit is:\n///\n/// - when `exp < 0`, the maximum length is `ceil(log_10 (5^-exp * (2^64 - 1)))`.\n/// - when `exp >= 0`, the maximum length is `ceil(log_10 (2^exp * (2^64 - 1)))`.\n///\n/// `ceil(log_10 (x^exp * (2^64 - 1)))` is less than `ceil(log_10 (2^64 - 1)) +\n/// ceil(exp * log_10 x)`, which is in turn less than `20 + (1 + exp * log_10 x)`.\n/// We use the facts that `log_10 2 < 5/16` and `log_10 5 < 12/16`, which is\n/// enough for our purposes.\n///\n/// Why do we need this? `format_exact` functions will fill the entire buffer\n/// unless limited by the last digit restriction, but it is possible that\n/// the number of digits requested is ridiculously large (say, 30,000 digits).\n/// The vast majority of buffer will be filled with zeroes, so we don't want to\n/// allocate all the buffer beforehand. Consequently, for any given arguments,\n/// 826 bytes of buffer should be sufficient for `f64`. Compare this with\n/// the actual number for the worst case: 770 bytes (when `exp = -1074`).\nfn estimate_max_buf_len(exp: i16) -> usize {\n    21 + ((if exp < 0 { -12 } else { 5 } * exp as i32) as usize >> 4)\n}\n\n/// Formats given floating point number into the exponential form with\n/// exactly given number of significant digits. The result is stored to\n/// the supplied parts array while utilizing given byte buffer as a scratch.\n/// `upper` is used to determine the case of the exponent prefix (`e` or `E`).\n/// The first part to be rendered is always a `Part::Sign` (which can be\n/// an empty string if no sign is rendered).\n///\n/// `format_exact` should be the underlying digit-generation function.\n/// You probably would want `strategy::grisu::format_exact` for this.\n///\n/// The byte buffer should be at least `ndigits` bytes long unless `ndigits` is\n/// so large that only the fixed number of digits will be ever written.\n/// (The tipping point for `f64` is about 800, so 1000 bytes should be enough.)\n/// There should be at least 6 parts available, due to the worst case like\n/// `[+][1][.][2345][e][-][6]`.\npub fn to_exact_exp_str<'a, T, F>(mut format_exact: F, v: T,\n                                  sign: Sign, ndigits: usize, upper: bool,\n                                  buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>\n        where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) {\n    assert!(parts.len() >= 6);\n    assert!(ndigits > 0);\n\n    let (negative, full_decoded) = decode(v);\n    let sign = determine_sign(sign, &full_decoded, negative);\n    match full_decoded {\n        FullDecoded::Nan => {\n            parts[0] = Part::Copy(b\"NaN\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Infinite => {\n            parts[0] = Part::Copy(b\"inf\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Zero => {\n            if ndigits > 1 { // [0.][0000][e0]\n                parts[0] = Part::Copy(b\"0.\");\n                parts[1] = Part::Zero(ndigits - 1);\n                parts[2] = Part::Copy(if upper { b\"E0\" } else { b\"e0\" });\n                Formatted { sign, parts: &parts[..3] }\n            } else {\n                parts[0] = Part::Copy(if upper { b\"0E0\" } else { b\"0e0\" });\n                Formatted { sign, parts: &parts[..1] }\n            }\n        }\n        FullDecoded::Finite(ref decoded) => {\n            let maxlen = estimate_max_buf_len(decoded.exp);\n            assert!(buf.len() >= ndigits || buf.len() >= maxlen);\n\n            let trunc = if ndigits < maxlen { ndigits } else { maxlen };\n            let (len, exp) = format_exact(decoded, &mut buf[..trunc], i16::MIN);\n            Formatted { sign,\n                        parts: digits_to_exp_str(&buf[..len], exp, ndigits, upper, parts) }\n        }\n    }\n}\n\n/// Formats given floating point number into the decimal form with exactly\n/// given number of fractional digits. The result is stored to the supplied parts\n/// array while utilizing given byte buffer as a scratch. `upper` is currently\n/// unused but left for the future decision to change the case of non-finite values,\n/// i.e. `inf` and `nan`. The first part to be rendered is always a `Part::Sign`\n/// (which can be an empty string if no sign is rendered).\n///\n/// `format_exact` should be the underlying digit-generation function.\n/// You probably would want `strategy::grisu::format_exact` for this.\n///\n/// The byte buffer should be enough for the output unless `frac_digits` is\n/// so large that only the fixed number of digits will be ever written.\n/// (The tipping point for `f64` is about 800, and 1000 bytes should be enough.)\n/// There should be at least 4 parts available, due to the worst case like\n/// `[+][0.][0000][2][0000]` with `frac_digits = 10`.\npub fn to_exact_fixed_str<'a, T, F>(mut format_exact: F, v: T,\n                                    sign: Sign, frac_digits: usize, _upper: bool,\n                                    buf: &'a mut [u8], parts: &'a mut [Part<'a>]) -> Formatted<'a>\n        where T: DecodableFloat, F: FnMut(&Decoded, &mut [u8], i16) -> (usize, i16) {\n    assert!(parts.len() >= 4);\n\n    let (negative, full_decoded) = decode(v);\n    let sign = determine_sign(sign, &full_decoded, negative);\n    match full_decoded {\n        FullDecoded::Nan => {\n            parts[0] = Part::Copy(b\"NaN\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Infinite => {\n            parts[0] = Part::Copy(b\"inf\");\n            Formatted { sign, parts: &parts[..1] }\n        }\n        FullDecoded::Zero => {\n            if frac_digits > 0 { // [0.][0000]\n                parts[0] = Part::Copy(b\"0.\");\n                parts[1] = Part::Zero(frac_digits);\n                Formatted { sign, parts: &parts[..2] }\n            } else {\n                parts[0] = Part::Copy(b\"0\");\n                Formatted { sign, parts: &parts[..1] }\n            }\n        }\n        FullDecoded::Finite(ref decoded) => {\n            let maxlen = estimate_max_buf_len(decoded.exp);\n            assert!(buf.len() >= maxlen);\n\n            // it *is* possible that `frac_digits` is ridiculously large.\n            // `format_exact` will end rendering digits much earlier in this case,\n            // because we are strictly limited by `maxlen`.\n            let limit = if frac_digits < 0x8000 { -(frac_digits as i16) } else { i16::MIN };\n            let (len, exp) = format_exact(decoded, &mut buf[..maxlen], limit);\n            if exp <= limit {\n                // the restriction couldn't been met, so this should render like zero no matter\n                // `exp` was. this does not include the case that the restriction has been met\n                // only after the final rounding-up; it's a regular case with `exp = limit + 1`.\n                debug_assert_eq!(len, 0);\n                if frac_digits > 0 { // [0.][0000]\n                    parts[0] = Part::Copy(b\"0.\");\n                    parts[1] = Part::Zero(frac_digits);\n                    Formatted { sign, parts: &parts[..2] }\n                } else {\n                    parts[0] = Part::Copy(b\"0\");\n                    Formatted { sign, parts: &parts[..1] }\n                }\n            } else {\n                Formatted { sign,\n                            parts: digits_to_dec_str(&buf[..len], exp, frac_digits, parts) }\n            }\n        }\n    }\n}\n\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Validating and decomposing a decimal string of the form:\n//!\n//! `(digits | digits? '.'? digits?) (('e' | 'E') ('+' | '-')? digits)?`\n//!\n//! In other words, standard floating-point syntax, with two exceptions: No sign, and no\n//! handling of \"inf\" and \"NaN\". These are handled by the driver function (super::dec2flt).\n//!\n//! Although recognizing valid inputs is relatively easy, this module also has to reject the\n//! countless invalid variations, never panic, and perform numerous checks that the other\n//! modules rely on to not panic (or overflow) in turn.\n//! To make matters worse, all that happens in a single pass over the input.\n//! So, be careful when modifying anything, and double-check with the other modules.\nuse super::num;\nuse self::ParseResult::{Valid, ShortcutToInf, ShortcutToZero, Invalid};\n\n#[derive(Debug)]\npub enum Sign {\n    Positive,\n    Negative,\n}\n\n#[derive(Debug, PartialEq, Eq)]\n/// The interesting parts of a decimal string.\npub struct Decimal<'a> {\n    pub integral: &'a [u8],\n    pub fractional: &'a [u8],\n    /// The decimal exponent, guaranteed to have fewer than 18 decimal digits.\n    pub exp: i64,\n}\n\nimpl<'a> Decimal<'a> {\n    pub fn new(integral: &'a [u8], fractional: &'a [u8], exp: i64) -> Decimal<'a> {\n        Decimal { integral, fractional, exp }\n    }\n}\n\n#[derive(Debug, PartialEq, Eq)]\npub enum ParseResult<'a> {\n    Valid(Decimal<'a>),\n    ShortcutToInf,\n    ShortcutToZero,\n    Invalid,\n}\n\n/// Check if the input string is a valid floating point number and if so, locate the integral\n/// part, the fractional part, and the exponent in it. Does not handle signs.\npub fn parse_decimal(s: &str) -> ParseResult {\n    if s.is_empty() {\n        return Invalid;\n    }\n\n    let s = s.as_bytes();\n    let (integral, s) = eat_digits(s);\n\n    match s.first() {\n        None => Valid(Decimal::new(integral, b\"\", 0)),\n        Some(&b'e') | Some(&b'E') => {\n            if integral.is_empty() {\n                return Invalid; // No digits before 'e'\n            }\n\n            parse_exp(integral, b\"\", &s[1..])\n        }\n        Some(&b'.') => {\n            let (fractional, s) = eat_digits(&s[1..]);\n            if integral.is_empty() && fractional.is_empty() {\n                // We require at least a single digit before or after the point.\n                return Invalid;\n            }\n\n            match s.first() {\n                None => Valid(Decimal::new(integral, fractional, 0)),\n                Some(&b'e') | Some(&b'E') => parse_exp(integral, fractional, &s[1..]),\n                _ => Invalid, // Trailing junk after fractional part\n            }\n        }\n        _ => Invalid, // Trailing junk after first digit string\n    }\n}\n\n/// Carve off decimal digits up to the first non-digit character.\nfn eat_digits(s: &[u8]) -> (&[u8], &[u8]) {\n    let mut i = 0;\n    while i < s.len() && b'0' <= s[i] && s[i] <= b'9' {\n        i += 1;\n    }\n    (&s[..i], &s[i..])\n}\n\n/// Exponent extraction and error checking.\nfn parse_exp<'a>(integral: &'a [u8], fractional: &'a [u8], rest: &'a [u8]) -> ParseResult<'a> {\n    let (sign, rest) = match rest.first() {\n        Some(&b'-') => (Sign::Negative, &rest[1..]),\n        Some(&b'+') => (Sign::Positive, &rest[1..]),\n        _ => (Sign::Positive, rest),\n    };\n    let (mut number, trailing) = eat_digits(rest);\n    if !trailing.is_empty() {\n        return Invalid; // Trailing junk after exponent\n    }\n    if number.is_empty() {\n        return Invalid; // Empty exponent\n    }\n    // At this point, we certainly have a valid string of digits. It may be too long to put into\n    // an `i64`, but if it's that huge, the input is certainly zero or infinity. Since each zero\n    // in the decimal digits only adjusts the exponent by +/- 1, at exp = 10^18 the input would\n    // have to be 17 exabyte (!) of zeros to get even remotely close to being finite.\n    // This is not exactly a use case we need to cater to.\n    while number.first() == Some(&b'0') {\n        number = &number[1..];\n    }\n    if number.len() >= 18 {\n        return match sign {\n            Sign::Positive => ShortcutToInf,\n            Sign::Negative => ShortcutToZero,\n        };\n    }\n    let abs_exp = num::from_str_unchecked(number);\n    let e = match sign {\n        Sign::Positive => abs_exp as i64,\n        Sign::Negative => -(abs_exp as i64),\n    };\n    Valid(Decimal::new(integral, fractional, e))\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Utility functions for bignums that don't make too much sense to turn into methods.\n\n// FIXME This module's name is a bit unfortunate, since other modules also import `core::num`.\n\nuse cmp::Ordering::{self, Less, Equal, Greater};\n\npub use num::bignum::Big32x40 as Big;\n\n/// Test whether truncating all bits less significant than `ones_place` introduces\n/// a relative error less, equal, or greater than 0.5 ULP.\npub fn compare_with_half_ulp(f: &Big, ones_place: usize) -> Ordering {\n    if ones_place == 0 {\n        return Less;\n    }\n    let half_bit = ones_place - 1;\n    if f.get_bit(half_bit) == 0 {\n        // < 0.5 ULP\n        return Less;\n    }\n    // If all remaining bits are zero, it's = 0.5 ULP, otherwise > 0.5\n    // If there are no more bits (half_bit == 0), the below also correctly returns Equal.\n    for i in 0..half_bit {\n        if f.get_bit(i) == 1 {\n            return Greater;\n        }\n    }\n    Equal\n}\n\n/// Convert an ASCII string containing only decimal digits to a `u64`.\n///\n/// Does not perform checks for overflow or invalid characters, so if the caller is not careful,\n/// the result is bogus and can panic (though it won't be `unsafe`). Additionally, empty strings\n/// are treated as zero. This function exists because\n///\n/// 1. using `FromStr` on `&[u8]` requires `from_utf8_unchecked`, which is bad, and\n/// 2. piecing together the results of `integral.parse()` and `fractional.parse()` is\n///    more complicated than this entire function.\npub fn from_str_unchecked<'a, T>(bytes: T) -> u64 where T : IntoIterator<Item=&'a u8> {\n    let mut result = 0;\n    for &c in bytes {\n        result = result * 10 + (c - b'0') as u64;\n    }\n    result\n}\n\n/// Convert a string of ASCII digits into a bignum.\n///\n/// Like `from_str_unchecked`, this function relies on the parser to weed out non-digits.\npub fn digits_to_big(integral: &[u8], fractional: &[u8]) -> Big {\n    let mut f = Big::from_small(0);\n    for &c in integral.iter().chain(fractional) {\n        let n = (c - b'0') as u32;\n        f.mul_small(10);\n        f.add_small(n);\n    }\n    f\n}\n\n/// Unwraps a bignum into a 64 bit integer. Panics if the number is too large.\npub fn to_u64(x: &Big) -> u64 {\n    assert!(x.bit_length() < 64);\n    let d = x.digits();\n    if d.len() < 2 {\n        d[0] as u64\n    } else {\n        (d[1] as u64) << 32 | d[0] as u64\n    }\n}\n\n\n/// Extract a range of bits.\n\n/// Index 0 is the least significant bit and the range is half-open as usual.\n/// Panics if asked to extract more bits than fit into the return type.\npub fn get_bits(x: &Big, start: usize, end: usize) -> u64 {\n    assert!(end - start <= 64);\n    let mut result: u64 = 0;\n    for i in (start..end).rev() {\n        result = result << 1 | x.get_bit(i) as u64;\n    }\n    result\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Bit fiddling on positive IEEE 754 floats. Negative numbers aren't and needn't be handled.\n//! Normal floating point numbers have a canonical representation as (frac, exp) such that the\n//! value is 2<sup>exp</sup> * (1 + sum(frac[N-i] / 2<sup>i</sup>)) where N is the number of bits.\n//! Subnormals are slightly different and weird, but the same principle applies.\n//!\n//! Here, however, we represent them as (sig, k) with f positive, such that the value is f *\n//! 2<sup>e</sup>. Besides making the \"hidden bit\" explicit, this changes the exponent by the\n//! so-called mantissa shift.\n//!\n//! Put another way, normally floats are written as (1) but here they are written as (2):\n//!\n//! 1. `1.101100...11 * 2^m`\n//! 2. `1101100...11 * 2^n`\n//!\n//! We call (1) the **fractional representation** and (2) the **integral representation**.\n//!\n//! Many functions in this module only handle normal numbers. The dec2flt routines conservatively\n//! take the universally-correct slow path (Algorithm M) for very small and very large numbers.\n//! That algorithm needs only next_float() which does handle subnormals and zeros.\nuse cmp::Ordering::{Less, Equal, Greater};\nuse convert::{TryFrom, TryInto};\nuse ops::{Add, Mul, Div, Neg};\nuse fmt::{Debug, LowerExp};\nuse num::diy_float::Fp;\nuse num::FpCategory::{Infinite, Zero, Subnormal, Normal, Nan};\nuse num::FpCategory;\nuse num::dec2flt::num::{self, Big};\nuse num::dec2flt::table;\n\n#[derive(Copy, Clone, Debug)]\npub struct Unpacked {\n    pub sig: u64,\n    pub k: i16,\n}\n\nimpl Unpacked {\n    pub fn new(sig: u64, k: i16) -> Self {\n        Unpacked { sig, k }\n    }\n}\n\n/// A helper trait to avoid duplicating basically all the conversion code for `f32` and `f64`.\n///\n/// See the parent module's doc comment for why this is necessary.\n///\n/// Should **never ever** be implemented for other types or be used outside the dec2flt module.\npub trait RawFloat\n    : Copy\n    + Debug\n    + LowerExp\n    + Mul<Output=Self>\n    + Div<Output=Self>\n    + Neg<Output=Self>\n{\n    const INFINITY: Self;\n    const NAN: Self;\n    const ZERO: Self;\n\n    /// Type used by `to_bits` and `from_bits`.\n    type Bits: Add<Output = Self::Bits> + From<u8> + TryFrom<u64>;\n\n    /// Raw transmutation to integer.\n    fn to_bits(self) -> Self::Bits;\n\n    /// Raw transmutation from integer.\n    fn from_bits(v: Self::Bits) -> Self;\n\n    /// Returns the category that this number falls into.\n    fn classify(self) -> FpCategory;\n\n    /// Returns the mantissa, exponent and sign as integers.\n    fn integer_decode(self) -> (u64, i16, i8);\n\n    /// Decode the float.\n    fn unpack(self) -> Unpacked;\n\n    /// Cast from a small integer that can be represented exactly.  Panic if the integer can't be\n    /// represented, the other code in this module makes sure to never let that happen.\n    fn from_int(x: u64) -> Self;\n\n    /// Get the value 10<sup>e</sup> from a pre-computed table.\n    /// Panics for `e >= CEIL_LOG5_OF_MAX_SIG`.\n    fn short_fast_pow10(e: usize) -> Self;\n\n    /// What the name says. It's easier to hard code than juggling intrinsics and\n    /// hoping LLVM constant folds it.\n    const CEIL_LOG5_OF_MAX_SIG: i16;\n\n    // A conservative bound on the decimal digits of inputs that can't produce overflow or zero or\n    /// subnormals. Probably the decimal exponent of the maximum normal value, hence the name.\n    const MAX_NORMAL_DIGITS: usize;\n\n    /// When the most significant decimal digit has a place value greater than this, the number\n    /// is certainly rounded to infinity.\n    const INF_CUTOFF: i64;\n\n    /// When the most significant decimal digit has a place value less than this, the number\n    /// is certainly rounded to zero.\n    const ZERO_CUTOFF: i64;\n\n    /// The number of bits in the exponent.\n    const EXP_BITS: u8;\n\n    /// The number of bits in the significand, *including* the hidden bit.\n    const SIG_BITS: u8;\n\n    /// The number of bits in the significand, *excluding* the hidden bit.\n    const EXPLICIT_SIG_BITS: u8;\n\n    /// The maximum legal exponent in fractional representation.\n    const MAX_EXP: i16;\n\n    /// The minimum legal exponent in fractional representation, excluding subnormals.\n    const MIN_EXP: i16;\n\n    /// `MAX_EXP` for integral representation, i.e., with the shift applied.\n    const MAX_EXP_INT: i16;\n\n    /// `MAX_EXP` encoded (i.e., with offset bias)\n    const MAX_ENCODED_EXP: i16;\n\n    /// `MIN_EXP` for integral representation, i.e., with the shift applied.\n    const MIN_EXP_INT: i16;\n\n    /// The maximum normalized significand in integral representation.\n    const MAX_SIG: u64;\n\n    /// The minimal normalized significand in integral representation.\n    const MIN_SIG: u64;\n}\n\n// Mostly a workaround for #34344.\nmacro_rules! other_constants {\n    ($type: ident) => {\n        const EXPLICIT_SIG_BITS: u8 = Self::SIG_BITS - 1;\n        const MAX_EXP: i16 = (1 << (Self::EXP_BITS - 1)) - 1;\n        const MIN_EXP: i16 = -Self::MAX_EXP + 1;\n        const MAX_EXP_INT: i16 = Self::MAX_EXP - (Self::SIG_BITS as i16 - 1);\n        const MAX_ENCODED_EXP: i16 = (1 << Self::EXP_BITS) - 1;\n        const MIN_EXP_INT: i16 = Self::MIN_EXP - (Self::SIG_BITS as i16 - 1);\n        const MAX_SIG: u64 = (1 << Self::SIG_BITS) - 1;\n        const MIN_SIG: u64 = 1 << (Self::SIG_BITS - 1);\n\n        const INFINITY: Self = $crate::$type::INFINITY;\n        const NAN: Self = $crate::$type::NAN;\n        const ZERO: Self = 0.0;\n    }\n}\n\nimpl RawFloat for f32 {\n    type Bits = u32;\n\n    const SIG_BITS: u8 = 24;\n    const EXP_BITS: u8 = 8;\n    const CEIL_LOG5_OF_MAX_SIG: i16 = 11;\n    const MAX_NORMAL_DIGITS: usize = 35;\n    const INF_CUTOFF: i64 = 40;\n    const ZERO_CUTOFF: i64 = -48;\n    other_constants!(f32);\n\n    /// Returns the mantissa, exponent and sign as integers.\n    fn integer_decode(self) -> (u64, i16, i8) {\n        let bits = self.to_bits();\n        let sign: i8 = if bits >> 31 == 0 { 1 } else { -1 };\n        let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;\n        let mantissa = if exponent == 0 {\n            (bits & 0x7fffff) << 1\n        } else {\n            (bits & 0x7fffff) | 0x800000\n        };\n        // Exponent bias + mantissa shift\n        exponent -= 127 + 23;\n        (mantissa as u64, exponent, sign)\n    }\n\n    fn unpack(self) -> Unpacked {\n        let (sig, exp, _sig) = self.integer_decode();\n        Unpacked::new(sig, exp)\n    }\n\n    fn from_int(x: u64) -> f32 {\n        // rkruppe is uncertain whether `as` rounds correctly on all platforms.\n        debug_assert!(x as f32 == fp_to_float(Fp { f: x, e: 0 }));\n        x as f32\n    }\n\n    fn short_fast_pow10(e: usize) -> Self {\n        table::F32_SHORT_POWERS[e]\n    }\n\n    fn classify(self) -> FpCategory { self.classify() }\n    fn to_bits(self) -> Self::Bits { self.to_bits() }\n    fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) }\n}\n\n\nimpl RawFloat for f64 {\n    type Bits = u64;\n\n    const SIG_BITS: u8 = 53;\n    const EXP_BITS: u8 = 11;\n    const CEIL_LOG5_OF_MAX_SIG: i16 = 23;\n    const MAX_NORMAL_DIGITS: usize = 305;\n    const INF_CUTOFF: i64 = 310;\n    const ZERO_CUTOFF: i64 = -326;\n    other_constants!(f64);\n\n    /// Returns the mantissa, exponent and sign as integers.\n    fn integer_decode(self) -> (u64, i16, i8) {\n        let bits = self.to_bits();\n        let sign: i8 = if bits >> 63 == 0 { 1 } else { -1 };\n        let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;\n        let mantissa = if exponent == 0 {\n            (bits & 0xfffffffffffff) << 1\n        } else {\n            (bits & 0xfffffffffffff) | 0x10000000000000\n        };\n        // Exponent bias + mantissa shift\n        exponent -= 1023 + 52;\n        (mantissa, exponent, sign)\n    }\n\n    fn unpack(self) -> Unpacked {\n        let (sig, exp, _sig) = self.integer_decode();\n        Unpacked::new(sig, exp)\n    }\n\n    fn from_int(x: u64) -> f64 {\n        // rkruppe is uncertain whether `as` rounds correctly on all platforms.\n        debug_assert!(x as f64 == fp_to_float(Fp { f: x, e: 0 }));\n        x as f64\n    }\n\n    fn short_fast_pow10(e: usize) -> Self {\n        table::F64_SHORT_POWERS[e]\n    }\n\n    fn classify(self) -> FpCategory { self.classify() }\n    fn to_bits(self) -> Self::Bits { self.to_bits() }\n    fn from_bits(v: Self::Bits) -> Self { Self::from_bits(v) }\n}\n\n/// Convert an Fp to the closest machine float type.\n/// Does not handle subnormal results.\npub fn fp_to_float<T: RawFloat>(x: Fp) -> T {\n    let x = x.normalize();\n    // x.f is 64 bit, so x.e has a mantissa shift of 63\n    let e = x.e + 63;\n    if e > T::MAX_EXP {\n        panic!(\"fp_to_float: exponent {} too large\", e)\n    }  else if e > T::MIN_EXP {\n        encode_normal(round_normal::<T>(x))\n    } else {\n        panic!(\"fp_to_float: exponent {} too small\", e)\n    }\n}\n\n/// Round the 64-bit significand to T::SIG_BITS bits with half-to-even.\n/// Does not handle exponent overflow.\npub fn round_normal<T: RawFloat>(x: Fp) -> Unpacked {\n    let excess = 64 - T::SIG_BITS as i16;\n    let half: u64 = 1 << (excess - 1);\n    let (q, rem) = (x.f >> excess, x.f & ((1 << excess) - 1));\n    assert_eq!(q << excess | rem, x.f);\n    // Adjust mantissa shift\n    let k = x.e + excess;\n    if rem < half {\n        Unpacked::new(q, k)\n    } else if rem == half && (q % 2) == 0 {\n        Unpacked::new(q, k)\n    } else if q == T::MAX_SIG {\n        Unpacked::new(T::MIN_SIG, k + 1)\n    } else {\n        Unpacked::new(q + 1, k)\n    }\n}\n\n/// Inverse of `RawFloat::unpack()` for normalized numbers.\n/// Panics if the significand or exponent are not valid for normalized numbers.\npub fn encode_normal<T: RawFloat>(x: Unpacked) -> T {\n    debug_assert!(T::MIN_SIG <= x.sig && x.sig <= T::MAX_SIG,\n        \"encode_normal: significand not normalized\");\n    // Remove the hidden bit\n    let sig_enc = x.sig & !(1 << T::EXPLICIT_SIG_BITS);\n    // Adjust the exponent for exponent bias and mantissa shift\n    let k_enc = x.k + T::MAX_EXP + T::EXPLICIT_SIG_BITS as i16;\n    debug_assert!(k_enc != 0 && k_enc < T::MAX_ENCODED_EXP,\n        \"encode_normal: exponent out of range\");\n    // Leave sign bit at 0 (\"+\"), our numbers are all positive\n    let bits = (k_enc as u64) << T::EXPLICIT_SIG_BITS | sig_enc;\n    T::from_bits(bits.try_into().unwrap_or_else(|_| unreachable!()))\n}\n\n/// Construct a subnormal. A mantissa of 0 is allowed and constructs zero.\npub fn encode_subnormal<T: RawFloat>(significand: u64) -> T {\n    assert!(significand < T::MIN_SIG, \"encode_subnormal: not actually subnormal\");\n    // Encoded exponent is 0, the sign bit is 0, so we just have to reinterpret the bits.\n    T::from_bits(significand.try_into().unwrap_or_else(|_| unreachable!()))\n}\n\n/// Approximate a bignum with an Fp. Rounds within 0.5 ULP with half-to-even.\npub fn big_to_fp(f: &Big) -> Fp {\n    let end = f.bit_length();\n    assert!(end != 0, \"big_to_fp: unexpectedly, input is zero\");\n    let start = end.saturating_sub(64);\n    let leading = num::get_bits(f, start, end);\n    // We cut off all bits prior to the index `start`, i.e., we effectively right-shift by\n    // an amount of `start`, so this is also the exponent we need.\n    let e = start as i16;\n    let rounded_down = Fp { f: leading, e }.normalize();\n    // Round (half-to-even) depending on the truncated bits.\n    match num::compare_with_half_ulp(f, start) {\n        Less => rounded_down,\n        Equal if leading % 2 == 0 => rounded_down,\n        Equal | Greater => match leading.checked_add(1) {\n            Some(f) => Fp { f, e }.normalize(),\n            None => Fp { f: 1 << 63, e: e + 1 },\n        }\n    }\n}\n\n/// Find the largest floating point number strictly smaller than the argument.\n/// Does not handle subnormals, zero, or exponent underflow.\npub fn prev_float<T: RawFloat>(x: T) -> T {\n    match x.classify() {\n        Infinite => panic!(\"prev_float: argument is infinite\"),\n        Nan => panic!(\"prev_float: argument is NaN\"),\n        Subnormal => panic!(\"prev_float: argument is subnormal\"),\n        Zero => panic!(\"prev_float: argument is zero\"),\n        Normal => {\n            let Unpacked { sig, k } = x.unpack();\n            if sig == T::MIN_SIG {\n                encode_normal(Unpacked::new(T::MAX_SIG, k - 1))\n            } else {\n                encode_normal(Unpacked::new(sig - 1, k))\n            }\n        }\n    }\n}\n\n// Find the smallest floating point number strictly larger than the argument.\n// This operation is saturating, i.e. next_float(inf) == inf.\n// Unlike most code in this module, this function does handle zero, subnormals, and infinities.\n// However, like all other code here, it does not deal with NaN and negative numbers.\npub fn next_float<T: RawFloat>(x: T) -> T {\n    match x.classify() {\n        Nan => panic!(\"next_float: argument is NaN\"),\n        Infinite => T::INFINITY,\n        // This seems too good to be true, but it works.\n        // 0.0 is encoded as the all-zero word. Subnormals are 0x000m...m where m is the mantissa.\n        // In particular, the smallest subnormal is 0x0...01 and the largest is 0x000F...F.\n        // The smallest normal number is 0x0010...0, so this corner case works as well.\n        // If the increment overflows the mantissa, the carry bit increments the exponent as we\n        // want, and the mantissa bits become zero. Because of the hidden bit convention, this\n        // too is exactly what we want!\n        // Finally, f64::MAX + 1 = 7eff...f + 1 = 7ff0...0 = f64::INFINITY.\n        Zero | Subnormal | Normal => {\n            T::from_bits(x.to_bits() + T::Bits::from(1u8))\n        }\n    }\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Converting decimal strings into IEEE 754 binary floating point numbers.\n//!\n//! # Problem statement\n//!\n//! We are given a decimal string such as `12.34e56`. This string consists of integral (`12`),\n//! fractional (`45`), and exponent (`56`) parts. All parts are optional and interpreted as zero\n//! when missing.\n//!\n//! We seek the IEEE 754 floating point number that is closest to the exact value of the decimal\n//! string. It is well-known that many decimal strings do not have terminating representations in\n//! base two, so we round to 0.5 units in the last place (in other words, as well as possible).\n//! Ties, decimal values exactly half-way between two consecutive floats, are resolved with the\n//! half-to-even strategy, also known as banker's rounding.\n//!\n//! Needless to say, this is quite hard, both in terms of implementation complexity and in terms\n//! of CPU cycles taken.\n//!\n//! # Implementation\n//!\n//! First, we ignore signs. Or rather, we remove it at the very beginning of the conversion\n//! process and re-apply it at the very end. This is correct in all edge cases since IEEE\n//! floats are symmetric around zero, negating one simply flips the first bit.\n//!\n//! Then we remove the decimal point by adjusting the exponent: Conceptually, `12.34e56` turns\n//! into `1234e54`, which we describe with a positive integer `f = 1234` and an integer `e = 54`.\n//! The `(f, e)` representation is used by almost all code past the parsing stage.\n//!\n//! We then try a long chain of progressively more general and expensive special cases using\n//! machine-sized integers and small, fixed-sized floating point numbers (first `f32`/`f64`, then\n//! a type with 64 bit significand, `Fp`). When all these fail, we bite the bullet and resort to a\n//! simple but very slow algorithm that involved computing `f * 10^e` fully and doing an iterative\n//! search for the best approximation.\n//!\n//! Primarily, this module and its children implement the algorithms described in:\n//! \"How to Read Floating Point Numbers Accurately\" by William D. Clinger,\n//! available online: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.45.4152\n//!\n//! In addition, there are numerous helper functions that are used in the paper but not available\n//! in Rust (or at least in core). Our version is additionally complicated by the need to handle\n//! overflow and underflow and the desire to handle subnormal numbers.  Bellerophon and\n//! Algorithm R have trouble with overflow, subnormals, and underflow. We conservatively switch to\n//! Algorithm M (with the modifications described in section 8 of the paper) well before the\n//! inputs get into the critical region.\n//!\n//! Another aspect that needs attention is the ``RawFloat`` trait by which almost all functions\n//! are parametrized. One might think that it's enough to parse to `f64` and cast the result to\n//! `f32`. Unfortunately this is not the world we live in, and this has nothing to do with using\n//! base two or half-to-even rounding.\n//!\n//! Consider for example two types `d2` and `d4` representing a decimal type with two decimal\n//! digits and four decimal digits each and take \"0.01499\" as input. Let's use half-up rounding.\n//! Going directly to two decimal digits gives `0.01`, but if we round to four digits first,\n//! we get `0.0150`, which is then rounded up to `0.02`. The same principle applies to other\n//! operations as well, if you want 0.5 ULP accuracy you need to do *everything* in full precision\n//! and round *exactly once, at the end*, by considering all truncated bits at once.\n//!\n//! FIXME Although some code duplication is necessary, perhaps parts of the code could be shuffled\n//! around such that less code is duplicated. Large parts of the algorithms are independent of the\n//! float type to output, or only needs access to a few constants, which could be passed in as\n//! parameters.\n//!\n//! # Other\n//!\n//! The conversion should *never* panic. There are assertions and explicit panics in the code,\n//! but they should never be triggered and only serve as internal sanity checks. Any panics should\n//! be considered a bug.\n//!\n//! There are unit tests but they are woefully inadequate at ensuring correctness, they only cover\n//! a small percentage of possible errors. Far more extensive tests are located in the directory\n//! `src/etc/test-float-parse` as a Python script.\n//!\n//! A note on integer overflow: Many parts of this file perform arithmetic with the decimal\n//! exponent `e`. Primarily, we shift the decimal point around: Before the first decimal digit,\n//! after the last decimal digit, and so on. This could overflow if done carelessly. We rely on\n//! the parsing submodule to only hand out sufficiently small exponents, where \"sufficient\" means\n//! \"such that the exponent +/- the number of decimal digits fits into a 64 bit integer\".\n//! Larger exponents are accepted, but we don't do arithmetic with them, they are immediately\n//! turned into {positive,negative} {zero,infinity}.\n\n#![doc(hidden)]\n#![unstable(feature = \"dec2flt\",\n            reason = \"internal routines only exposed for testing\",\n            issue = \"0\")]\n\nuse fmt;\nuse str::FromStr;\n\nuse self::parse::{parse_decimal, Decimal, Sign, ParseResult};\nuse self::num::digits_to_big;\nuse self::rawfp::RawFloat;\n\nmod algorithm;\nmod table;\nmod num;\n// These two have their own tests.\npub mod rawfp;\npub mod parse;\n\nmacro_rules! from_str_float_impl {\n    ($t:ty) => {\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl FromStr for $t {\n            type Err = ParseFloatError;\n\n            /// Converts a string in base 10 to a float.\n            /// Accepts an optional decimal exponent.\n            ///\n            /// This function accepts strings such as\n            ///\n            /// * '3.14'\n            /// * '-3.14'\n            /// * '2.5E10', or equivalently, '2.5e10'\n            /// * '2.5E-10'\n            /// * '5.'\n            /// * '.5', or, equivalently,  '0.5'\n            /// * 'inf', '-inf', 'NaN'\n            ///\n            /// Leading and trailing whitespace represent an error.\n            ///\n            /// # Arguments\n            ///\n            /// * src - A string\n            ///\n            /// # Return value\n            ///\n            /// `Err(ParseFloatError)` if the string did not represent a valid\n            /// number.  Otherwise, `Ok(n)` where `n` is the floating-point\n            /// number represented by `src`.\n            #[inline]\n            fn from_str(src: &str) -> Result<Self, ParseFloatError> {\n                dec2flt(src)\n            }\n        }\n    }\n}\nfrom_str_float_impl!(f32);\nfrom_str_float_impl!(f64);\n\n/// An error which can be returned when parsing a float.\n///\n/// This error is used as the error type for the [`FromStr`] implementation\n/// for [`f32`] and [`f64`].\n///\n/// [`FromStr`]: ../str/trait.FromStr.html\n/// [`f32`]: ../../std/primitive.f32.html\n/// [`f64`]: ../../std/primitive.f64.html\n#[derive(Debug, Clone, PartialEq, Eq)]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct ParseFloatError {\n    kind: FloatErrorKind\n}\n\n#[derive(Debug, Clone, PartialEq, Eq)]\nenum FloatErrorKind {\n    Empty,\n    Invalid,\n}\n\nimpl ParseFloatError {\n    #[unstable(feature = \"int_error_internals\",\n               reason = \"available through Error trait and this method should \\\n                         not be exposed publicly\",\n               issue = \"0\")]\n    #[doc(hidden)]\n    pub fn __description(&self) -> &str {\n        match self.kind {\n            FloatErrorKind::Empty => \"cannot parse float from empty string\",\n            FloatErrorKind::Invalid => \"invalid float literal\",\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl fmt::Display for ParseFloatError {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        self.__description().fmt(f)\n    }\n}\n\nfn pfe_empty() -> ParseFloatError {\n    ParseFloatError { kind: FloatErrorKind::Empty }\n}\n\nfn pfe_invalid() -> ParseFloatError {\n    ParseFloatError { kind: FloatErrorKind::Invalid }\n}\n\n/// Split decimal string into sign and the rest, without inspecting or validating the rest.\nfn extract_sign(s: &str) -> (Sign, &str) {\n    match s.as_bytes()[0] {\n        b'+' => (Sign::Positive, &s[1..]),\n        b'-' => (Sign::Negative, &s[1..]),\n        // If the string is invalid, we never use the sign, so we don't need to validate here.\n        _ => (Sign::Positive, s),\n    }\n}\n\n/// Convert a decimal string into a floating point number.\nfn dec2flt<T: RawFloat>(s: &str) -> Result<T, ParseFloatError> {\n    if s.is_empty() {\n        return Err(pfe_empty())\n    }\n    let (sign, s) = extract_sign(s);\n    let flt = match parse_decimal(s) {\n        ParseResult::Valid(decimal) => convert(decimal)?,\n        ParseResult::ShortcutToInf => T::INFINITY,\n        ParseResult::ShortcutToZero => T::ZERO,\n        ParseResult::Invalid => match s {\n            \"inf\" => T::INFINITY,\n            \"NaN\" => T::NAN,\n            _ => { return Err(pfe_invalid()); }\n        }\n    };\n\n    match sign {\n        Sign::Positive => Ok(flt),\n        Sign::Negative => Ok(-flt),\n    }\n}\n\n/// The main workhorse for the decimal-to-float conversion: Orchestrate all the preprocessing\n/// and figure out which algorithm should do the actual conversion.\nfn convert<T: RawFloat>(mut decimal: Decimal) -> Result<T, ParseFloatError> {\n    simplify(&mut decimal);\n    if let Some(x) = trivial_cases(&decimal) {\n        return Ok(x);\n    }\n    // Remove/shift out the decimal point.\n    let e = decimal.exp - decimal.fractional.len() as i64;\n    if let Some(x) = algorithm::fast_path(decimal.integral, decimal.fractional, e) {\n        return Ok(x);\n    }\n    // Big32x40 is limited to 1280 bits, which translates to about 385 decimal digits.\n    // If we exceed this, we'll crash, so we error out before getting too close (within 10^10).\n    let upper_bound = bound_intermediate_digits(&decimal, e);\n    if upper_bound > 375 {\n        return Err(pfe_invalid());\n    }\n    let f = digits_to_big(decimal.integral, decimal.fractional);\n\n    // Now the exponent certainly fits in 16 bit, which is used throughout the main algorithms.\n    let e = e as i16;\n    // FIXME These bounds are rather conservative. A more careful analysis of the failure modes\n    // of Bellerophon could allow using it in more cases for a massive speed up.\n    let exponent_in_range = table::MIN_E <= e && e <= table::MAX_E;\n    let value_in_range = upper_bound <= T::MAX_NORMAL_DIGITS as u64;\n    if exponent_in_range && value_in_range {\n        Ok(algorithm::bellerophon(&f, e))\n    } else {\n        Ok(algorithm::algorithm_m(&f, e))\n    }\n}\n\n// As written, this optimizes badly (see #27130, though it refers to an old version of the code).\n// `inline(always)` is a workaround for that. There are only two call sites overall and it doesn't\n// make code size worse.\n\n/// Strip zeros where possible, even when this requires changing the exponent\n#[inline(always)]\nfn simplify(decimal: &mut Decimal) {\n    let is_zero = &|&&d: &&u8| -> bool { d == b'0' };\n    // Trimming these zeros does not change anything but may enable the fast path (< 15 digits).\n    let leading_zeros = decimal.integral.iter().take_while(is_zero).count();\n    decimal.integral = &decimal.integral[leading_zeros..];\n    let trailing_zeros = decimal.fractional.iter().rev().take_while(is_zero).count();\n    let end = decimal.fractional.len() - trailing_zeros;\n    decimal.fractional = &decimal.fractional[..end];\n    // Simplify numbers of the form 0.0...x and x...0.0, adjusting the exponent accordingly.\n    // This may not always be a win (possibly pushes some numbers out of the fast path), but it\n    // simplifies other parts significantly (notably, approximating the magnitude of the value).\n    if decimal.integral.is_empty() {\n        let leading_zeros = decimal.fractional.iter().take_while(is_zero).count();\n        decimal.fractional = &decimal.fractional[leading_zeros..];\n        decimal.exp -= leading_zeros as i64;\n    } else if decimal.fractional.is_empty() {\n        let trailing_zeros = decimal.integral.iter().rev().take_while(is_zero).count();\n        let end = decimal.integral.len() - trailing_zeros;\n        decimal.integral = &decimal.integral[..end];\n        decimal.exp += trailing_zeros as i64;\n    }\n}\n\n/// Quick and dirty upper bound on the size (log10) of the largest value that Algorithm R and\n/// Algorithm M will compute while working on the given decimal.\nfn bound_intermediate_digits(decimal: &Decimal, e: i64) -> u64 {\n    // We don't need to worry too much about overflow here thanks to trivial_cases() and the\n    // parser, which filter out the most extreme inputs for us.\n    let f_len: u64 = decimal.integral.len() as u64 + decimal.fractional.len() as u64;\n    if e >= 0 {\n        // In the case e >= 0, both algorithms compute about `f * 10^e`. Algorithm R proceeds to\n        // do some complicated calculations with this but we can ignore that for the upper bound\n        // because it also reduces the fraction beforehand, so we have plenty of buffer there.\n        f_len + (e as u64)\n    } else {\n        // If e < 0, Algorithm R does roughly the same thing, but Algorithm M differs:\n        // It tries to find a positive number k such that `f << k / 10^e` is an in-range\n        // significand. This will result in about `2^53 * f * 10^e` < `10^17 * f * 10^e`.\n        // One input that triggers this is 0.33...33 (375 x 3).\n        f_len + (e.abs() as u64) + 17\n    }\n}\n\n/// Detect obvious overflows and underflows without even looking at the decimal digits.\nfn trivial_cases<T: RawFloat>(decimal: &Decimal) -> Option<T> {\n    // There were zeros but they were stripped by simplify()\n    if decimal.integral.is_empty() && decimal.fractional.is_empty() {\n        return Some(T::ZERO);\n    }\n    // This is a crude approximation of ceil(log10(the real value)). We don't need to worry too\n    // much about overflow here because the input length is tiny (at least compared to 2^64) and\n    // the parser already handles exponents whose absolute value is greater than 10^18\n    // (which is still 10^19 short of 2^64).\n    let max_place = decimal.exp + decimal.integral.len() as i64;\n    if max_place > T::INF_CUTOFF {\n        return Some(T::INFINITY);\n    } else if max_place < T::ZERO_CUTOFF {\n        return Some(T::ZERO);\n    }\n    None\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Custom arbitrary-precision number (bignum) implementation.\n//!\n//! This is designed to avoid the heap allocation at expense of stack memory.\n//! The most used bignum type, `Big32x40`, is limited by 32 \u00d7 40 = 1,280 bits\n//! and will take at most 160 bytes of stack memory. This is more than enough\n//! for round-tripping all possible finite `f64` values.\n//!\n//! In principle it is possible to have multiple bignum types for different\n//! inputs, but we don't do so to avoid the code bloat. Each bignum is still\n//! tracked for the actual usages, so it normally doesn't matter.\n\n// This module is only for dec2flt and flt2dec, and only public because of coretests.\n// It is not intended to ever be stabilized.\n#![doc(hidden)]\n#![unstable(feature = \"core_private_bignum\",\n            reason = \"internal routines only exposed for testing\",\n            issue = \"0\")]\n#![macro_use]\n\nuse mem;\nuse intrinsics;\n\n/// Arithmetic operations required by bignums.\npub trait FullOps: Sized {\n    /// Returns `(carry', v')` such that `carry' * 2^W + v' = self + other + carry`,\n    /// where `W` is the number of bits in `Self`.\n    fn full_add(self, other: Self, carry: bool) -> (bool /* carry */, Self);\n\n    /// Returns `(carry', v')` such that `carry' * 2^W + v' = self * other + carry`,\n    /// where `W` is the number of bits in `Self`.\n    fn full_mul(self, other: Self, carry: Self) -> (Self /* carry */, Self);\n\n    /// Returns `(carry', v')` such that `carry' * 2^W + v' = self * other + other2 + carry`,\n    /// where `W` is the number of bits in `Self`.\n    fn full_mul_add(self, other: Self, other2: Self, carry: Self) -> (Self /* carry */, Self);\n\n    /// Returns `(quo, rem)` such that `borrow * 2^W + self = quo * other + rem`\n    /// and `0 <= rem < other`, where `W` is the number of bits in `Self`.\n    fn full_div_rem(self,\n                    other: Self,\n                    borrow: Self)\n                    -> (Self /* quotient */, Self /* remainder */);\n}\n\nmacro_rules! impl_full_ops {\n    ($($ty:ty: add($addfn:path), mul/div($bigty:ident);)*) => (\n        $(\n            impl FullOps for $ty {\n                fn full_add(self, other: $ty, carry: bool) -> (bool, $ty) {\n                    // this cannot overflow, the output is between 0 and 2*2^nbits - 1\n                    // FIXME will LLVM optimize this into ADC or similar???\n                    let (v, carry1) = unsafe { intrinsics::add_with_overflow(self, other) };\n                    let (v, carry2) = unsafe {\n                        intrinsics::add_with_overflow(v, if carry {1} else {0})\n                    };\n                    (carry1 || carry2, v)\n                }\n\n                fn full_mul(self, other: $ty, carry: $ty) -> ($ty, $ty) {\n                    // this cannot overflow, the output is between 0 and 2^nbits * (2^nbits - 1)\n                    let nbits = mem::size_of::<$ty>() * 8;\n                    let v = (self as $bigty) * (other as $bigty) + (carry as $bigty);\n                    ((v >> nbits) as $ty, v as $ty)\n                }\n\n                fn full_mul_add(self, other: $ty, other2: $ty, carry: $ty) -> ($ty, $ty) {\n                    // this cannot overflow, the output is between 0 and 2^(2*nbits) - 1\n                    let nbits = mem::size_of::<$ty>() * 8;\n                    let v = (self as $bigty) * (other as $bigty) + (other2 as $bigty) +\n                            (carry as $bigty);\n                    ((v >> nbits) as $ty, v as $ty)\n                }\n\n                fn full_div_rem(self, other: $ty, borrow: $ty) -> ($ty, $ty) {\n                    debug_assert!(borrow < other);\n                    // this cannot overflow, the dividend is between 0 and other * 2^nbits - 1\n                    let nbits = mem::size_of::<$ty>() * 8;\n                    let lhs = ((borrow as $bigty) << nbits) | (self as $bigty);\n                    let rhs = other as $bigty;\n                    ((lhs / rhs) as $ty, (lhs % rhs) as $ty)\n                }\n            }\n        )*\n    )\n}\n\nimpl_full_ops! {\n    u8:  add(intrinsics::u8_add_with_overflow),  mul/div(u16);\n    u16: add(intrinsics::u16_add_with_overflow), mul/div(u32);\n    u32: add(intrinsics::u32_add_with_overflow), mul/div(u64);\n//  u64: add(intrinsics::u64_add_with_overflow), mul/div(u128); // see RFC #521 for enabling this.\n}\n\n/// Table of powers of 5 representable in digits. Specifically, the largest {u8, u16, u32} value\n/// that's a power of five, plus the corresponding exponent. Used in `mul_pow5`.\nconst SMALL_POW5: [(u64, usize); 3] = [(125, 3), (15625, 6), (1_220_703_125, 13)];\n\nmacro_rules! define_bignum {\n    ($name:ident: type=$ty:ty, n=$n:expr) => (\n        /// Stack-allocated arbitrary-precision (up to certain limit) integer.\n        ///\n        /// This is backed by a fixed-size array of given type (\"digit\").\n        /// While the array is not very large (normally some hundred bytes),\n        /// copying it recklessly may result in the performance hit.\n        /// Thus this is intentionally not `Copy`.\n        ///\n        /// All operations available to bignums panic in the case of overflows.\n        /// The caller is responsible to use large enough bignum types.\n        pub struct $name {\n            /// One plus the offset to the maximum \"digit\" in use.\n            /// This does not decrease, so be aware of the computation order.\n            /// `base[size..]` should be zero.\n            size: usize,\n            /// Digits. `[a, b, c, ...]` represents `a + b*2^W + c*2^(2W) + ...`\n            /// where `W` is the number of bits in the digit type.\n            base: [$ty; $n]\n        }\n\n        impl $name {\n            /// Makes a bignum from one digit.\n            pub fn from_small(v: $ty) -> $name {\n                let mut base = [0; $n];\n                base[0] = v;\n                $name { size: 1, base: base }\n            }\n\n            /// Makes a bignum from `u64` value.\n            pub fn from_u64(mut v: u64) -> $name {\n                use mem;\n\n                let mut base = [0; $n];\n                let mut sz = 0;\n                while v > 0 {\n                    base[sz] = v as $ty;\n                    v >>= mem::size_of::<$ty>() * 8;\n                    sz += 1;\n                }\n                $name { size: sz, base: base }\n            }\n\n            /// Returns the internal digits as a slice `[a, b, c, ...]` such that the numeric\n            /// value is `a + b * 2^W + c * 2^(2W) + ...` where `W` is the number of bits in\n            /// the digit type.\n            pub fn digits(&self) -> &[$ty] {\n                &self.base[..self.size]\n            }\n\n            /// Returns the `i`-th bit where bit 0 is the least significant one.\n            /// In other words, the bit with weight `2^i`.\n            pub fn get_bit(&self, i: usize) -> u8 {\n                use mem;\n\n                let digitbits = mem::size_of::<$ty>() * 8;\n                let d = i / digitbits;\n                let b = i % digitbits;\n                ((self.base[d] >> b) & 1) as u8\n            }\n\n            /// Returns `true` if the bignum is zero.\n            pub fn is_zero(&self) -> bool {\n                self.digits().iter().all(|&v| v == 0)\n            }\n\n            /// Returns the number of bits necessary to represent this value. Note that zero\n            /// is considered to need 0 bits.\n            pub fn bit_length(&self) -> usize {\n                use mem;\n\n                // Skip over the most significant digits which are zero.\n                let digits = self.digits();\n                let zeros = digits.iter().rev().take_while(|&&x| x == 0).count();\n                let end = digits.len() - zeros;\n                let nonzero = &digits[..end];\n\n                if nonzero.is_empty() {\n                    // There are no non-zero digits, i.e. the number is zero.\n                    return 0;\n                }\n                // This could be optimized with leading_zeros() and bit shifts, but that's\n                // probably not worth the hassle.\n                let digitbits = mem::size_of::<$ty>()* 8;\n                let mut i = nonzero.len() * digitbits - 1;\n                while self.get_bit(i) == 0 {\n                    i -= 1;\n                }\n                i + 1\n            }\n\n            /// Adds `other` to itself and returns its own mutable reference.\n            pub fn add<'a>(&'a mut self, other: &$name) -> &'a mut $name {\n                use cmp;\n                use num::bignum::FullOps;\n\n                let mut sz = cmp::max(self.size, other.size);\n                let mut carry = false;\n                for (a, b) in self.base[..sz].iter_mut().zip(&other.base[..sz]) {\n                    let (c, v) = (*a).full_add(*b, carry);\n                    *a = v;\n                    carry = c;\n                }\n                if carry {\n                    self.base[sz] = 1;\n                    sz += 1;\n                }\n                self.size = sz;\n                self\n            }\n\n            pub fn add_small(&mut self, other: $ty) -> &mut $name {\n                use num::bignum::FullOps;\n\n                let (mut carry, v) = self.base[0].full_add(other, false);\n                self.base[0] = v;\n                let mut i = 1;\n                while carry {\n                    let (c, v) = self.base[i].full_add(0, carry);\n                    self.base[i] = v;\n                    carry = c;\n                    i += 1;\n                }\n                if i > self.size {\n                    self.size = i;\n                }\n                self\n            }\n\n            /// Subtracts `other` from itself and returns its own mutable reference.\n            pub fn sub<'a>(&'a mut self, other: &$name) -> &'a mut $name {\n                use cmp;\n                use num::bignum::FullOps;\n\n                let sz = cmp::max(self.size, other.size);\n                let mut noborrow = true;\n                for (a, b) in self.base[..sz].iter_mut().zip(&other.base[..sz]) {\n                    let (c, v) = (*a).full_add(!*b, noborrow);\n                    *a = v;\n                    noborrow = c;\n                }\n                assert!(noborrow);\n                self.size = sz;\n                self\n            }\n\n            /// Multiplies itself by a digit-sized `other` and returns its own\n            /// mutable reference.\n            pub fn mul_small(&mut self, other: $ty) -> &mut $name {\n                use num::bignum::FullOps;\n\n                let mut sz = self.size;\n                let mut carry = 0;\n                for a in &mut self.base[..sz] {\n                    let (c, v) = (*a).full_mul(other, carry);\n                    *a = v;\n                    carry = c;\n                }\n                if carry > 0 {\n                    self.base[sz] = carry;\n                    sz += 1;\n                }\n                self.size = sz;\n                self\n            }\n\n            /// Multiplies itself by `2^bits` and returns its own mutable reference.\n            pub fn mul_pow2(&mut self, bits: usize) -> &mut $name {\n                use mem;\n\n                let digitbits = mem::size_of::<$ty>() * 8;\n                let digits = bits / digitbits;\n                let bits = bits % digitbits;\n\n                assert!(digits < $n);\n                debug_assert!(self.base[$n-digits..].iter().all(|&v| v == 0));\n                debug_assert!(bits == 0 || (self.base[$n-digits-1] >> (digitbits - bits)) == 0);\n\n                // shift by `digits * digitbits` bits\n                for i in (0..self.size).rev() {\n                    self.base[i+digits] = self.base[i];\n                }\n                for i in 0..digits {\n                    self.base[i] = 0;\n                }\n\n                // shift by `bits` bits\n                let mut sz = self.size + digits;\n                if bits > 0 {\n                    let last = sz;\n                    let overflow = self.base[last-1] >> (digitbits - bits);\n                    if overflow > 0 {\n                        self.base[last] = overflow;\n                        sz += 1;\n                    }\n                    for i in (digits+1..last).rev() {\n                        self.base[i] = (self.base[i] << bits) |\n                                       (self.base[i-1] >> (digitbits - bits));\n                    }\n                    self.base[digits] <<= bits;\n                    // self.base[..digits] is zero, no need to shift\n                }\n\n                self.size = sz;\n                self\n            }\n\n            /// Multiplies itself by `5^e` and returns its own mutable reference.\n            pub fn mul_pow5(&mut self, mut e: usize) -> &mut $name {\n                use mem;\n                use num::bignum::SMALL_POW5;\n\n                // There are exactly n trailing zeros on 2^n, and the only relevant digit sizes\n                // are consecutive powers of two, so this is well suited index for the table.\n                let table_index = mem::size_of::<$ty>().trailing_zeros() as usize;\n                let (small_power, small_e) = SMALL_POW5[table_index];\n                let small_power = small_power as $ty;\n\n                // Multiply with the largest single-digit power as long as possible ...\n                while e >= small_e {\n                    self.mul_small(small_power);\n                    e -= small_e;\n                }\n\n                // ... then finish off the remainder.\n                let mut rest_power = 1;\n                for _ in 0..e {\n                    rest_power *= 5;\n                }\n                self.mul_small(rest_power);\n\n                self\n            }\n\n\n            /// Multiplies itself by a number described by `other[0] + other[1] * 2^W +\n            /// other[2] * 2^(2W) + ...` (where `W` is the number of bits in the digit type)\n            /// and returns its own mutable reference.\n            pub fn mul_digits<'a>(&'a mut self, other: &[$ty]) -> &'a mut $name {\n                // the internal routine. works best when aa.len() <= bb.len().\n                fn mul_inner(ret: &mut [$ty; $n], aa: &[$ty], bb: &[$ty]) -> usize {\n                    use num::bignum::FullOps;\n\n                    let mut retsz = 0;\n                    for (i, &a) in aa.iter().enumerate() {\n                        if a == 0 { continue; }\n                        let mut sz = bb.len();\n                        let mut carry = 0;\n                        for (j, &b) in bb.iter().enumerate() {\n                            let (c, v) = a.full_mul_add(b, ret[i + j], carry);\n                            ret[i + j] = v;\n                            carry = c;\n                        }\n                        if carry > 0 {\n                            ret[i + sz] = carry;\n                            sz += 1;\n                        }\n                        if retsz < i + sz {\n                            retsz = i + sz;\n                        }\n                    }\n                    retsz\n                }\n\n                let mut ret = [0; $n];\n                let retsz = if self.size < other.len() {\n                    mul_inner(&mut ret, &self.digits(), other)\n                } else {\n                    mul_inner(&mut ret, other, &self.digits())\n                };\n                self.base = ret;\n                self.size = retsz;\n                self\n            }\n\n            /// Divides itself by a digit-sized `other` and returns its own\n            /// mutable reference *and* the remainder.\n            pub fn div_rem_small(&mut self, other: $ty) -> (&mut $name, $ty) {\n                use num::bignum::FullOps;\n\n                assert!(other > 0);\n\n                let sz = self.size;\n                let mut borrow = 0;\n                for a in self.base[..sz].iter_mut().rev() {\n                    let (q, r) = (*a).full_div_rem(other, borrow);\n                    *a = q;\n                    borrow = r;\n                }\n                (self, borrow)\n            }\n\n            /// Divide self by another bignum, overwriting `q` with the quotient and `r` with the\n            /// remainder.\n            pub fn div_rem(&self, d: &$name, q: &mut $name, r: &mut $name) {\n                use mem;\n\n                // Stupid slow base-2 long division taken from\n                // https://en.wikipedia.org/wiki/Division_algorithm\n                // FIXME use a greater base ($ty) for the long division.\n                assert!(!d.is_zero());\n                let digitbits = mem::size_of::<$ty>() * 8;\n                for digit in &mut q.base[..] {\n                    *digit = 0;\n                }\n                for digit in &mut r.base[..] {\n                    *digit = 0;\n                }\n                r.size = d.size;\n                q.size = 1;\n                let mut q_is_zero = true;\n                let end = self.bit_length();\n                for i in (0..end).rev() {\n                    r.mul_pow2(1);\n                    r.base[0] |= self.get_bit(i) as $ty;\n                    if &*r >= d {\n                        r.sub(d);\n                        // Set bit `i` of q to 1.\n                        let digit_idx = i / digitbits;\n                        let bit_idx = i % digitbits;\n                        if q_is_zero {\n                            q.size = digit_idx + 1;\n                            q_is_zero = false;\n                        }\n                        q.base[digit_idx] |= 1 << bit_idx;\n                    }\n                }\n                debug_assert!(q.base[q.size..].iter().all(|&d| d == 0));\n                debug_assert!(r.base[r.size..].iter().all(|&d| d == 0));\n            }\n        }\n\n        impl ::cmp::PartialEq for $name {\n            fn eq(&self, other: &$name) -> bool { self.base[..] == other.base[..] }\n        }\n\n        impl ::cmp::Eq for $name {\n        }\n\n        impl ::cmp::PartialOrd for $name {\n            fn partial_cmp(&self, other: &$name) -> ::option::Option<::cmp::Ordering> {\n                ::option::Option::Some(self.cmp(other))\n            }\n        }\n\n        impl ::cmp::Ord for $name {\n            fn cmp(&self, other: &$name) -> ::cmp::Ordering {\n                use cmp::max;\n                let sz = max(self.size, other.size);\n                let lhs = self.base[..sz].iter().cloned().rev();\n                let rhs = other.base[..sz].iter().cloned().rev();\n                lhs.cmp(rhs)\n            }\n        }\n\n        impl ::clone::Clone for $name {\n            fn clone(&self) -> $name {\n                $name { size: self.size, base: self.base }\n            }\n        }\n\n        impl ::fmt::Debug for $name {\n            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {\n                use mem;\n\n                let sz = if self.size < 1 {1} else {self.size};\n                let digitlen = mem::size_of::<$ty>() * 2;\n\n                write!(f, \"{:#x}\", self.base[sz-1])?;\n                for &v in self.base[..sz-1].iter().rev() {\n                    write!(f, \"_{:01$x}\", v, digitlen)?;\n                }\n                ::result::Result::Ok(())\n            }\n        }\n    )\n}\n\n/// The digit type for `Big32x40`.\npub type Digit32 = u32;\n\ndefine_bignum!(Big32x40: type=Digit32, n=40);\n\n// this one is used for testing only.\n#[doc(hidden)]\npub mod tests {\n    define_bignum!(Big8x3: type=u8, n=3);\n}\n","// Copyright 2015 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Extended precision \"soft float\", for internal use only.\n\n// This module is only for dec2flt and flt2dec, and only public because of coretests.\n// It is not intended to ever be stabilized.\n#![doc(hidden)]\n#![unstable(feature = \"core_private_diy_float\",\n            reason = \"internal routines only exposed for testing\",\n            issue = \"0\")]\n\n/// A custom 64-bit floating point type, representing `f * 2^e`.\n#[derive(Copy, Clone, Debug)]\n#[doc(hidden)]\npub struct Fp {\n    /// The integer mantissa.\n    pub f: u64,\n    /// The exponent in base 2.\n    pub e: i16,\n}\n\nimpl Fp {\n    /// Returns a correctly rounded product of itself and `other`.\n    pub fn mul(&self, other: &Fp) -> Fp {\n        const MASK: u64 = 0xffffffff;\n        let a = self.f >> 32;\n        let b = self.f & MASK;\n        let c = other.f >> 32;\n        let d = other.f & MASK;\n        let ac = a * c;\n        let bc = b * c;\n        let ad = a * d;\n        let bd = b * d;\n        let tmp = (bd >> 32) + (ad & MASK) + (bc & MASK) + (1 << 31) /* round */;\n        let f = ac + (ad >> 32) + (bc >> 32) + (tmp >> 32);\n        let e = self.e + other.e + 64;\n        Fp { f, e }\n    }\n\n    /// Normalizes itself so that the resulting mantissa is at least `2^63`.\n    pub fn normalize(&self) -> Fp {\n        let mut f = self.f;\n        let mut e = self.e;\n        if f >> (64 - 32) == 0 {\n            f <<= 32;\n            e -= 32;\n        }\n        if f >> (64 - 16) == 0 {\n            f <<= 16;\n            e -= 16;\n        }\n        if f >> (64 - 8) == 0 {\n            f <<= 8;\n            e -= 8;\n        }\n        if f >> (64 - 4) == 0 {\n            f <<= 4;\n            e -= 4;\n        }\n        if f >> (64 - 2) == 0 {\n            f <<= 2;\n            e -= 2;\n        }\n        if f >> (64 - 1) == 0 {\n            f <<= 1;\n            e -= 1;\n        }\n        debug_assert!(f >= (1 >> 63));\n        Fp { f, e }\n    }\n\n    /// Normalizes itself to have the shared exponent.\n    /// It can only decrease the exponent (and thus increase the mantissa).\n    pub fn normalize_to(&self, e: i16) -> Fp {\n        let edelta = self.e - e;\n        assert!(edelta >= 0);\n        let edelta = edelta as usize;\n        assert_eq!(self.f << edelta >> edelta, self.f);\n        Fp {\n            f: self.f << edelta,\n            e,\n        }\n    }\n}\n","// Copyright 2012-2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse char;\nuse str as core_str;\nuse fmt;\nuse fmt::Write;\nuse mem;\n\n/// Lossy UTF-8 string.\n#[unstable(feature = \"str_internals\", issue = \"0\")]\npub struct Utf8Lossy {\n    bytes: [u8]\n}\n\nimpl Utf8Lossy {\n    pub fn from_str(s: &str) -> &Utf8Lossy {\n        Utf8Lossy::from_bytes(s.as_bytes())\n    }\n\n    pub fn from_bytes(bytes: &[u8]) -> &Utf8Lossy {\n        unsafe { mem::transmute(bytes) }\n    }\n\n    pub fn chunks(&self) -> Utf8LossyChunksIter {\n        Utf8LossyChunksIter { source: &self.bytes }\n    }\n}\n\n\n/// Iterator over lossy UTF-8 string\n#[unstable(feature = \"str_internals\", issue = \"0\")]\n#[allow(missing_debug_implementations)]\npub struct Utf8LossyChunksIter<'a> {\n    source: &'a [u8],\n}\n\n#[unstable(feature = \"str_internals\", issue = \"0\")]\n#[derive(PartialEq, Eq, Debug)]\npub struct Utf8LossyChunk<'a> {\n    /// Sequence of valid chars.\n    /// Can be empty between broken UTF-8 chars.\n    pub valid: &'a str,\n    /// Single broken char, empty if none.\n    /// Empty iff iterator item is last.\n    pub broken: &'a [u8],\n}\n\nimpl<'a> Iterator for Utf8LossyChunksIter<'a> {\n    type Item = Utf8LossyChunk<'a>;\n\n    fn next(&mut self) -> Option<Utf8LossyChunk<'a>> {\n        if self.source.len() == 0 {\n            return None;\n        }\n\n        const TAG_CONT_U8: u8 = 128;\n        fn unsafe_get(xs: &[u8], i: usize) -> u8 {\n            unsafe { *xs.get_unchecked(i) }\n        }\n        fn safe_get(xs: &[u8], i: usize) -> u8 {\n            if i >= xs.len() { 0 } else { unsafe_get(xs, i) }\n        }\n\n        let mut i = 0;\n        while i < self.source.len() {\n            let i_ = i;\n\n            let byte = unsafe_get(self.source, i);\n            i += 1;\n\n            if byte < 128 {\n\n            } else {\n                let w = core_str::utf8_char_width(byte);\n\n                macro_rules! error { () => ({\n                    unsafe {\n                        let r = Utf8LossyChunk {\n                            valid: core_str::from_utf8_unchecked(&self.source[0..i_]),\n                            broken: &self.source[i_..i],\n                        };\n                        self.source = &self.source[i..];\n                        return Some(r);\n                    }\n                })}\n\n                match w {\n                    2 => {\n                        if safe_get(self.source, i) & 192 != TAG_CONT_U8 {\n                            error!();\n                        }\n                        i += 1;\n                    }\n                    3 => {\n                        match (byte, safe_get(self.source, i)) {\n                            (0xE0, 0xA0 ..= 0xBF) => (),\n                            (0xE1 ..= 0xEC, 0x80 ..= 0xBF) => (),\n                            (0xED, 0x80 ..= 0x9F) => (),\n                            (0xEE ..= 0xEF, 0x80 ..= 0xBF) => (),\n                            _ => {\n                                error!();\n                            }\n                        }\n                        i += 1;\n                        if safe_get(self.source, i) & 192 != TAG_CONT_U8 {\n                            error!();\n                        }\n                        i += 1;\n                    }\n                    4 => {\n                        match (byte, safe_get(self.source, i)) {\n                            (0xF0, 0x90 ..= 0xBF) => (),\n                            (0xF1 ..= 0xF3, 0x80 ..= 0xBF) => (),\n                            (0xF4, 0x80 ..= 0x8F) => (),\n                            _ => {\n                                error!();\n                            }\n                        }\n                        i += 1;\n                        if safe_get(self.source, i) & 192 != TAG_CONT_U8 {\n                            error!();\n                        }\n                        i += 1;\n                        if safe_get(self.source, i) & 192 != TAG_CONT_U8 {\n                            error!();\n                        }\n                        i += 1;\n                    }\n                    _ => {\n                        error!();\n                    }\n                }\n            }\n        }\n\n        let r = Utf8LossyChunk {\n            valid: unsafe { core_str::from_utf8_unchecked(self.source) },\n            broken: &[],\n        };\n        self.source = &[];\n        Some(r)\n    }\n}\n\n\nimpl fmt::Display for Utf8Lossy {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        // If we're the empty string then our iterator won't actually yield\n        // anything, so perform the formatting manually\n        if self.bytes.len() == 0 {\n            return \"\".fmt(f)\n        }\n\n        for Utf8LossyChunk { valid, broken } in self.chunks() {\n            // If we successfully decoded the whole chunk as a valid string then\n            // we can return a direct formatting of the string which will also\n            // respect various formatting flags if possible.\n            if valid.len() == self.bytes.len() {\n                assert!(broken.is_empty());\n                return valid.fmt(f)\n            }\n\n            f.write_str(valid)?;\n            if !broken.is_empty() {\n                f.write_char(char::REPLACEMENT_CHARACTER)?;\n            }\n        }\n        Ok(())\n    }\n}\n\nimpl fmt::Debug for Utf8Lossy {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.write_char('\"')?;\n\n        for Utf8LossyChunk { valid, broken } in self.chunks() {\n\n            // Valid part.\n            // Here we partially parse UTF-8 again which is suboptimal.\n            {\n                let mut from = 0;\n                for (i, c) in valid.char_indices() {\n                    let esc = c.escape_debug();\n                    // If char needs escaping, flush backlog so far and write, else skip\n                    if esc.len() != 1 {\n                        f.write_str(&valid[from..i])?;\n                        for c in esc {\n                            f.write_char(c)?;\n                        }\n                        from = i + c.len_utf8();\n                    }\n                }\n                f.write_str(&valid[from..])?;\n            }\n\n            // Broken parts of string as hex escape.\n            for &b in broken {\n                write!(f, \"\\\\x{:02x}\", b)?;\n            }\n        }\n\n        f.write_char('\"')\n    }\n}\n","// Copyright 2017 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\nuse fmt::{Formatter, Result, LowerExp, UpperExp, Display, Debug};\nuse mem;\nuse num::flt2dec;\n\n// Don't inline this so callers don't use the stack space this function\n// requires unless they have to.\n#[inline(never)]\nfn float_to_decimal_common_exact<T>(fmt: &mut Formatter, num: &T,\n                                    sign: flt2dec::Sign, precision: usize) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    unsafe {\n        let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64\n        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();\n        let formatted = flt2dec::to_exact_fixed_str(flt2dec::strategy::grisu::format_exact,\n                                                    *num, sign, precision,\n                                                    false, &mut buf, &mut parts);\n        fmt.pad_formatted_parts(&formatted)\n    }\n}\n\n// Don't inline this so callers that call both this and the above won't wind\n// up using the combined stack space of both functions in some cases.\n#[inline(never)]\nfn float_to_decimal_common_shortest<T>(fmt: &mut Formatter, num: &T,\n                                       sign: flt2dec::Sign, precision: usize) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    unsafe {\n        // enough for f32 and f64\n        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();\n        let mut parts: [flt2dec::Part; 4] = mem::uninitialized();\n        let formatted = flt2dec::to_shortest_str(flt2dec::strategy::grisu::format_shortest, *num,\n                                                 sign, precision, false, &mut buf, &mut parts);\n        fmt.pad_formatted_parts(&formatted)\n    }\n}\n\n// Common code of floating point Debug and Display.\nfn float_to_decimal_common<T>(fmt: &mut Formatter, num: &T,\n                              negative_zero: bool, min_precision: usize) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    let force_sign = fmt.sign_plus();\n    let sign = match (force_sign, negative_zero) {\n        (false, false) => flt2dec::Sign::Minus,\n        (false, true)  => flt2dec::Sign::MinusRaw,\n        (true,  false) => flt2dec::Sign::MinusPlus,\n        (true,  true)  => flt2dec::Sign::MinusPlusRaw,\n    };\n\n    if let Some(precision) = fmt.precision {\n        float_to_decimal_common_exact(fmt, num, sign, precision)\n    } else {\n        float_to_decimal_common_shortest(fmt, num, sign, min_precision)\n    }\n}\n\n// Don't inline this so callers don't use the stack space this function\n// requires unless they have to.\n#[inline(never)]\nfn float_to_exponential_common_exact<T>(fmt: &mut Formatter, num: &T,\n                                        sign: flt2dec::Sign, precision: usize,\n                                        upper: bool) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    unsafe {\n        let mut buf: [u8; 1024] = mem::uninitialized(); // enough for f32 and f64\n        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();\n        let formatted = flt2dec::to_exact_exp_str(flt2dec::strategy::grisu::format_exact,\n                                                  *num, sign, precision,\n                                                  upper, &mut buf, &mut parts);\n        fmt.pad_formatted_parts(&formatted)\n    }\n}\n\n// Don't inline this so callers that call both this and the above won't wind\n// up using the combined stack space of both functions in some cases.\n#[inline(never)]\nfn float_to_exponential_common_shortest<T>(fmt: &mut Formatter,\n                                           num: &T, sign: flt2dec::Sign,\n                                           upper: bool) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    unsafe {\n        // enough for f32 and f64\n        let mut buf: [u8; flt2dec::MAX_SIG_DIGITS] = mem::uninitialized();\n        let mut parts: [flt2dec::Part; 6] = mem::uninitialized();\n        let formatted = flt2dec::to_shortest_exp_str(flt2dec::strategy::grisu::format_shortest,\n                                                     *num, sign, (0, 0), upper,\n                                                     &mut buf, &mut parts);\n        fmt.pad_formatted_parts(&formatted)\n    }\n}\n\n// Common code of floating point LowerExp and UpperExp.\nfn float_to_exponential_common<T>(fmt: &mut Formatter, num: &T, upper: bool) -> Result\n    where T: flt2dec::DecodableFloat\n{\n    let force_sign = fmt.sign_plus();\n    let sign = match force_sign {\n        false => flt2dec::Sign::Minus,\n        true  => flt2dec::Sign::MinusPlus,\n    };\n\n    if let Some(precision) = fmt.precision {\n        // 1 integral digit + `precision` fractional digits = `precision + 1` total digits\n        float_to_exponential_common_exact(fmt, num, sign, precision + 1, upper)\n    } else {\n        float_to_exponential_common_shortest(fmt, num, sign, upper)\n    }\n}\n\nmacro_rules! floating {\n    ($ty:ident) => (\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Debug for $ty {\n            fn fmt(&self, fmt: &mut Formatter) -> Result {\n                float_to_decimal_common(fmt, self, true, 1)\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Display for $ty {\n            fn fmt(&self, fmt: &mut Formatter) -> Result {\n                float_to_decimal_common(fmt, self, false, 0)\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl LowerExp for $ty {\n            fn fmt(&self, fmt: &mut Formatter) -> Result {\n                float_to_exponential_common(fmt, self, false)\n            }\n        }\n\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl UpperExp for $ty {\n            fn fmt(&self, fmt: &mut Formatter) -> Result {\n                float_to_exponential_common(fmt, self, true)\n            }\n        }\n    )\n}\n\nfloating! { f32 }\nfloating! { f64 }\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! This module provides constants which are specific to the implementation\n//! of the `f32` floating point data type.\n//!\n//! *[See also the `f32` primitive type](../../std/primitive.f32.html).*\n//!\n//! Mathematically significant numbers are provided in the `consts` sub-module.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse mem;\nuse num::FpCategory;\n\n/// The radix or base of the internal representation of `f32`.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const RADIX: u32 = 2;\n\n/// Number of significant digits in base 2.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MANTISSA_DIGITS: u32 = 24;\n/// Approximate number of significant digits in base 10.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const DIGITS: u32 = 6;\n\n/// [Machine epsilon] value for `f32`.\n///\n/// This is the difference between `1.0` and the next largest representable number.\n///\n/// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const EPSILON: f32 = 1.19209290e-07_f32;\n\n/// Smallest finite `f32` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN: f32 = -3.40282347e+38_f32;\n/// Smallest positive normal `f32` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_POSITIVE: f32 = 1.17549435e-38_f32;\n/// Largest finite `f32` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX: f32 = 3.40282347e+38_f32;\n\n/// One greater than the minimum possible normal power of 2 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_EXP: i32 = -125;\n/// Maximum possible power of 2 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX_EXP: i32 = 128;\n\n/// Minimum possible normal power of 10 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_10_EXP: i32 = -37;\n/// Maximum possible power of 10 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX_10_EXP: i32 = 38;\n\n/// Not a Number (NaN).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const NAN: f32 = 0.0_f32 / 0.0_f32;\n/// Infinity (\u221e).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const INFINITY: f32 = 1.0_f32 / 0.0_f32;\n/// Negative infinity (-\u221e).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const NEG_INFINITY: f32 = -1.0_f32 / 0.0_f32;\n\n/// Basic mathematical constants.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub mod consts {\n    // FIXME: replace with mathematical constants from cmath.\n\n    /// Archimedes' constant (\u03c0)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const PI: f32 = 3.14159265358979323846264338327950288_f32;\n\n    /// \u03c0/2\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_2: f32 = 1.57079632679489661923132169163975144_f32;\n\n    /// \u03c0/3\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_3: f32 = 1.04719755119659774615421446109316763_f32;\n\n    /// \u03c0/4\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_4: f32 = 0.785398163397448309615660845819875721_f32;\n\n    /// \u03c0/6\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_6: f32 = 0.52359877559829887307710723054658381_f32;\n\n    /// \u03c0/8\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_8: f32 = 0.39269908169872415480783042290993786_f32;\n\n    /// 1/\u03c0\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_1_PI: f32 = 0.318309886183790671537767526745028724_f32;\n\n    /// 2/\u03c0\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_2_PI: f32 = 0.636619772367581343075535053490057448_f32;\n\n    /// 2/sqrt(\u03c0)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_2_SQRT_PI: f32 = 1.12837916709551257389615890312154517_f32;\n\n    /// sqrt(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const SQRT_2: f32 = 1.41421356237309504880168872420969808_f32;\n\n    /// 1/sqrt(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_1_SQRT_2: f32 = 0.707106781186547524400844362104849039_f32;\n\n    /// Euler's number (e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const E: f32 = 2.71828182845904523536028747135266250_f32;\n\n    /// log<sub>2</sub>(e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LOG2_E: f32 = 1.44269504088896340735992468100189214_f32;\n\n    /// log<sub>2</sub>(10)\n    #[unstable(feature = \"extra_log_consts\", issue = \"50540\")]\n    pub const LOG2_10: f32 = 3.32192809488736234787031942948939018_f32;\n\n    /// log<sub>10</sub>(e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LOG10_E: f32 = 0.434294481903251827651128918916605082_f32;\n\n    /// log<sub>10</sub>(2)\n    #[unstable(feature = \"extra_log_consts\", issue = \"50540\")]\n    pub const LOG10_2: f32 = 0.301029995663981195213738894724493027_f32;\n\n    /// ln(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LN_2: f32 = 0.693147180559945309417232121458176568_f32;\n\n    /// ln(10)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;\n}\n\n#[lang = \"f32\"]\n#[cfg(not(test))]\nimpl f32 {\n    /// Returns `true` if this value is `NaN` and false otherwise.\n    ///\n    /// ```\n    /// use std::f32;\n    ///\n    /// let nan = f32::NAN;\n    /// let f = 7.0_f32;\n    ///\n    /// assert!(nan.is_nan());\n    /// assert!(!f.is_nan());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_nan(self) -> bool {\n        self != self\n    }\n\n    /// Returns `true` if this value is positive infinity or negative infinity and\n    /// false otherwise.\n    ///\n    /// ```\n    /// use std::f32;\n    ///\n    /// let f = 7.0f32;\n    /// let inf = f32::INFINITY;\n    /// let neg_inf = f32::NEG_INFINITY;\n    /// let nan = f32::NAN;\n    ///\n    /// assert!(!f.is_infinite());\n    /// assert!(!nan.is_infinite());\n    ///\n    /// assert!(inf.is_infinite());\n    /// assert!(neg_inf.is_infinite());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_infinite(self) -> bool {\n        self == INFINITY || self == NEG_INFINITY\n    }\n\n    /// Returns `true` if this number is neither infinite nor `NaN`.\n    ///\n    /// ```\n    /// use std::f32;\n    ///\n    /// let f = 7.0f32;\n    /// let inf = f32::INFINITY;\n    /// let neg_inf = f32::NEG_INFINITY;\n    /// let nan = f32::NAN;\n    ///\n    /// assert!(f.is_finite());\n    ///\n    /// assert!(!nan.is_finite());\n    /// assert!(!inf.is_finite());\n    /// assert!(!neg_inf.is_finite());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_finite(self) -> bool {\n        !(self.is_nan() || self.is_infinite())\n    }\n\n    /// Returns `true` if the number is neither zero, infinite,\n    /// [subnormal][subnormal], or `NaN`.\n    ///\n    /// ```\n    /// use std::f32;\n    ///\n    /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32\n    /// let max = f32::MAX;\n    /// let lower_than_min = 1.0e-40_f32;\n    /// let zero = 0.0_f32;\n    ///\n    /// assert!(min.is_normal());\n    /// assert!(max.is_normal());\n    ///\n    /// assert!(!zero.is_normal());\n    /// assert!(!f32::NAN.is_normal());\n    /// assert!(!f32::INFINITY.is_normal());\n    /// // Values between `0` and `min` are Subnormal.\n    /// assert!(!lower_than_min.is_normal());\n    /// ```\n    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_normal(self) -> bool {\n        self.classify() == FpCategory::Normal\n    }\n\n    /// Returns the floating point category of the number. If only one property\n    /// is going to be tested, it is generally faster to use the specific\n    /// predicate instead.\n    ///\n    /// ```\n    /// use std::num::FpCategory;\n    /// use std::f32;\n    ///\n    /// let num = 12.4_f32;\n    /// let inf = f32::INFINITY;\n    ///\n    /// assert_eq!(num.classify(), FpCategory::Normal);\n    /// assert_eq!(inf.classify(), FpCategory::Infinite);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn classify(self) -> FpCategory {\n        const EXP_MASK: u32 = 0x7f800000;\n        const MAN_MASK: u32 = 0x007fffff;\n\n        let bits = self.to_bits();\n        match (bits & MAN_MASK, bits & EXP_MASK) {\n            (0, 0) => FpCategory::Zero,\n            (_, 0) => FpCategory::Subnormal,\n            (0, EXP_MASK) => FpCategory::Infinite,\n            (_, EXP_MASK) => FpCategory::Nan,\n            _ => FpCategory::Normal,\n        }\n    }\n\n    /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with\n    /// positive sign bit and positive infinity.\n    ///\n    /// ```\n    /// let f = 7.0_f32;\n    /// let g = -7.0_f32;\n    ///\n    /// assert!(f.is_sign_positive());\n    /// assert!(!g.is_sign_positive());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_sign_positive(self) -> bool {\n        !self.is_sign_negative()\n    }\n\n    /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with\n    /// negative sign bit and negative infinity.\n    ///\n    /// ```\n    /// let f = 7.0f32;\n    /// let g = -7.0f32;\n    ///\n    /// assert!(!f.is_sign_negative());\n    /// assert!(g.is_sign_negative());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_sign_negative(self) -> bool {\n        // IEEE754 says: isSignMinus(x) is true if and only if x has negative sign. isSignMinus\n        // applies to zeros and NaNs as well.\n        self.to_bits() & 0x8000_0000 != 0\n    }\n\n    /// Takes the reciprocal (inverse) of a number, `1/x`.\n    ///\n    /// ```\n    /// use std::f32;\n    ///\n    /// let x = 2.0_f32;\n    /// let abs_difference = (x.recip() - (1.0/x)).abs();\n    ///\n    /// assert!(abs_difference <= f32::EPSILON);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn recip(self) -> f32 {\n        1.0 / self\n    }\n\n    /// Converts radians to degrees.\n    ///\n    /// ```\n    /// use std::f32::{self, consts};\n    ///\n    /// let angle = consts::PI;\n    ///\n    /// let abs_difference = (angle.to_degrees() - 180.0).abs();\n    ///\n    /// assert!(abs_difference <= f32::EPSILON);\n    /// ```\n    #[stable(feature = \"f32_deg_rad_conversions\", since=\"1.7.0\")]\n    #[inline]\n    pub fn to_degrees(self) -> f32 {\n        // Use a constant for better precision.\n        const PIS_IN_180: f32 = 57.2957795130823208767981548141051703_f32;\n        self * PIS_IN_180\n    }\n\n    /// Converts degrees to radians.\n    ///\n    /// ```\n    /// use std::f32::{self, consts};\n    ///\n    /// let angle = 180.0f32;\n    ///\n    /// let abs_difference = (angle.to_radians() - consts::PI).abs();\n    ///\n    /// assert!(abs_difference <= f32::EPSILON);\n    /// ```\n    #[stable(feature = \"f32_deg_rad_conversions\", since=\"1.7.0\")]\n    #[inline]\n    pub fn to_radians(self) -> f32 {\n        let value: f32 = consts::PI;\n        self * (value / 180.0f32)\n    }\n\n    /// Returns the maximum of the two numbers.\n    ///\n    /// ```\n    /// let x = 1.0f32;\n    /// let y = 2.0f32;\n    ///\n    /// assert_eq!(x.max(y), y);\n    /// ```\n    ///\n    /// If one of the arguments is NaN, then the other argument is returned.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn max(self, other: f32) -> f32 {\n        // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the\n        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it\n        // is either x or y, canonicalized (this means results might differ among implementations).\n        // When either x or y is a signalingNaN, then the result is according to 6.2.\n        //\n        // Since we do not support sNaN in Rust yet, we do not need to handle them.\n        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by\n        // multiplying by 1.0. Should switch to the `canonicalize` when it works.\n        (if self.is_nan() || self < other { other } else { self }) * 1.0\n    }\n\n    /// Returns the minimum of the two numbers.\n    ///\n    /// ```\n    /// let x = 1.0f32;\n    /// let y = 2.0f32;\n    ///\n    /// assert_eq!(x.min(y), x);\n    /// ```\n    ///\n    /// If one of the arguments is NaN, then the other argument is returned.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn min(self, other: f32) -> f32 {\n        // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the\n        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it\n        // is either x or y, canonicalized (this means results might differ among implementations).\n        // When either x or y is a signalingNaN, then the result is according to 6.2.\n        //\n        // Since we do not support sNaN in Rust yet, we do not need to handle them.\n        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by\n        // multiplying by 1.0. Should switch to the `canonicalize` when it works.\n        (if other.is_nan() || self < other { self } else { other }) * 1.0\n    }\n\n    /// Raw transmutation to `u32`.\n    ///\n    /// This is currently identical to `transmute::<f32, u32>(self)` on all platforms.\n    ///\n    /// See `from_bits` for some discussion of the portability of this operation\n    /// (there are almost no issues).\n    ///\n    /// Note that this function is distinct from `as` casting, which attempts to\n    /// preserve the *numeric* value, and not the bitwise value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert_ne!((1f32).to_bits(), 1f32 as u32); // to_bits() is not casting!\n    /// assert_eq!((12.5f32).to_bits(), 0x41480000);\n    ///\n    /// ```\n    #[stable(feature = \"float_bits_conv\", since = \"1.20.0\")]\n    #[inline]\n    pub fn to_bits(self) -> u32 {\n        unsafe { mem::transmute(self) }\n    }\n\n    /// Raw transmutation from `u32`.\n    ///\n    /// This is currently identical to `transmute::<u32, f32>(v)` on all platforms.\n    /// It turns out this is incredibly portable, for two reasons:\n    ///\n    /// * Floats and Ints have the same endianness on all supported platforms.\n    /// * IEEE-754 very precisely specifies the bit layout of floats.\n    ///\n    /// However there is one caveat: prior to the 2008 version of IEEE-754, how\n    /// to interpret the NaN signaling bit wasn't actually specified. Most platforms\n    /// (notably x86 and ARM) picked the interpretation that was ultimately\n    /// standardized in 2008, but some didn't (notably MIPS). As a result, all\n    /// signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.\n    ///\n    /// Rather than trying to preserve signaling-ness cross-platform, this\n    /// implementation favours preserving the exact bits. This means that\n    /// any payloads encoded in NaNs will be preserved even if the result of\n    /// this method is sent over the network from an x86 machine to a MIPS one.\n    ///\n    /// If the results of this method are only manipulated by the same\n    /// architecture that produced them, then there is no portability concern.\n    ///\n    /// If the input isn't NaN, then there is no portability concern.\n    ///\n    /// If you don't care about signalingness (very likely), then there is no\n    /// portability concern.\n    ///\n    /// Note that this function is distinct from `as` casting, which attempts to\n    /// preserve the *numeric* value, and not the bitwise value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::f32;\n    /// let v = f32::from_bits(0x41480000);\n    /// let difference = (v - 12.5).abs();\n    /// assert!(difference <= 1e-5);\n    /// ```\n    #[stable(feature = \"float_bits_conv\", since = \"1.20.0\")]\n    #[inline]\n    pub fn from_bits(v: u32) -> Self {\n        // It turns out the safety issues with sNaN were overblown! Hooray!\n        unsafe { mem::transmute(v) }\n    }\n}\n","// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! This module provides constants which are specific to the implementation\n//! of the `f64` floating point data type.\n//!\n//! *[See also the `f64` primitive type](../../std/primitive.f64.html).*\n//!\n//! Mathematically significant numbers are provided in the `consts` sub-module.\n\n#![stable(feature = \"rust1\", since = \"1.0.0\")]\n\nuse mem;\nuse num::FpCategory;\n\n/// The radix or base of the internal representation of `f64`.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const RADIX: u32 = 2;\n\n/// Number of significant digits in base 2.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MANTISSA_DIGITS: u32 = 53;\n/// Approximate number of significant digits in base 10.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const DIGITS: u32 = 15;\n\n/// [Machine epsilon] value for `f64`.\n///\n/// This is the difference between `1.0` and the next largest representable number.\n///\n/// [Machine epsilon]: https://en.wikipedia.org/wiki/Machine_epsilon\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const EPSILON: f64 = 2.2204460492503131e-16_f64;\n\n/// Smallest finite `f64` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN: f64 = -1.7976931348623157e+308_f64;\n/// Smallest positive normal `f64` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64;\n/// Largest finite `f64` value.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX: f64 = 1.7976931348623157e+308_f64;\n\n/// One greater than the minimum possible normal power of 2 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_EXP: i32 = -1021;\n/// Maximum possible power of 2 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX_EXP: i32 = 1024;\n\n/// Minimum possible normal power of 10 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MIN_10_EXP: i32 = -307;\n/// Maximum possible power of 10 exponent.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const MAX_10_EXP: i32 = 308;\n\n/// Not a Number (NaN).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const NAN: f64 = 0.0_f64 / 0.0_f64;\n/// Infinity (\u221e).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const INFINITY: f64 = 1.0_f64 / 0.0_f64;\n/// Negative infinity (-\u221e).\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub const NEG_INFINITY: f64 = -1.0_f64 / 0.0_f64;\n\n/// Basic mathematical constants.\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub mod consts {\n    // FIXME: replace with mathematical constants from cmath.\n\n    /// Archimedes' constant (\u03c0)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const PI: f64 = 3.14159265358979323846264338327950288_f64;\n\n    /// \u03c0/2\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_2: f64 = 1.57079632679489661923132169163975144_f64;\n\n    /// \u03c0/3\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_3: f64 = 1.04719755119659774615421446109316763_f64;\n\n    /// \u03c0/4\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_4: f64 = 0.785398163397448309615660845819875721_f64;\n\n    /// \u03c0/6\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_6: f64 = 0.52359877559829887307710723054658381_f64;\n\n    /// \u03c0/8\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_PI_8: f64 = 0.39269908169872415480783042290993786_f64;\n\n    /// 1/\u03c0\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_1_PI: f64 = 0.318309886183790671537767526745028724_f64;\n\n    /// 2/\u03c0\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_2_PI: f64 = 0.636619772367581343075535053490057448_f64;\n\n    /// 2/sqrt(\u03c0)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_2_SQRT_PI: f64 = 1.12837916709551257389615890312154517_f64;\n\n    /// sqrt(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const SQRT_2: f64 = 1.41421356237309504880168872420969808_f64;\n\n    /// 1/sqrt(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const FRAC_1_SQRT_2: f64 = 0.707106781186547524400844362104849039_f64;\n\n    /// Euler's number (e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const E: f64 = 2.71828182845904523536028747135266250_f64;\n\n    /// log<sub>2</sub>(10)\n    #[unstable(feature = \"extra_log_consts\", issue = \"50540\")]\n    pub const LOG2_10: f64 = 3.32192809488736234787031942948939018_f64;\n\n    /// log<sub>2</sub>(e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LOG2_E: f64 = 1.44269504088896340735992468100189214_f64;\n\n    /// log<sub>10</sub>(2)\n    #[unstable(feature = \"extra_log_consts\", issue = \"50540\")]\n    pub const LOG10_2: f64 = 0.301029995663981195213738894724493027_f64;\n\n    /// log<sub>10</sub>(e)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LOG10_E: f64 = 0.434294481903251827651128918916605082_f64;\n\n    /// ln(2)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LN_2: f64 = 0.693147180559945309417232121458176568_f64;\n\n    /// ln(10)\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;\n}\n\n#[lang = \"f64\"]\n#[cfg(not(test))]\nimpl f64 {\n    /// Returns `true` if this value is `NaN` and false otherwise.\n    ///\n    /// ```\n    /// use std::f64;\n    ///\n    /// let nan = f64::NAN;\n    /// let f = 7.0_f64;\n    ///\n    /// assert!(nan.is_nan());\n    /// assert!(!f.is_nan());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_nan(self) -> bool {\n        self != self\n    }\n\n    /// Returns `true` if this value is positive infinity or negative infinity and\n    /// false otherwise.\n    ///\n    /// ```\n    /// use std::f64;\n    ///\n    /// let f = 7.0f64;\n    /// let inf = f64::INFINITY;\n    /// let neg_inf = f64::NEG_INFINITY;\n    /// let nan = f64::NAN;\n    ///\n    /// assert!(!f.is_infinite());\n    /// assert!(!nan.is_infinite());\n    ///\n    /// assert!(inf.is_infinite());\n    /// assert!(neg_inf.is_infinite());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_infinite(self) -> bool {\n        self == INFINITY || self == NEG_INFINITY\n    }\n\n    /// Returns `true` if this number is neither infinite nor `NaN`.\n    ///\n    /// ```\n    /// use std::f64;\n    ///\n    /// let f = 7.0f64;\n    /// let inf: f64 = f64::INFINITY;\n    /// let neg_inf: f64 = f64::NEG_INFINITY;\n    /// let nan: f64 = f64::NAN;\n    ///\n    /// assert!(f.is_finite());\n    ///\n    /// assert!(!nan.is_finite());\n    /// assert!(!inf.is_finite());\n    /// assert!(!neg_inf.is_finite());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_finite(self) -> bool {\n        !(self.is_nan() || self.is_infinite())\n    }\n\n    /// Returns `true` if the number is neither zero, infinite,\n    /// [subnormal][subnormal], or `NaN`.\n    ///\n    /// ```\n    /// use std::f64;\n    ///\n    /// let min = f64::MIN_POSITIVE; // 2.2250738585072014e-308f64\n    /// let max = f64::MAX;\n    /// let lower_than_min = 1.0e-308_f64;\n    /// let zero = 0.0f64;\n    ///\n    /// assert!(min.is_normal());\n    /// assert!(max.is_normal());\n    ///\n    /// assert!(!zero.is_normal());\n    /// assert!(!f64::NAN.is_normal());\n    /// assert!(!f64::INFINITY.is_normal());\n    /// // Values between `0` and `min` are Subnormal.\n    /// assert!(!lower_than_min.is_normal());\n    /// ```\n    /// [subnormal]: https://en.wikipedia.org/wiki/Denormal_number\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_normal(self) -> bool {\n        self.classify() == FpCategory::Normal\n    }\n\n    /// Returns the floating point category of the number. If only one property\n    /// is going to be tested, it is generally faster to use the specific\n    /// predicate instead.\n    ///\n    /// ```\n    /// use std::num::FpCategory;\n    /// use std::f64;\n    ///\n    /// let num = 12.4_f64;\n    /// let inf = f64::INFINITY;\n    ///\n    /// assert_eq!(num.classify(), FpCategory::Normal);\n    /// assert_eq!(inf.classify(), FpCategory::Infinite);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    pub fn classify(self) -> FpCategory {\n        const EXP_MASK: u64 = 0x7ff0000000000000;\n        const MAN_MASK: u64 = 0x000fffffffffffff;\n\n        let bits = self.to_bits();\n        match (bits & MAN_MASK, bits & EXP_MASK) {\n            (0, 0) => FpCategory::Zero,\n            (_, 0) => FpCategory::Subnormal,\n            (0, EXP_MASK) => FpCategory::Infinite,\n            (_, EXP_MASK) => FpCategory::Nan,\n            _ => FpCategory::Normal,\n        }\n    }\n\n    /// Returns `true` if and only if `self` has a positive sign, including `+0.0`, `NaN`s with\n    /// positive sign bit and positive infinity.\n    ///\n    /// ```\n    /// let f = 7.0_f64;\n    /// let g = -7.0_f64;\n    ///\n    /// assert!(f.is_sign_positive());\n    /// assert!(!g.is_sign_positive());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_sign_positive(self) -> bool {\n        !self.is_sign_negative()\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.0.0\", reason = \"renamed to is_sign_positive\")]\n    #[inline]\n    #[doc(hidden)]\n    pub fn is_positive(self) -> bool {\n        self.is_sign_positive()\n    }\n\n    /// Returns `true` if and only if `self` has a negative sign, including `-0.0`, `NaN`s with\n    /// negative sign bit and negative infinity.\n    ///\n    /// ```\n    /// let f = 7.0_f64;\n    /// let g = -7.0_f64;\n    ///\n    /// assert!(!f.is_sign_negative());\n    /// assert!(g.is_sign_negative());\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn is_sign_negative(self) -> bool {\n        self.to_bits() & 0x8000_0000_0000_0000 != 0\n    }\n\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[rustc_deprecated(since = \"1.0.0\", reason = \"renamed to is_sign_negative\")]\n    #[inline]\n    #[doc(hidden)]\n    pub fn is_negative(self) -> bool {\n        self.is_sign_negative()\n    }\n\n    /// Takes the reciprocal (inverse) of a number, `1/x`.\n    ///\n    /// ```\n    /// let x = 2.0_f64;\n    /// let abs_difference = (x.recip() - (1.0/x)).abs();\n    ///\n    /// assert!(abs_difference < 1e-10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn recip(self) -> f64 {\n        1.0 / self\n    }\n\n    /// Converts radians to degrees.\n    ///\n    /// ```\n    /// use std::f64::consts;\n    ///\n    /// let angle = consts::PI;\n    ///\n    /// let abs_difference = (angle.to_degrees() - 180.0).abs();\n    ///\n    /// assert!(abs_difference < 1e-10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_degrees(self) -> f64 {\n        // The division here is correctly rounded with respect to the true\n        // value of 180/\u03c0. (This differs from f32, where a constant must be\n        // used to ensure a correctly rounded result.)\n        self * (180.0f64 / consts::PI)\n    }\n\n    /// Converts degrees to radians.\n    ///\n    /// ```\n    /// use std::f64::consts;\n    ///\n    /// let angle = 180.0_f64;\n    ///\n    /// let abs_difference = (angle.to_radians() - consts::PI).abs();\n    ///\n    /// assert!(abs_difference < 1e-10);\n    /// ```\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn to_radians(self) -> f64 {\n        let value: f64 = consts::PI;\n        self * (value / 180.0)\n    }\n\n    /// Returns the maximum of the two numbers.\n    ///\n    /// ```\n    /// let x = 1.0_f64;\n    /// let y = 2.0_f64;\n    ///\n    /// assert_eq!(x.max(y), y);\n    /// ```\n    ///\n    /// If one of the arguments is NaN, then the other argument is returned.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn max(self, other: f64) -> f64 {\n        // IEEE754 says: maxNum(x, y) is the canonicalized number y if x < y, x if y < x, the\n        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it\n        // is either x or y, canonicalized (this means results might differ among implementations).\n        // When either x or y is a signalingNaN, then the result is according to 6.2.\n        //\n        // Since we do not support sNaN in Rust yet, we do not need to handle them.\n        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by\n        // multiplying by 1.0. Should switch to the `canonicalize` when it works.\n        (if self.is_nan() || self < other { other } else { self }) * 1.0\n    }\n\n    /// Returns the minimum of the two numbers.\n    ///\n    /// ```\n    /// let x = 1.0_f64;\n    /// let y = 2.0_f64;\n    ///\n    /// assert_eq!(x.min(y), x);\n    /// ```\n    ///\n    /// If one of the arguments is NaN, then the other argument is returned.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    #[inline]\n    pub fn min(self, other: f64) -> f64 {\n        // IEEE754 says: minNum(x, y) is the canonicalized number x if x < y, y if y < x, the\n        // canonicalized number if one operand is a number and the other a quiet NaN. Otherwise it\n        // is either x or y, canonicalized (this means results might differ among implementations).\n        // When either x or y is a signalingNaN, then the result is according to 6.2.\n        //\n        // Since we do not support sNaN in Rust yet, we do not need to handle them.\n        // FIXME(nagisa): due to https://bugs.llvm.org/show_bug.cgi?id=33303 we canonicalize by\n        // multiplying by 1.0. Should switch to the `canonicalize` when it works.\n        (if other.is_nan() || self < other { self } else { other }) * 1.0\n    }\n\n    /// Raw transmutation to `u64`.\n    ///\n    /// This is currently identical to `transmute::<f64, u64>(self)` on all platforms.\n    ///\n    /// See `from_bits` for some discussion of the portability of this operation\n    /// (there are almost no issues).\n    ///\n    /// Note that this function is distinct from `as` casting, which attempts to\n    /// preserve the *numeric* value, and not the bitwise value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// assert!((1f64).to_bits() != 1f64 as u64); // to_bits() is not casting!\n    /// assert_eq!((12.5f64).to_bits(), 0x4029000000000000);\n    ///\n    /// ```\n    #[stable(feature = \"float_bits_conv\", since = \"1.20.0\")]\n    #[inline]\n    pub fn to_bits(self) -> u64 {\n        unsafe { mem::transmute(self) }\n    }\n\n    /// Raw transmutation from `u64`.\n    ///\n    /// This is currently identical to `transmute::<u64, f64>(v)` on all platforms.\n    /// It turns out this is incredibly portable, for two reasons:\n    ///\n    /// * Floats and Ints have the same endianness on all supported platforms.\n    /// * IEEE-754 very precisely specifies the bit layout of floats.\n    ///\n    /// However there is one caveat: prior to the 2008 version of IEEE-754, how\n    /// to interpret the NaN signaling bit wasn't actually specified. Most platforms\n    /// (notably x86 and ARM) picked the interpretation that was ultimately\n    /// standardized in 2008, but some didn't (notably MIPS). As a result, all\n    /// signaling NaNs on MIPS are quiet NaNs on x86, and vice-versa.\n    ///\n    /// Rather than trying to preserve signaling-ness cross-platform, this\n    /// implementation favours preserving the exact bits. This means that\n    /// any payloads encoded in NaNs will be preserved even if the result of\n    /// this method is sent over the network from an x86 machine to a MIPS one.\n    ///\n    /// If the results of this method are only manipulated by the same\n    /// architecture that produced them, then there is no portability concern.\n    ///\n    /// If the input isn't NaN, then there is no portability concern.\n    ///\n    /// If you don't care about signalingness (very likely), then there is no\n    /// portability concern.\n    ///\n    /// Note that this function is distinct from `as` casting, which attempts to\n    /// preserve the *numeric* value, and not the bitwise value.\n    ///\n    /// # Examples\n    ///\n    /// ```\n    /// use std::f64;\n    /// let v = f64::from_bits(0x4029000000000000);\n    /// let difference = (v - 12.5).abs();\n    /// assert!(difference <= 1e-5);\n    /// ```\n    #[stable(feature = \"float_bits_conv\", since = \"1.20.0\")]\n    #[inline]\n    pub fn from_bits(v: u64) -> Self {\n        // It turns out the safety issues with sNaN were overblown! Hooray!\n        unsafe { mem::transmute(v) }\n    }\n}\n","// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n//! Operations on ASCII strings and characters.\n//!\n//! Most string operations in Rust act on UTF-8 strings. However, at times it\n//! makes more sense to only consider the ASCII character set for a specific\n//! operation.\n//!\n//! The [`escape_default`] function provides an iterator over the bytes of an\n//! escaped version of the character given.\n//!\n//! [`escape_default`]: fn.escape_default.html\n\n#![stable(feature = \"core_ascii\", since = \"1.26.0\")]\n\nuse fmt;\nuse ops::Range;\nuse iter::FusedIterator;\n\n/// An iterator over the escaped version of a byte.\n///\n/// This `struct` is created by the [`escape_default`] function. See its\n/// documentation for more.\n///\n/// [`escape_default`]: fn.escape_default.html\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub struct EscapeDefault {\n    range: Range<usize>,\n    data: [u8; 4],\n}\n\n/// Returns an iterator that produces an escaped version of a `u8`.\n///\n/// The default is chosen with a bias toward producing literals that are\n/// legal in a variety of languages, including C++11 and similar C-family\n/// languages. The exact rules are:\n///\n/// * Tab is escaped as `\\t`.\n/// * Carriage return is escaped as `\\r`.\n/// * Line feed is escaped as `\\n`.\n/// * Single quote is escaped as `\\'`.\n/// * Double quote is escaped as `\\\"`.\n/// * Backslash is escaped as `\\\\`.\n/// * Any character in the 'printable ASCII' range `0x20` .. `0x7e`\n///   inclusive is not escaped.\n/// * Any other chars are given hex escapes of the form '\\xNN'.\n/// * Unicode escapes are never generated by this function.\n///\n/// # Examples\n///\n/// ```\n/// use std::ascii;\n///\n/// let escaped = ascii::escape_default(b'0').next().unwrap();\n/// assert_eq!(b'0', escaped);\n///\n/// let mut escaped = ascii::escape_default(b'\\t');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b't', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\\r');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'r', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\\n');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'n', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\\'');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'\\'', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\"');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'\"', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\\\\');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n///\n/// let mut escaped = ascii::escape_default(b'\\x9d');\n///\n/// assert_eq!(b'\\\\', escaped.next().unwrap());\n/// assert_eq!(b'x', escaped.next().unwrap());\n/// assert_eq!(b'9', escaped.next().unwrap());\n/// assert_eq!(b'd', escaped.next().unwrap());\n/// ```\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub fn escape_default(c: u8) -> EscapeDefault {\n    let (data, len) = match c {\n        b'\\t' => ([b'\\\\', b't', 0, 0], 2),\n        b'\\r' => ([b'\\\\', b'r', 0, 0], 2),\n        b'\\n' => ([b'\\\\', b'n', 0, 0], 2),\n        b'\\\\' => ([b'\\\\', b'\\\\', 0, 0], 2),\n        b'\\'' => ([b'\\\\', b'\\'', 0, 0], 2),\n        b'\"' => ([b'\\\\', b'\"', 0, 0], 2),\n        b'\\x20' ..= b'\\x7e' => ([c, 0, 0, 0], 1),\n        _ => ([b'\\\\', b'x', hexify(c >> 4), hexify(c & 0xf)], 4),\n    };\n\n    return EscapeDefault { range: 0..len, data };\n\n    fn hexify(b: u8) -> u8 {\n        match b {\n            0 ..= 9 => b'0' + b,\n            _ => b'a' + b - 10,\n        }\n    }\n}\n\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl Iterator for EscapeDefault {\n    type Item = u8;\n    fn next(&mut self) -> Option<u8> { self.range.next().map(|i| self.data[i]) }\n    fn size_hint(&self) -> (usize, Option<usize>) { self.range.size_hint() }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl DoubleEndedIterator for EscapeDefault {\n    fn next_back(&mut self) -> Option<u8> {\n        self.range.next_back().map(|i| self.data[i])\n    }\n}\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\nimpl ExactSizeIterator for EscapeDefault {}\n#[stable(feature = \"fused\", since = \"1.26.0\")]\nimpl FusedIterator for EscapeDefault {}\n\n#[stable(feature = \"std_debug\", since = \"1.16.0\")]\nimpl fmt::Debug for EscapeDefault {\n    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {\n        f.pad(\"EscapeDefault { .. }\")\n    }\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/s_exp2.c */\n//-\n// Copyright (c) 2005 David Schultz <das@FreeBSD.ORG>\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions\n// are met:\n// 1. Redistributions of source code must retain the above copyright\n//    notice, this list of conditions and the following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright\n//    notice, this list of conditions and the following disclaimer in the\n//    documentation and/or other materials provided with the distribution.\n//\n// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\n// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n// SUCH DAMAGE.\n\nuse super::scalbn;\n\nconst TBLSIZE: usize = 256;\n\n#[cfg_attr(rustfmt, rustfmt_skip)]\nstatic TBL: [u64; TBLSIZE * 2] = [\n    //  exp2(z + eps)          eps\n    0x3fe6a09e667f3d5d, 0x3d39880000000000,\n    0x3fe6b052fa751744, 0x3cd8000000000000,\n    0x3fe6c012750bd9fe, 0xbd28780000000000,\n    0x3fe6cfdcddd476bf, 0x3d1ec00000000000,\n    0x3fe6dfb23c651a29, 0xbcd8000000000000,\n    0x3fe6ef9298593ae3, 0xbcbc000000000000,\n    0x3fe6ff7df9519386, 0xbd2fd80000000000,\n    0x3fe70f7466f42da3, 0xbd2c880000000000,\n    0x3fe71f75e8ec5fc3, 0x3d13c00000000000,\n    0x3fe72f8286eacf05, 0xbd38300000000000,\n    0x3fe73f9a48a58152, 0xbd00c00000000000,\n    0x3fe74fbd35d7ccfc, 0x3d2f880000000000,\n    0x3fe75feb564267f1, 0x3d03e00000000000,\n    0x3fe77024b1ab6d48, 0xbd27d00000000000,\n    0x3fe780694fde5d38, 0xbcdd000000000000,\n    0x3fe790b938ac1d00, 0x3ce3000000000000,\n    0x3fe7a11473eb0178, 0xbced000000000000,\n    0x3fe7b17b0976d060, 0x3d20400000000000,\n    0x3fe7c1ed0130c133, 0x3ca0000000000000,\n    0x3fe7d26a62ff8636, 0xbd26900000000000,\n    0x3fe7e2f336cf4e3b, 0xbd02e00000000000,\n    0x3fe7f3878491c3e8, 0xbd24580000000000,\n    0x3fe80427543e1b4e, 0x3d33000000000000,\n    0x3fe814d2add1071a, 0x3d0f000000000000,\n    0x3fe82589994ccd7e, 0xbd21c00000000000,\n    0x3fe8364c1eb942d0, 0x3d29d00000000000,\n    0x3fe8471a4623cab5, 0x3d47100000000000,\n    0x3fe857f4179f5bbc, 0x3d22600000000000,\n    0x3fe868d99b4491af, 0xbd32c40000000000,\n    0x3fe879cad931a395, 0xbd23000000000000,\n    0x3fe88ac7d98a65b8, 0xbd2a800000000000,\n    0x3fe89bd0a4785800, 0xbced000000000000,\n    0x3fe8ace5422aa223, 0x3d33280000000000,\n    0x3fe8be05bad619fa, 0x3d42b40000000000,\n    0x3fe8cf3216b54383, 0xbd2ed00000000000,\n    0x3fe8e06a5e08664c, 0xbd20500000000000,\n    0x3fe8f1ae99157807, 0x3d28280000000000,\n    0x3fe902fed0282c0e, 0xbd1cb00000000000,\n    0x3fe9145b0b91ff96, 0xbd05e00000000000,\n    0x3fe925c353aa2ff9, 0x3cf5400000000000,\n    0x3fe93737b0cdc64a, 0x3d17200000000000,\n    0x3fe948b82b5f98ae, 0xbd09000000000000,\n    0x3fe95a44cbc852cb, 0x3d25680000000000,\n    0x3fe96bdd9a766f21, 0xbd36d00000000000,\n    0x3fe97d829fde4e2a, 0xbd01000000000000,\n    0x3fe98f33e47a23a3, 0x3d2d000000000000,\n    0x3fe9a0f170ca0604, 0xbd38a40000000000,\n    0x3fe9b2bb4d53ff89, 0x3d355c0000000000,\n    0x3fe9c49182a3f15b, 0x3d26b80000000000,\n    0x3fe9d674194bb8c5, 0xbcec000000000000,\n    0x3fe9e86319e3238e, 0x3d17d00000000000,\n    0x3fe9fa5e8d07f302, 0x3d16400000000000,\n    0x3fea0c667b5de54d, 0xbcf5000000000000,\n    0x3fea1e7aed8eb8f6, 0x3d09e00000000000,\n    0x3fea309bec4a2e27, 0x3d2ad80000000000,\n    0x3fea42c980460a5d, 0xbd1af00000000000,\n    0x3fea5503b23e259b, 0x3d0b600000000000,\n    0x3fea674a8af46213, 0x3d38880000000000,\n    0x3fea799e1330b3a7, 0x3d11200000000000,\n    0x3fea8bfe53c12e8d, 0x3d06c00000000000,\n    0x3fea9e6b5579fcd2, 0xbd29b80000000000,\n    0x3feab0e521356fb8, 0x3d2b700000000000,\n    0x3feac36bbfd3f381, 0x3cd9000000000000,\n    0x3fead5ff3a3c2780, 0x3ce4000000000000,\n    0x3feae89f995ad2a3, 0xbd2c900000000000,\n    0x3feafb4ce622f367, 0x3d16500000000000,\n    0x3feb0e07298db790, 0x3d2fd40000000000,\n    0x3feb20ce6c9a89a9, 0x3d12700000000000,\n    0x3feb33a2b84f1a4b, 0x3d4d470000000000,\n    0x3feb468415b747e7, 0xbd38380000000000,\n    0x3feb59728de5593a, 0x3c98000000000000,\n    0x3feb6c6e29f1c56a, 0x3d0ad00000000000,\n    0x3feb7f76f2fb5e50, 0x3cde800000000000,\n    0x3feb928cf22749b2, 0xbd04c00000000000,\n    0x3feba5b030a10603, 0xbd0d700000000000,\n    0x3febb8e0b79a6f66, 0x3d0d900000000000,\n    0x3febcc1e904bc1ff, 0x3d02a00000000000,\n    0x3febdf69c3f3a16f, 0xbd1f780000000000,\n    0x3febf2c25bd71db8, 0xbd10a00000000000,\n    0x3fec06286141b2e9, 0xbd11400000000000,\n    0x3fec199bdd8552e0, 0x3d0be00000000000,\n    0x3fec2d1cd9fa64ee, 0xbd09400000000000,\n    0x3fec40ab5fffd02f, 0xbd0ed00000000000,\n    0x3fec544778fafd15, 0x3d39660000000000,\n    0x3fec67f12e57d0cb, 0xbd1a100000000000,\n    0x3fec7ba88988c1b6, 0xbd58458000000000,\n    0x3fec8f6d9406e733, 0xbd1a480000000000,\n    0x3feca3405751c4df, 0x3ccb000000000000,\n    0x3fecb720dcef9094, 0x3d01400000000000,\n    0x3feccb0f2e6d1689, 0x3cf0200000000000,\n    0x3fecdf0b555dc412, 0x3cf3600000000000,\n    0x3fecf3155b5bab3b, 0xbd06900000000000,\n    0x3fed072d4a0789bc, 0x3d09a00000000000,\n    0x3fed1b532b08c8fa, 0xbd15e00000000000,\n    0x3fed2f87080d8a85, 0x3d1d280000000000,\n    0x3fed43c8eacaa203, 0x3d01a00000000000,\n    0x3fed5818dcfba491, 0x3cdf000000000000,\n    0x3fed6c76e862e6a1, 0xbd03a00000000000,\n    0x3fed80e316c9834e, 0xbd0cd80000000000,\n    0x3fed955d71ff6090, 0x3cf4c00000000000,\n    0x3feda9e603db32ae, 0x3cff900000000000,\n    0x3fedbe7cd63a8325, 0x3ce9800000000000,\n    0x3fedd321f301b445, 0xbcf5200000000000,\n    0x3fede7d5641c05bf, 0xbd1d700000000000,\n    0x3fedfc97337b9aec, 0xbd16140000000000,\n    0x3fee11676b197d5e, 0x3d0b480000000000,\n    0x3fee264614f5a3e7, 0x3d40ce0000000000,\n    0x3fee3b333b16ee5c, 0x3d0c680000000000,\n    0x3fee502ee78b3fb4, 0xbd09300000000000,\n    0x3fee653924676d68, 0xbce5000000000000,\n    0x3fee7a51fbc74c44, 0xbd07f80000000000,\n    0x3fee8f7977cdb726, 0xbcf3700000000000,\n    0x3feea4afa2a490e8, 0x3ce5d00000000000,\n    0x3feeb9f4867ccae4, 0x3d161a0000000000,\n    0x3feecf482d8e680d, 0x3cf5500000000000,\n    0x3feee4aaa2188514, 0x3cc6400000000000,\n    0x3feefa1bee615a13, 0xbcee800000000000,\n    0x3fef0f9c1cb64106, 0xbcfa880000000000,\n    0x3fef252b376bb963, 0xbd2c900000000000,\n    0x3fef3ac948dd7275, 0x3caa000000000000,\n    0x3fef50765b6e4524, 0xbcf4f00000000000,\n    0x3fef6632798844fd, 0x3cca800000000000,\n    0x3fef7bfdad9cbe38, 0x3cfabc0000000000,\n    0x3fef91d802243c82, 0xbcd4600000000000,\n    0x3fefa7c1819e908e, 0xbd0b0c0000000000,\n    0x3fefbdba3692d511, 0xbcc0e00000000000,\n    0x3fefd3c22b8f7194, 0xbd10de8000000000,\n    0x3fefe9d96b2a23ee, 0x3cee430000000000,\n    0x3ff0000000000000, 0x0,\n    0x3ff00b1afa5abcbe, 0xbcb3400000000000,\n    0x3ff0163da9fb3303, 0xbd12170000000000,\n    0x3ff02168143b0282, 0x3cba400000000000,\n    0x3ff02c9a3e77806c, 0x3cef980000000000,\n    0x3ff037d42e11bbca, 0xbcc7400000000000,\n    0x3ff04315e86e7f89, 0x3cd8300000000000,\n    0x3ff04e5f72f65467, 0xbd1a3f0000000000,\n    0x3ff059b0d315855a, 0xbd02840000000000,\n    0x3ff0650a0e3c1f95, 0x3cf1600000000000,\n    0x3ff0706b29ddf71a, 0x3d15240000000000,\n    0x3ff07bd42b72a82d, 0xbce9a00000000000,\n    0x3ff0874518759bd0, 0x3ce6400000000000,\n    0x3ff092bdf66607c8, 0xbd00780000000000,\n    0x3ff09e3ecac6f383, 0xbc98000000000000,\n    0x3ff0a9c79b1f3930, 0x3cffa00000000000,\n    0x3ff0b5586cf988fc, 0xbcfac80000000000,\n    0x3ff0c0f145e46c8a, 0x3cd9c00000000000,\n    0x3ff0cc922b724816, 0x3d05200000000000,\n    0x3ff0d83b23395dd8, 0xbcfad00000000000,\n    0x3ff0e3ec32d3d1f3, 0x3d1bac0000000000,\n    0x3ff0efa55fdfa9a6, 0xbd04e80000000000,\n    0x3ff0fb66affed2f0, 0xbd0d300000000000,\n    0x3ff1073028d7234b, 0x3cf1500000000000,\n    0x3ff11301d0125b5b, 0x3cec000000000000,\n    0x3ff11edbab5e2af9, 0x3d16bc0000000000,\n    0x3ff12abdc06c31d5, 0x3ce8400000000000,\n    0x3ff136a814f2047d, 0xbd0ed00000000000,\n    0x3ff1429aaea92de9, 0x3ce8e00000000000,\n    0x3ff14e95934f3138, 0x3ceb400000000000,\n    0x3ff15a98c8a58e71, 0x3d05300000000000,\n    0x3ff166a45471c3df, 0x3d03380000000000,\n    0x3ff172b83c7d5211, 0x3d28d40000000000,\n    0x3ff17ed48695bb9f, 0xbd05d00000000000,\n    0x3ff18af9388c8d93, 0xbd1c880000000000,\n    0x3ff1972658375d66, 0x3d11f00000000000,\n    0x3ff1a35beb6fcba7, 0x3d10480000000000,\n    0x3ff1af99f81387e3, 0xbd47390000000000,\n    0x3ff1bbe084045d54, 0x3d24e40000000000,\n    0x3ff1c82f95281c43, 0xbd0a200000000000,\n    0x3ff1d4873168b9b2, 0x3ce3800000000000,\n    0x3ff1e0e75eb44031, 0x3ceac00000000000,\n    0x3ff1ed5022fcd938, 0x3d01900000000000,\n    0x3ff1f9c18438cdf7, 0xbd1b780000000000,\n    0x3ff2063b88628d8f, 0x3d2d940000000000,\n    0x3ff212be3578a81e, 0x3cd8000000000000,\n    0x3ff21f49917ddd41, 0x3d2b340000000000,\n    0x3ff22bdda2791323, 0x3d19f80000000000,\n    0x3ff2387a6e7561e7, 0xbd19c80000000000,\n    0x3ff2451ffb821427, 0x3d02300000000000,\n    0x3ff251ce4fb2a602, 0xbd13480000000000,\n    0x3ff25e85711eceb0, 0x3d12700000000000,\n    0x3ff26b4565e27d16, 0x3d11d00000000000,\n    0x3ff2780e341de00f, 0x3d31ee0000000000,\n    0x3ff284dfe1f5633e, 0xbd14c00000000000,\n    0x3ff291ba7591bb30, 0xbd13d80000000000,\n    0x3ff29e9df51fdf09, 0x3d08b00000000000,\n    0x3ff2ab8a66d10e9b, 0xbd227c0000000000,\n    0x3ff2b87fd0dada3a, 0x3d2a340000000000,\n    0x3ff2c57e39771af9, 0xbd10800000000000,\n    0x3ff2d285a6e402d9, 0xbd0ed00000000000,\n    0x3ff2df961f641579, 0xbcf4200000000000,\n    0x3ff2ecafa93e2ecf, 0xbd24980000000000,\n    0x3ff2f9d24abd8822, 0xbd16300000000000,\n    0x3ff306fe0a31b625, 0xbd32360000000000,\n    0x3ff31432edeea50b, 0xbd70df8000000000,\n    0x3ff32170fc4cd7b8, 0xbd22480000000000,\n    0x3ff32eb83ba8e9a2, 0xbd25980000000000,\n    0x3ff33c08b2641766, 0x3d1ed00000000000,\n    0x3ff3496266e3fa27, 0xbcdc000000000000,\n    0x3ff356c55f929f0f, 0xbd30d80000000000,\n    0x3ff36431a2de88b9, 0x3d22c80000000000,\n    0x3ff371a7373aaa39, 0x3d20600000000000,\n    0x3ff37f26231e74fe, 0xbd16600000000000,\n    0x3ff38cae6d05d838, 0xbd0ae00000000000,\n    0x3ff39a401b713ec3, 0xbd44720000000000,\n    0x3ff3a7db34e5a020, 0x3d08200000000000,\n    0x3ff3b57fbfec6e95, 0x3d3e800000000000,\n    0x3ff3c32dc313a8f2, 0x3cef800000000000,\n    0x3ff3d0e544ede122, 0xbd17a00000000000,\n    0x3ff3dea64c1234bb, 0x3d26300000000000,\n    0x3ff3ec70df1c4ecc, 0xbd48a60000000000,\n    0x3ff3fa4504ac7e8c, 0xbd3cdc0000000000,\n    0x3ff40822c367a0bb, 0x3d25b80000000000,\n    0x3ff4160a21f72e95, 0x3d1ec00000000000,\n    0x3ff423fb27094646, 0xbd13600000000000,\n    0x3ff431f5d950a920, 0x3d23980000000000,\n    0x3ff43ffa3f84b9eb, 0x3cfa000000000000,\n    0x3ff44e0860618919, 0xbcf6c00000000000,\n    0x3ff45c2042a7d201, 0xbd0bc00000000000,\n    0x3ff46a41ed1d0016, 0xbd12800000000000,\n    0x3ff4786d668b3326, 0x3d30e00000000000,\n    0x3ff486a2b5c13c00, 0xbd2d400000000000,\n    0x3ff494e1e192af04, 0x3d0c200000000000,\n    0x3ff4a32af0d7d372, 0xbd1e500000000000,\n    0x3ff4b17dea6db801, 0x3d07800000000000,\n    0x3ff4bfdad53629e1, 0xbd13800000000000,\n    0x3ff4ce41b817c132, 0x3d00800000000000,\n    0x3ff4dcb299fddddb, 0x3d2c700000000000,\n    0x3ff4eb2d81d8ab96, 0xbd1ce00000000000,\n    0x3ff4f9b2769d2d02, 0x3d19200000000000,\n    0x3ff508417f4531c1, 0xbd08c00000000000,\n    0x3ff516daa2cf662a, 0xbcfa000000000000,\n    0x3ff5257de83f51ea, 0x3d4a080000000000,\n    0x3ff5342b569d4eda, 0xbd26d80000000000,\n    0x3ff542e2f4f6ac1a, 0xbd32440000000000,\n    0x3ff551a4ca5d94db, 0x3d483c0000000000,\n    0x3ff56070dde9116b, 0x3d24b00000000000,\n    0x3ff56f4736b529de, 0x3d415a0000000000,\n    0x3ff57e27dbe2c40e, 0xbd29e00000000000,\n    0x3ff58d12d497c76f, 0xbd23080000000000,\n    0x3ff59c0827ff0b4c, 0x3d4dec0000000000,\n    0x3ff5ab07dd485427, 0xbcc4000000000000,\n    0x3ff5ba11fba87af4, 0x3d30080000000000,\n    0x3ff5c9268a59460b, 0xbd26c80000000000,\n    0x3ff5d84590998e3f, 0x3d469a0000000000,\n    0x3ff5e76f15ad20e1, 0xbd1b400000000000,\n    0x3ff5f6a320dcebca, 0x3d17700000000000,\n    0x3ff605e1b976dcb8, 0x3d26f80000000000,\n    0x3ff6152ae6cdf715, 0x3d01000000000000,\n    0x3ff6247eb03a5531, 0xbd15d00000000000,\n    0x3ff633dd1d1929b5, 0xbd12d00000000000,\n    0x3ff6434634ccc313, 0xbcea800000000000,\n    0x3ff652b9febc8efa, 0xbd28600000000000,\n    0x3ff6623882553397, 0x3d71fe0000000000,\n    0x3ff671c1c708328e, 0xbd37200000000000,\n    0x3ff68155d44ca97e, 0x3ce6800000000000,\n    0x3ff690f4b19e9471, 0xbd29780000000000,\n];\n\n// exp2(x): compute the base 2 exponential of x\n//\n// Accuracy: Peak error < 0.503 ulp for normalized results.\n//\n// Method: (accurate tables)\n//\n//   Reduce x:\n//     x = k + y, for integer k and |y| <= 1/2.\n//     Thus we have exp2(x) = 2**k * exp2(y).\n//\n//   Reduce y:\n//     y = i/TBLSIZE + z - eps[i] for integer i near y * TBLSIZE.\n//     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z - eps[i]),\n//     with |z - eps[i]| <= 2**-9 + 2**-39 for the table used.\n//\n//   We compute exp2(i/TBLSIZE) via table lookup and exp2(z - eps[i]) via\n//   a degree-5 minimax polynomial with maximum error under 1.3 * 2**-61.\n//   The values in exp2t[] and eps[] are chosen such that\n//   exp2t[i] = exp2(i/TBLSIZE + eps[i]), and eps[i] is a small offset such\n//   that exp2t[i] is accurate to 2**-64.\n//\n//   Note that the range of i is +-TBLSIZE/2, so we actually index the tables\n//   by i0 = i + TBLSIZE/2.  For cache efficiency, exp2t[] and eps[] are\n//   virtual tables, interleaved in the real table tbl[].\n//\n//   This method is due to Gal, with many details due to Gal and Bachelis:\n//\n//      Gal, S. and Bachelis, B.  An Accurate Elementary Mathematical Library\n//      for the IEEE Floating Point Standard.  TOMS 17(1), 26-46 (1991).\n#[inline]\npub fn exp2(mut x: f64) -> f64 {\n    let redux = f64::from_bits(0x4338000000000000) / TBLSIZE as f64;\n    let p1 = f64::from_bits(0x3fe62e42fefa39ef);\n    let p2 = f64::from_bits(0x3fcebfbdff82c575);\n    let p3 = f64::from_bits(0x3fac6b08d704a0a6);\n    let p4 = f64::from_bits(0x3f83b2ab88f70400);\n    let p5 = f64::from_bits(0x3f55d88003875c74);\n\n    // double_t r, t, z;\n    // uint32_t ix, i0;\n    // union {double f; uint64_t i;} u = {x};\n    // union {uint32_t u; int32_t i;} k;\n    let x1p1023 = f64::from_bits(0x7fe0000000000000);\n    let x1p52 = f64::from_bits(0x4330000000000000);\n    let _0x1p_149 = f64::from_bits(0xb6a0000000000000);\n\n    /* Filter out exceptional cases. */\n    let ui = f64::to_bits(x);\n    let ix = ui >> 32 & 0x7fffffff;\n    if ix >= 0x408ff000 {\n        /* |x| >= 1022 or nan */\n        if ix >= 0x40900000 && ui >> 63 == 0 {\n            /* x >= 1024 or nan */\n            /* overflow */\n            x *= x1p1023;\n            return x;\n        }\n        if ix >= 0x7ff00000 {\n            /* -inf or -nan */\n            return -1.0 / x;\n        }\n        if ui >> 63 != 0 {\n            /* x <= -1022 */\n            /* underflow */\n            if x <= -1075.0 || x - x1p52 + x1p52 != x {\n                force_eval!((_0x1p_149 / x) as f32);\n            }\n            if x <= -1075.0 {\n                return 0.0;\n            }\n        }\n    } else if ix < 0x3c900000 {\n        /* |x| < 0x1p-54 */\n        return 1.0 + x;\n    }\n\n    /* Reduce x, computing z, i0, and k. */\n    let ui = f64::to_bits(x + redux);\n    let mut i0 = ui as u32;\n    i0 += TBLSIZE as u32 / 2;\n    let ku = i0 / TBLSIZE as u32 * TBLSIZE as u32;\n    let ki = ku as i32 / TBLSIZE as i32;\n    i0 %= TBLSIZE as u32;\n    let uf = f64::from_bits(ui) - redux;\n    let mut z = x - uf;\n\n    /* Compute r = exp2(y) = exp2t[i0] * p(z - eps[i]). */\n    let t = f64::from_bits(TBL[2 * i0 as usize]); /* exp2t[i0] */\n    z -= f64::from_bits(TBL[2 * i0 as usize + 1]); /* eps[i0]   */\n    let r = t + t * z * (p1 + z * (p2 + z * (p3 + z * (p4 + z * p5))));\n\n    scalbn(r, ki)\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/s_exp2f.c\n//-\n// Copyright (c) 2005 David Schultz <das@FreeBSD.ORG>\n// All rights reserved.\n//\n// Redistribution and use in source and binary forms, with or without\n// modification, are permitted provided that the following conditions\n// are met:\n// 1. Redistributions of source code must retain the above copyright\n//    notice, this list of conditions and the following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright\n//    notice, this list of conditions and the following disclaimer in the\n//    documentation and/or other materials provided with the distribution.\n//\n// THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\n// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n// ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n// OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n// SUCH DAMAGE.\n\nconst TBLSIZE: usize = 16;\n\nstatic EXP2FT: [u64; TBLSIZE] = [\n    0x3fe6a09e667f3bcd,\n    0x3fe7a11473eb0187,\n    0x3fe8ace5422aa0db,\n    0x3fe9c49182a3f090,\n    0x3feae89f995ad3ad,\n    0x3fec199bdd85529c,\n    0x3fed5818dcfba487,\n    0x3feea4afa2a490da,\n    0x3ff0000000000000,\n    0x3ff0b5586cf9890f,\n    0x3ff172b83c7d517b,\n    0x3ff2387a6e756238,\n    0x3ff306fe0a31b715,\n    0x3ff3dea64c123422,\n    0x3ff4bfdad5362a27,\n    0x3ff5ab07dd485429,\n];\n\n// exp2f(x): compute the base 2 exponential of x\n//\n// Accuracy: Peak error < 0.501 ulp; location of peak: -0.030110927.\n//\n// Method: (equally-spaced tables)\n//\n//   Reduce x:\n//     x = k + y, for integer k and |y| <= 1/2.\n//     Thus we have exp2f(x) = 2**k * exp2(y).\n//\n//   Reduce y:\n//     y = i/TBLSIZE + z for integer i near y * TBLSIZE.\n//     Thus we have exp2(y) = exp2(i/TBLSIZE) * exp2(z),\n//     with |z| <= 2**-(TBLSIZE+1).\n//\n//   We compute exp2(i/TBLSIZE) via table lookup and exp2(z) via a\n//   degree-4 minimax polynomial with maximum error under 1.4 * 2**-33.\n//   Using double precision for everything except the reduction makes\n//   roundoff error insignificant and simplifies the scaling step.\n//\n//   This method is due to Tang, but I do not use his suggested parameters:\n//\n//      Tang, P.  Table-driven Implementation of the Exponential Function\n//      in IEEE Floating-Point Arithmetic.  TOMS 15(2), 144-157 (1989).\n#[inline]\npub fn exp2f(mut x: f32) -> f32 {\n    let redux = f32::from_bits(0x4b400000) / TBLSIZE as f32;\n    let p1 = f32::from_bits(0x3f317218);\n    let p2 = f32::from_bits(0x3e75fdf0);\n    let p3 = f32::from_bits(0x3d6359a4);\n    let p4 = f32::from_bits(0x3c1d964e);\n\n    // double_t t, r, z;\n    // uint32_t ix, i0, k;\n\n    let x1p127 = f32::from_bits(0x7f000000);\n\n    /* Filter out exceptional cases. */\n    let ui = f32::to_bits(x);\n    let ix = ui & 0x7fffffff;\n    if ix > 0x42fc0000 {\n        /* |x| > 126 */\n        if ix > 0x7f800000 {\n            /* NaN */\n            return x;\n        }\n        if ui >= 0x43000000 && ui < 0x80000000 {\n            /* x >= 128 */\n            x *= x1p127;\n            return x;\n        }\n        if ui >= 0x80000000 {\n            /* x < -126 */\n            if ui >= 0xc3160000 || (ui & 0x0000ffff != 0) {\n                force_eval!(f32::from_bits(0x80000001) / x);\n            }\n            if ui >= 0xc3160000 {\n                /* x <= -150 */\n                return 0.0;\n            }\n        }\n    } else if ix <= 0x33000000 {\n        /* |x| <= 0x1p-25 */\n        return 1.0 + x;\n    }\n\n    /* Reduce x, computing z, i0, and k. */\n    let ui = f32::to_bits(x + redux);\n    let mut i0 = ui;\n    i0 += TBLSIZE as u32 / 2;\n    let k = i0 / TBLSIZE as u32;\n    let ukf = f64::from_bits(((0x3ff + k) as u64) << 52);\n    i0 &= TBLSIZE as u32 - 1;\n    let mut uf = f32::from_bits(ui);\n    uf -= redux;\n    let z: f64 = (x - uf) as f64;\n    /* Compute r = exp2(y) = exp2ft[i0] * p(z). */\n    let r: f64 = f64::from_bits(EXP2FT[i0 as usize]);\n    let t: f64 = r as f64 * z;\n    let r: f64 = r + t * (p1 as f64 + z * p2 as f64) + t * (z * z) * (p3 as f64 + z * p4 as f64);\n\n    /* Scale by 2**k */\n    (r * ukf) as f32\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/k_tan.c */\n//\n// ====================================================\n// Copyright 2004 Sun Microsystems, Inc.  All Rights Reserved.\n//\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\n// kernel tan function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854\n// Input x is assumed to be bounded by ~pi/4 in magnitude.\n// Input y is the tail of x.\n// Input odd indicates whether tan (if odd = 0) or -1/tan (if odd = 1) is returned.\n//\n// Algorithm\n//      1. Since tan(-x) = -tan(x), we need only to consider positive x.\n//      2. Callers must return tan(-0) = -0 without calling here since our\n//         odd polynomial is not evaluated in a way that preserves -0.\n//         Callers may do the optimization tan(x) ~ x for tiny x.\n//      3. tan(x) is approximated by a odd polynomial of degree 27 on\n//         [0,0.67434]\n//                               3             27\n//              tan(x) ~ x + T1*x + ... + T13*x\n//         where\n//\n//              |tan(x)         2     4            26   |     -59.2\n//              |----- - (1+T1*x +T2*x +.... +T13*x    )| <= 2\n//              |  x                                    |\n//\n//         Note: tan(x+y) = tan(x) + tan'(x)*y\n//                        ~ tan(x) + (1+x*x)*y\n//         Therefore, for better accuracy in computing tan(x+y), let\n//                   3      2      2       2       2\n//              r = x *(T2+x *(T3+x *(...+x *(T12+x *T13))))\n//         then\n//                                  3    2\n//              tan(x+y) = x + (T1*x + (x *(r+y)+y))\n//\n//      4. For x in [0.67434,pi/4],  let y = pi/4 - x, then\n//              tan(x) = tan(pi/4-y) = (1-tan(y))/(1+tan(y))\n//                     = 1 - 2*(tan(y) - (tan(y)^2)/(1+tan(y)))\nstatic T: [f64; 13] = [\n    3.33333333333334091986e-01,  /* 3FD55555, 55555563 */\n    1.33333333333201242699e-01,  /* 3FC11111, 1110FE7A */\n    5.39682539762260521377e-02,  /* 3FABA1BA, 1BB341FE */\n    2.18694882948595424599e-02,  /* 3F9664F4, 8406D637 */\n    8.86323982359930005737e-03,  /* 3F8226E3, E96E8493 */\n    3.59207910759131235356e-03,  /* 3F6D6D22, C9560328 */\n    1.45620945432529025516e-03,  /* 3F57DBC8, FEE08315 */\n    5.88041240820264096874e-04,  /* 3F4344D8, F2F26501 */\n    2.46463134818469906812e-04,  /* 3F3026F7, 1A8D1068 */\n    7.81794442939557092300e-05,  /* 3F147E88, A03792A6 */\n    7.14072491382608190305e-05,  /* 3F12B80F, 32F0A7E9 */\n    -1.85586374855275456654e-05, /* BEF375CB, DB605373 */\n    2.59073051863633712884e-05,  /* 3EFB2A70, 74BF7AD4 */\n];\nconst PIO4: f64 = 7.85398163397448278999e-01; /* 3FE921FB, 54442D18 */\nconst PIO4_LO: f64 = 3.06161699786838301793e-17; /* 3C81A626, 33145C07 */\n\n#[inline]\npub fn k_tan(mut x: f64, mut y: f64, odd: i32) -> f64 {\n    let hx = (f64::to_bits(x) >> 32) as u32;\n    let big = (hx & 0x7fffffff) >= 0x3FE59428; /* |x| >= 0.6744 */\n    if big {\n        let sign = hx >> 31;\n        if sign != 0 {\n            x = -x;\n            y = -y;\n        }\n        x = (PIO4 - x) + (PIO4_LO - y);\n        y = 0.0;\n    }\n    let z = x * x;\n    let w = z * z;\n    /*\n     * Break x^5*(T[1]+x^2*T[2]+...) into\n     * x^5(T[1]+x^4*T[3]+...+x^20*T[11]) +\n     * x^5(x^2*(T[2]+x^4*T[4]+...+x^22*[T12]))\n     */\n    let r = T[1] + w * (T[3] + w * (T[5] + w * (T[7] + w * (T[9] + w * T[11]))));\n    let v = z * (T[2] + w * (T[4] + w * (T[6] + w * (T[8] + w * (T[10] + w * T[12])))));\n    let s = z * x;\n    let r = y + z * (s * (r + v) + y) + s * T[0];\n    let w = x + r;\n    if big {\n        let sign = hx >> 31;\n        let s = 1.0 - 2.0 * odd as f64;\n        let v = s - 2.0 * (x + (r - w * w / (w + s)));\n        return if sign != 0 { -v } else { v };\n    }\n    if odd == 0 {\n        return w;\n    }\n    /* -1.0/(x+r) has up to 2ulp error, so compute it accurately */\n    let w0 = zero_low_word(w);\n    let v = r - (w0 - x); /* w0+v = r+x */\n    let a = -1.0 / w;\n    let a0 = zero_low_word(a);\n    a0 + a * (1.0 + a0 * w0 + a0 * v)\n}\n\n#[inline]\nfn zero_low_word(x: f64) -> f64 {\n    f64::from_bits(f64::to_bits(x) & 0xFFFF_FFFF_0000_0000)\n}\n","use core::u64;\n\n#[inline]\npub fn fabs(x: f64) -> f64 {\n    // On wasm32 we know that LLVM's intrinsic will compile to an optimized\n    // `f64.abs` native instruction, so we can leverage this for both code size\n    // and speed.\n    llvm_intrinsically_optimized! {\n        #[cfg(target_arch = \"wasm32\")] {\n            return unsafe { ::core::intrinsics::fabsf64(x) }\n        }\n    }\n    f64::from_bits(x.to_bits() & (u64::MAX / 2))\n}\n","#[inline]\npub fn scalbn(x: f64, mut n: i32) -> f64 {\n    let x1p1023 = f64::from_bits(0x7fe0000000000000); // 0x1p1023 === 2 ^ 1023\n    let x1p53 = f64::from_bits(0x4340000000000000); // 0x1p53 === 2 ^ 53\n    let x1p_1022 = f64::from_bits(0x0010000000000000); // 0x1p-1022 === 2 ^ (-1022)\n\n    let mut y = x;\n\n    if n > 1023 {\n        y *= x1p1023;\n        n -= 1023;\n        if n > 1023 {\n            y *= x1p1023;\n            n -= 1023;\n            if n > 1023 {\n                n = 1023;\n            }\n        }\n    } else if n < -1022 {\n        /* make sure final n < -53 to avoid double\n           rounding in the subnormal range */\n        y *= x1p_1022 * x1p53;\n        n += 1022 - 53;\n        if n < -1022 {\n            y *= x1p_1022 * x1p53;\n            n += 1022 - 53;\n            if n < -1022 {\n                n = -1022;\n            }\n        }\n    }\n    y * f64::from_bits(((0x3ff + n) as u64) << 52)\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2.c\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n//\n// Optimized by Bruce D. Evans. */\n\nuse super::rem_pio2_large;\n\n// #if FLT_EVAL_METHOD==0 || FLT_EVAL_METHOD==1\n// #define EPS DBL_EPSILON\nconst EPS: f64 = 2.2204460492503131e-16;\n// #elif FLT_EVAL_METHOD==2\n// #define EPS LDBL_EPSILON\n// #endif\n\n// TODO: Support FLT_EVAL_METHOD?\n\nconst TO_INT: f64 = 1.5 / EPS;\n/// 53 bits of 2/pi\nconst INV_PIO2: f64 = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */\n/// first 33 bits of pi/2\nconst PIO2_1: f64 = 1.57079632673412561417e+00; /* 0x3FF921FB, 0x54400000 */\n/// pi/2 - PIO2_1\nconst PIO2_1T: f64 = 6.07710050650619224932e-11; /* 0x3DD0B461, 0x1A626331 */\n/// second 33 bits of pi/2\nconst PIO2_2: f64 = 6.07710050630396597660e-11; /* 0x3DD0B461, 0x1A600000 */\n/// pi/2 - (PIO2_1+PIO2_2)\nconst PIO2_2T: f64 = 2.02226624879595063154e-21; /* 0x3BA3198A, 0x2E037073 */\n/// third 33 bits of pi/2\nconst PIO2_3: f64 = 2.02226624871116645580e-21; /* 0x3BA3198A, 0x2E000000 */\n/// pi/2 - (PIO2_1+PIO2_2+PIO2_3)\nconst PIO2_3T: f64 = 8.47842766036889956997e-32; /* 0x397B839A, 0x252049C1 */\n\n// return the remainder of x rem pi/2 in y[0]+y[1]\n// use rem_pio2_large() for large x\n//\n// caller must handle the case when reduction is not needed: |x| ~<= pi/4 */\n#[inline]\npub fn rem_pio2(x: f64) -> (i32, f64, f64) {\n    let x1p24 = f64::from_bits(0x4170000000000000);\n\n    let sign = (f64::to_bits(x) >> 63) as i32;\n    let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;\n\n    #[inline]\n    fn medium(x: f64, ix: u32) -> (i32, f64, f64) {\n        /* rint(x/(pi/2)), Assume round-to-nearest. */\n        let f_n = x as f64 * INV_PIO2 + TO_INT - TO_INT;\n        let n = f_n as i32;\n        let mut r = x - f_n * PIO2_1;\n        let mut w = f_n * PIO2_1T; /* 1st round, good to 85 bits */\n        let mut y0 = r - w;\n        let ui = f64::to_bits(y0);\n        let ey = (ui >> 52) as i32 & 0x7ff;\n        let ex = (ix >> 20) as i32;\n        if ex - ey > 16 {\n            /* 2nd round, good to 118 bits */\n            let t = r;\n            w = f_n * PIO2_2;\n            r = t - w;\n            w = f_n * PIO2_2T - ((t - r) - w);\n            y0 = r - w;\n            let ey = (f64::to_bits(y0) >> 52) as i32 & 0x7ff;\n            if ex - ey > 49 {\n                /* 3rd round, good to 151 bits, covers all cases */\n                let t = r;\n                w = f_n * PIO2_3;\n                r = t - w;\n                w = f_n * PIO2_3T - ((t - r) - w);\n                y0 = r - w;\n            }\n        }\n        let y1 = (r - y0) - w;\n        return (n, y0, y1);\n    }\n\n    if ix <= 0x400f6a7a {\n        /* |x| ~<= 5pi/4 */\n        if (ix & 0xfffff) == 0x921fb {\n            /* |x| ~= pi/2 or 2pi/2 */\n            medium(x, ix); /* cancellation -- use medium case */\n        }\n        if ix <= 0x4002d97c {\n            /* |x| ~<= 3pi/4 */\n            if sign == 0 {\n                let z = x - PIO2_1; /* one round good to 85 bits */\n                let y0 = z - PIO2_1T;\n                let y1 = (z - y0) - PIO2_1T;\n                return (1, y0, y1);\n            } else {\n                let z = x + PIO2_1;\n                let y0 = z + PIO2_1T;\n                let y1 = (z - y0) + PIO2_1T;\n                return (-1, y0, y1);\n            }\n        } else {\n            if sign == 0 {\n                let z = x - 2.0 * PIO2_1;\n                let y0 = z - 2.0 * PIO2_1T;\n                let y1 = (z - y0) - 2.0 * PIO2_1T;\n                return (2, y0, y1);\n            } else {\n                let z = x + 2.0 * PIO2_1;\n                let y0 = z + 2.0 * PIO2_1T;\n                let y1 = (z - y0) + 2.0 * PIO2_1T;\n                return (-2, y0, y1);\n            }\n        }\n    }\n    if ix <= 0x401c463b {\n        /* |x| ~<= 9pi/4 */\n        if ix <= 0x4015fdbc {\n            /* |x| ~<= 7pi/4 */\n            if ix == 0x4012d97c {\n                /* |x| ~= 3pi/2 */\n                return medium(x, ix);\n            }\n            if sign == 0 {\n                let z = x - 3.0 * PIO2_1;\n                let y0 = z - 3.0 * PIO2_1T;\n                let y1 = (z - y0) - 3.0 * PIO2_1T;\n                return (3, y0, y1);\n            } else {\n                let z = x + 3.0 * PIO2_1;\n                let y0 = z + 3.0 * PIO2_1T;\n                let y1 = (z - y0) + 3.0 * PIO2_1T;\n                return (-3, y0, y1);\n            }\n        } else {\n            if ix == 0x401921fb {\n                /* |x| ~= 4pi/2 */\n                return medium(x, ix);\n            }\n            if sign == 0 {\n                let z = x - 4.0 * PIO2_1;\n                let y0 = z - 4.0 * PIO2_1T;\n                let y1 = (z - y0) - 4.0 * PIO2_1T;\n                return (4, y0, y1);\n            } else {\n                let z = x + 4.0 * PIO2_1;\n                let y0 = z + 4.0 * PIO2_1T;\n                let y1 = (z - y0) + 4.0 * PIO2_1T;\n                return (-4, y0, y1);\n            }\n        }\n    }\n    if ix < 0x413921fb {\n        /* |x| ~< 2^20*(pi/2), medium size */\n        return medium(x, ix);\n    }\n    /*\n     * all other (large) arguments\n     */\n    if ix >= 0x7ff00000 {\n        /* x is inf or NaN */\n        let y0 = x - x;\n        let y1 = y0;\n        return (0, y0, y1);\n    }\n    /* set z = scalbn(|x|,-ilogb(x)+23) */\n    let mut ui = f64::to_bits(x);\n    ui &= (!1) >> 12;\n    ui |= (0x3ff + 23) << 52;\n    let mut z = f64::from_bits(ui);\n    let mut tx = [0.0; 3];\n    for i in 0..2 {\n        tx[i] = z as i32 as f64;\n        z = (z - tx[i]) * x1p24;\n    }\n    tx[2] = z;\n    /* skip zero terms, first term is non-zero */\n    let mut i = 2;\n    while i != 0 && tx[i] == 0.0 {\n        i -= 1;\n    }\n    let mut ty = [0.0; 3];\n    let n = rem_pio2_large(&tx[..=i], &mut ty, ((ix >> 20) - (0x3ff + 23)) as i32, 1);\n    if sign != 0 {\n        return (-n, -ty[0], -ty[1]);\n    }\n    return (n, ty[0], ty[1]);\n}\n","use core::f64;\n\nconst TOINT: f64 = 1. / f64::EPSILON;\n\n#[inline]\npub fn floor(x: f64) -> f64 {\n    // On wasm32 we know that LLVM's intrinsic will compile to an optimized\n    // `f64.floor` native instruction, so we can leverage this for both code size\n    // and speed.\n    llvm_intrinsically_optimized! {\n        #[cfg(target_arch = \"wasm32\")] {\n            return unsafe { ::core::intrinsics::floorf64(x) }\n        }\n    }\n    let ui = x.to_bits();\n    let e = ((ui >> 52) & 0x7ff) as i32;\n\n    if (e >= 0x3ff + 52) || (x == 0.) {\n        return x;\n    }\n    /* y = int(x) - x, where int(x) is an integer neighbor of x */\n    let y = if (ui >> 63) != 0 {\n        x - TOINT + TOINT - x\n    } else {\n        x + TOINT - TOINT - x\n    };\n    /* special case because of non-nearest rounding modes */\n    if e <= 0x3ff - 1 {\n        force_eval!(y);\n        return if (ui >> 63) != 0 { -1. } else { 0. };\n    }\n    if y > 0. {\n        x + y - 1.\n    } else {\n        x + y\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_acos.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/* acos(x)\n * Method :\n *      acos(x)  = pi/2 - asin(x)\n *      acos(-x) = pi/2 + asin(x)\n * For |x|<=0.5\n *      acos(x) = pi/2 - (x + x*x^2*R(x^2))     (see asin.c)\n * For x>0.5\n *      acos(x) = pi/2 - (pi/2 - 2asin(sqrt((1-x)/2)))\n *              = 2asin(sqrt((1-x)/2))\n *              = 2s + 2s*z*R(z)        ...z=(1-x)/2, s=sqrt(z)\n *              = 2f + (2c + 2s*z*R(z))\n *     where f=hi part of s, and c = (z-f*f)/(s+f) is the correction term\n *     for f so that f+c ~ sqrt(z).\n * For x<-0.5\n *      acos(x) = pi - 2asin(sqrt((1-|x|)/2))\n *              = pi - 0.5*(s+s*z*R(z)), where z=(1-|x|)/2,s=sqrt(z)\n *\n * Special cases:\n *      if x is NaN, return x itself;\n *      if |x|>1, return NaN with invalid signal.\n *\n * Function needed: sqrt\n */\n\nuse super::sqrt;\n\nconst PIO2_HI: f64 = 1.57079632679489655800e+00; /* 0x3FF921FB, 0x54442D18 */\nconst PIO2_LO: f64 = 6.12323399573676603587e-17; /* 0x3C91A626, 0x33145C07 */\nconst PS0: f64 = 1.66666666666666657415e-01; /* 0x3FC55555, 0x55555555 */\nconst PS1: f64 = -3.25565818622400915405e-01; /* 0xBFD4D612, 0x03EB6F7D */\nconst PS2: f64 = 2.01212532134862925881e-01; /* 0x3FC9C155, 0x0E884455 */\nconst PS3: f64 = -4.00555345006794114027e-02; /* 0xBFA48228, 0xB5688F3B */\nconst PS4: f64 = 7.91534994289814532176e-04; /* 0x3F49EFE0, 0x7501B288 */\nconst PS5: f64 = 3.47933107596021167570e-05; /* 0x3F023DE1, 0x0DFDF709 */\nconst QS1: f64 = -2.40339491173441421878e+00; /* 0xC0033A27, 0x1C8A2D4B */\nconst QS2: f64 = 2.02094576023350569471e+00; /* 0x40002AE5, 0x9C598AC8 */\nconst QS3: f64 = -6.88283971605453293030e-01; /* 0xBFE6066C, 0x1B8D0159 */\nconst QS4: f64 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */\n\n#[inline]\nfn r(z: f64) -> f64 {\n    let p: f64 = z * (PS0 + z * (PS1 + z * (PS2 + z * (PS3 + z * (PS4 + z * PS5)))));\n    let q: f64 = 1.0 + z * (QS1 + z * (QS2 + z * (QS3 + z * QS4)));\n    return p / q;\n}\n\n#[inline]\npub fn acos(x: f64) -> f64 {\n    let x1p_120f = f64::from_bits(0x3870000000000000); // 0x1p-120 === 2 ^ -120\n    let z: f64;\n    let w: f64;\n    let s: f64;\n    let c: f64;\n    let df: f64;\n    let hx: u32;\n    let ix: u32;\n\n    hx = (x.to_bits() >> 32) as u32;\n    ix = hx & 0x7fffffff;\n    /* |x| >= 1 or nan */\n    if ix >= 0x3ff00000 {\n        let lx: u32 = x.to_bits() as u32;\n\n        if (ix - 0x3ff00000 | lx) == 0 {\n            /* acos(1)=0, acos(-1)=pi */\n            if (hx >> 31) != 0 {\n                return 2. * PIO2_HI + x1p_120f;\n            }\n            return 0.;\n        }\n        return 0. / (x - x);\n    }\n    /* |x| < 0.5 */\n    if ix < 0x3fe00000 {\n        if ix <= 0x3c600000 {\n            /* |x| < 2**-57 */\n            return PIO2_HI + x1p_120f;\n        }\n        return PIO2_HI - (x - (PIO2_LO - x * r(x * x)));\n    }\n    /* x < -0.5 */\n    if (hx >> 31) != 0 {\n        z = (1.0 + x) * 0.5;\n        s = sqrt(z);\n        w = r(z) * s - PIO2_LO;\n        return 2. * (PIO2_HI - (s + w));\n    }\n    /* x > 0.5 */\n    z = (1.0 - x) * 0.5;\n    s = sqrt(z);\n    // Set the low 4 bytes to zero\n    df = f64::from_bits(s.to_bits() & 0xff_ff_ff_ff_00_00_00_00);\n\n    c = (z - df * df) / (s + df);\n    w = r(z) * s + c;\n    return 2. * (df + w);\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_sqrt.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/* sqrt(x)\n * Return correctly rounded sqrt.\n *           ------------------------------------------\n *           |  Use the hardware sqrt if you have one |\n *           ------------------------------------------\n * Method:\n *   Bit by bit method using integer arithmetic. (Slow, but portable)\n *   1. Normalization\n *      Scale x to y in [1,4) with even powers of 2:\n *      find an integer k such that  1 <= (y=x*2^(2k)) < 4, then\n *              sqrt(x) = 2^k * sqrt(y)\n *   2. Bit by bit computation\n *      Let q  = sqrt(y) truncated to i bit after binary point (q = 1),\n *           i                                                   0\n *                                     i+1         2\n *          s  = 2*q , and      y  =  2   * ( y - q  ).         (1)\n *           i      i            i                 i\n *\n *      To compute q    from q , one checks whether\n *                  i+1       i\n *\n *                            -(i+1) 2\n *                      (q + 2      ) <= y.                     (2)\n *                        i\n *                                                            -(i+1)\n *      If (2) is false, then q   = q ; otherwise q   = q  + 2      .\n *                             i+1   i             i+1   i\n *\n *      With some algebric manipulation, it is not difficult to see\n *      that (2) is equivalent to\n *                             -(i+1)\n *                      s  +  2       <= y                      (3)\n *                       i                i\n *\n *      The advantage of (3) is that s  and y  can be computed by\n *                                    i      i\n *      the following recurrence formula:\n *          if (3) is false\n *\n *          s     =  s  ,       y    = y   ;                    (4)\n *           i+1      i          i+1    i\n *\n *          otherwise,\n *                         -i                     -(i+1)\n *          s     =  s  + 2  ,  y    = y  -  s  - 2             (5)\n *           i+1      i          i+1    i     i\n *\n *      One may easily use induction to prove (4) and (5).\n *      Note. Since the left hand side of (3) contain only i+2 bits,\n *            it does not necessary to do a full (53-bit) comparison\n *            in (3).\n *   3. Final rounding\n *      After generating the 53 bits result, we compute one more bit.\n *      Together with the remainder, we can decide whether the\n *      result is exact, bigger than 1/2ulp, or less than 1/2ulp\n *      (it will never equal to 1/2ulp).\n *      The rounding mode can be detected by checking whether\n *      huge + tiny is equal to huge, and whether huge - tiny is\n *      equal to huge for some floating point number \"huge\" and \"tiny\".\n *\n * Special cases:\n *      sqrt(+-0) = +-0         ... exact\n *      sqrt(inf) = inf\n *      sqrt(-ve) = NaN         ... with invalid signal\n *      sqrt(NaN) = NaN         ... with invalid signal for signaling NaN\n */\n\nuse core::f64;\n\nconst TINY: f64 = 1.0e-300;\n\n#[inline]\npub fn sqrt(x: f64) -> f64 {\n    // On wasm32 we know that LLVM's intrinsic will compile to an optimized\n    // `f64.sqrt` native instruction, so we can leverage this for both code size\n    // and speed.\n    llvm_intrinsically_optimized! {\n        #[cfg(target_arch = \"wasm32\")] {\n            return if x < 0.0 {\n                f64::NAN\n            } else {\n                unsafe { ::core::intrinsics::sqrtf64(x) }\n            }\n        }\n    }\n    let mut z: f64;\n    let sign: u32 = 0x80000000;\n    let mut ix0: i32;\n    let mut s0: i32;\n    let mut q: i32;\n    let mut m: i32;\n    let mut t: i32;\n    let mut i: i32;\n    let mut r: u32;\n    let mut t1: u32;\n    let mut s1: u32;\n    let mut ix1: u32;\n    let mut q1: u32;\n\n    ix0 = (x.to_bits() >> 32) as i32;\n    ix1 = x.to_bits() as u32;\n\n    /* take care of Inf and NaN */\n    if (ix0 & 0x7ff00000) == 0x7ff00000 {\n        return x * x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */\n    }\n    /* take care of zero */\n    if ix0 <= 0 {\n        if ((ix0 & !(sign as i32)) | ix1 as i32) == 0 {\n            return x; /* sqrt(+-0) = +-0 */\n        }\n        if ix0 < 0 {\n            return (x - x) / (x - x); /* sqrt(-ve) = sNaN */\n        }\n    }\n    /* normalize x */\n    m = ix0 >> 20;\n    if m == 0 {\n        /* subnormal x */\n        while ix0 == 0 {\n            m -= 21;\n            ix0 |= (ix1 >> 11) as i32;\n            ix1 <<= 21;\n        }\n        i = 0;\n        while (ix0 & 0x00100000) == 0 {\n            i += 1;\n            ix0 <<= 1;\n        }\n        m -= i - 1;\n        ix0 |= (ix1 >> (32 - i)) as i32;\n        ix1 <<= i;\n    }\n    m -= 1023; /* unbias exponent */\n    ix0 = (ix0 & 0x000fffff) | 0x00100000;\n    if (m & 1) == 1 {\n        /* odd m, double x to make it even */\n        ix0 += ix0 + ((ix1 & sign) >> 31) as i32;\n        ix1 += ix1;\n    }\n    m >>= 1; /* m = [m/2] */\n\n    /* generate sqrt(x) bit by bit */\n    ix0 += ix0 + ((ix1 & sign) >> 31) as i32;\n    ix1 += ix1;\n    q = 0; /* [q,q1] = sqrt(x) */\n    q1 = 0;\n    s0 = 0;\n    s1 = 0;\n    r = 0x00200000; /* r = moving bit from right to left */\n\n    while r != 0 {\n        t = s0 + r as i32;\n        if t <= ix0 {\n            s0 = t + r as i32;\n            ix0 -= t;\n            q += r as i32;\n        }\n        ix0 += ix0 + ((ix1 & sign) >> 31) as i32;\n        ix1 += ix1;\n        r >>= 1;\n    }\n\n    r = sign;\n    while r != 0 {\n        t1 = s1 + r;\n        t = s0;\n        if t < ix0 || (t == ix0 && t1 <= ix1) {\n            s1 = t1 + r;\n            if (t1 & sign) == sign && (s1 & sign) == 0 {\n                s0 += 1;\n            }\n            ix0 -= t;\n            if ix1 < t1 {\n                ix0 -= 1;\n            }\n            ix1 -= t1;\n            q1 += r;\n        }\n        ix0 += ix0 + ((ix1 & sign) >> 31) as i32;\n        ix1 += ix1;\n        r >>= 1;\n    }\n\n    /* use floating add to find out rounding direction */\n    if (ix0 as u32 | ix1) != 0 {\n        z = 1.0 - TINY; /* raise inexact flag */\n        if z >= 1.0 {\n            z = 1.0 + TINY;\n            if q1 == 0xffffffff {\n                q1 = 0;\n                q += 1;\n            } else if z > 1.0 {\n                if q1 == 0xfffffffe {\n                    q += 1;\n                }\n                q1 += 2;\n            } else {\n                q1 += q1 & 1;\n            }\n        }\n    }\n    ix0 = (q >> 1) + 0x3fe00000;\n    ix1 = q1 >> 1;\n    if (q & 1) == 1 {\n        ix1 |= sign;\n    }\n    ix0 += m << 20;\n    f64::from_bits((ix0 as u64) << 32 | ix1 as u64)\n}\n","macro_rules! force_eval {\n    ($e:expr) => {\n        unsafe {\n            ::core::ptr::read_volatile(&$e);\n        }\n    };\n}\n\n#[cfg(not(feature = \"checked\"))]\nmacro_rules! i {\n    ($array:expr, $index:expr) => {\n        unsafe { *$array.get_unchecked($index) }\n    };\n    ($array:expr, $index:expr, = , $rhs:expr) => {\n        unsafe {\n            *$array.get_unchecked_mut($index) = $rhs;\n        }\n    };\n    ($array:expr, $index:expr, += , $rhs:expr) => {\n        unsafe {\n            *$array.get_unchecked_mut($index) += $rhs;\n        }\n    };\n    ($array:expr, $index:expr, -= , $rhs:expr) => {\n        unsafe {\n            *$array.get_unchecked_mut($index) -= $rhs;\n        }\n    };\n    ($array:expr, $index:expr, &= , $rhs:expr) => {\n        unsafe {\n            *$array.get_unchecked_mut($index) &= $rhs;\n        }\n    };\n    ($array:expr, $index:expr, == , $rhs:expr) => {\n        unsafe { *$array.get_unchecked_mut($index) == $rhs }\n    };\n}\n\n#[cfg(feature = \"checked\")]\nmacro_rules! i {\n    ($array:expr, $index:expr) => {\n        *$array.get($index).unwrap()\n    };\n    ($array:expr, $index:expr, = , $rhs:expr) => {\n        *$array.get_mut($index).unwrap() = $rhs;\n    };\n    ($array:expr, $index:expr, -= , $rhs:expr) => {\n        *$array.get_mut($index).unwrap() -= $rhs;\n    };\n    ($array:expr, $index:expr, += , $rhs:expr) => {\n        *$array.get_mut($index).unwrap() += $rhs;\n    };\n    ($array:expr, $index:expr, &= , $rhs:expr) => {\n        *$array.get_mut($index).unwrap() &= $rhs;\n    };\n    ($array:expr, $index:expr, == , $rhs:expr) => {\n        *$array.get_mut($index).unwrap() == $rhs\n    };\n}\n\nmacro_rules! llvm_intrinsically_optimized {\n    (#[cfg($($clause:tt)*)] $e:expr) => {\n        #[cfg(all(not(feature = \"stable\"), $($clause)*))]\n        {\n            if true { // thwart the dead code lint\n                $e\n            }\n        }\n    };\n}\n\n// Public modules\nmod acos;\nmod acosf;\nmod asin;\nmod asinf;\nmod atan;\nmod atan2;\nmod atan2f;\nmod atanf;\nmod cbrt;\nmod cbrtf;\nmod ceil;\nmod ceilf;\nmod cos;\nmod cosf;\nmod cosh;\nmod coshf;\nmod exp;\nmod exp2;\nmod exp2f;\nmod expf;\nmod expm1;\nmod expm1f;\nmod fabs;\nmod fabsf;\nmod fdim;\nmod fdimf;\nmod floor;\nmod floorf;\nmod fma;\nmod fmaf;\nmod fmod;\nmod fmodf;\nmod hypot;\nmod hypotf;\nmod log;\nmod log10;\nmod log10f;\nmod log1p;\nmod log1pf;\nmod log2;\nmod log2f;\nmod logf;\nmod pow;\nmod powf;\nmod round;\nmod roundf;\nmod scalbn;\nmod scalbnf;\nmod sin;\nmod sinf;\nmod sinh;\nmod sinhf;\nmod sqrt;\nmod sqrtf;\nmod tan;\nmod tanf;\nmod tanh;\nmod tanhf;\nmod trunc;\nmod truncf;\n\n// Use separated imports instead of {}-grouped imports for easier merging.\npub use self::acos::acos;\npub use self::acosf::acosf;\npub use self::asin::asin;\npub use self::asinf::asinf;\npub use self::atan::atan;\npub use self::atan2::atan2;\npub use self::atan2f::atan2f;\npub use self::atanf::atanf;\npub use self::cbrt::cbrt;\npub use self::cbrtf::cbrtf;\npub use self::ceil::ceil;\npub use self::ceilf::ceilf;\npub use self::cos::cos;\npub use self::cosf::cosf;\npub use self::cosh::cosh;\npub use self::coshf::coshf;\npub use self::exp::exp;\npub use self::exp2::exp2;\npub use self::exp2f::exp2f;\npub use self::expf::expf;\npub use self::expm1::expm1;\npub use self::expm1f::expm1f;\npub use self::fabs::fabs;\npub use self::fabsf::fabsf;\npub use self::fdim::fdim;\npub use self::fdimf::fdimf;\npub use self::floor::floor;\npub use self::floorf::floorf;\npub use self::fma::fma;\npub use self::fmaf::fmaf;\npub use self::fmod::fmod;\npub use self::fmodf::fmodf;\npub use self::hypot::hypot;\npub use self::hypotf::hypotf;\npub use self::log::log;\npub use self::log10::log10;\npub use self::log10f::log10f;\npub use self::log1p::log1p;\npub use self::log1pf::log1pf;\npub use self::log2::log2;\npub use self::log2f::log2f;\npub use self::logf::logf;\npub use self::pow::pow;\npub use self::powf::powf;\npub use self::round::round;\npub use self::roundf::roundf;\npub use self::scalbn::scalbn;\npub use self::scalbnf::scalbnf;\npub use self::sin::sin;\npub use self::sinf::sinf;\npub use self::sinh::sinh;\npub use self::sinhf::sinhf;\npub use self::sqrt::sqrt;\npub use self::sqrtf::sqrtf;\npub use self::tan::tan;\npub use self::tanf::tanf;\npub use self::tanh::tanh;\npub use self::tanhf::tanhf;\npub use self::trunc::trunc;\npub use self::truncf::truncf;\n\n// Private modules\nmod expo2;\nmod fenv;\nmod k_cos;\nmod k_cosf;\nmod k_expo2;\nmod k_expo2f;\nmod k_sin;\nmod k_sinf;\nmod k_tan;\nmod k_tanf;\nmod rem_pio2;\nmod rem_pio2_large;\nmod rem_pio2f;\n\n// Private re-imports\nuse self::expo2::expo2;\nuse self::k_cos::k_cos;\nuse self::k_cosf::k_cosf;\nuse self::k_expo2::k_expo2;\nuse self::k_expo2f::k_expo2f;\nuse self::k_sin::k_sin;\nuse self::k_sinf::k_sinf;\nuse self::k_tan::k_tan;\nuse self::k_tanf::k_tanf;\nuse self::rem_pio2::rem_pio2;\nuse self::rem_pio2_large::rem_pio2_large;\nuse self::rem_pio2f::rem_pio2f;\n\n#[inline]\nfn get_high_word(x: f64) -> u32 {\n    (x.to_bits() >> 32) as u32\n}\n\n#[inline]\nfn get_low_word(x: f64) -> u32 {\n    x.to_bits() as u32\n}\n\n#[inline]\nfn with_set_high_word(f: f64, hi: u32) -> f64 {\n    let mut tmp = f.to_bits();\n    tmp &= 0x00000000_ffffffff;\n    tmp |= (hi as u64) << 32;\n    f64::from_bits(tmp)\n}\n\n#[inline]\nfn with_set_low_word(f: f64, lo: u32) -> f64 {\n    let mut tmp = f.to_bits();\n    tmp &= 0xffffffff_00000000;\n    tmp |= lo as u64;\n    f64::from_bits(tmp)\n}\n\n#[inline]\nfn combine_words(hi: u32, lo: u32) -> f64 {\n    f64::from_bits((hi as u64) << 32 | lo as u64)\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_asin.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/* asin(x)\n * Method :\n *      Since  asin(x) = x + x^3/6 + x^5*3/40 + x^7*15/336 + ...\n *      we approximate asin(x) on [0,0.5] by\n *              asin(x) = x + x*x^2*R(x^2)\n *      where\n *              R(x^2) is a rational approximation of (asin(x)-x)/x^3\n *      and its remez error is bounded by\n *              |(asin(x)-x)/x^3 - R(x^2)| < 2^(-58.75)\n *\n *      For x in [0.5,1]\n *              asin(x) = pi/2-2*asin(sqrt((1-x)/2))\n *      Let y = (1-x), z = y/2, s := sqrt(z), and pio2_hi+pio2_lo=pi/2;\n *      then for x>0.98\n *              asin(x) = pi/2 - 2*(s+s*z*R(z))\n *                      = pio2_hi - (2*(s+s*z*R(z)) - pio2_lo)\n *      For x<=0.98, let pio4_hi = pio2_hi/2, then\n *              f = hi part of s;\n *              c = sqrt(z) - f = (z-f*f)/(s+f)         ...f+c=sqrt(z)\n *      and\n *              asin(x) = pi/2 - 2*(s+s*z*R(z))\n *                      = pio4_hi+(pio4-2s)-(2s*z*R(z)-pio2_lo)\n *                      = pio4_hi+(pio4-2f)-(2s*z*R(z)-(pio2_lo+2c))\n *\n * Special cases:\n *      if x is NaN, return x itself;\n *      if |x|>1, return NaN with invalid signal.\n *\n */\n\nuse super::{fabs, get_high_word, get_low_word, sqrt, with_set_low_word};\n\nconst PIO2_HI: f64 = 1.57079632679489655800e+00; /* 0x3FF921FB, 0x54442D18 */\nconst PIO2_LO: f64 = 6.12323399573676603587e-17; /* 0x3C91A626, 0x33145C07 */\n/* coefficients for R(x^2) */\nconst P_S0: f64 = 1.66666666666666657415e-01; /* 0x3FC55555, 0x55555555 */\nconst P_S1: f64 = -3.25565818622400915405e-01; /* 0xBFD4D612, 0x03EB6F7D */\nconst P_S2: f64 = 2.01212532134862925881e-01; /* 0x3FC9C155, 0x0E884455 */\nconst P_S3: f64 = -4.00555345006794114027e-02; /* 0xBFA48228, 0xB5688F3B */\nconst P_S4: f64 = 7.91534994289814532176e-04; /* 0x3F49EFE0, 0x7501B288 */\nconst P_S5: f64 = 3.47933107596021167570e-05; /* 0x3F023DE1, 0x0DFDF709 */\nconst Q_S1: f64 = -2.40339491173441421878e+00; /* 0xC0033A27, 0x1C8A2D4B */\nconst Q_S2: f64 = 2.02094576023350569471e+00; /* 0x40002AE5, 0x9C598AC8 */\nconst Q_S3: f64 = -6.88283971605453293030e-01; /* 0xBFE6066C, 0x1B8D0159 */\nconst Q_S4: f64 = 7.70381505559019352791e-02; /* 0x3FB3B8C5, 0xB12E9282 */\n\n#[inline]\nfn comp_r(z: f64) -> f64 {\n    let p = z * (P_S0 + z * (P_S1 + z * (P_S2 + z * (P_S3 + z * (P_S4 + z * P_S5)))));\n    let q = 1.0 + z * (Q_S1 + z * (Q_S2 + z * (Q_S3 + z * Q_S4)));\n    return p / q;\n}\n\n#[inline]\npub fn asin(mut x: f64) -> f64 {\n    let z: f64;\n    let r: f64;\n    let s: f64;\n    let hx: u32;\n    let ix: u32;\n\n    hx = get_high_word(x);\n    ix = hx & 0x7fffffff;\n    /* |x| >= 1 or nan */\n    if ix >= 0x3ff00000 {\n        let lx: u32;\n        lx = get_low_word(x);\n        if (ix - 0x3ff00000 | lx) == 0 {\n            /* asin(1) = +-pi/2 with inexact */\n            return x * PIO2_HI + f64::from_bits(0x3870000000000000);\n        } else {\n            return 0.0 / (x - x);\n        }\n    }\n    /* |x| < 0.5 */\n    if ix < 0x3fe00000 {\n        /* if 0x1p-1022 <= |x| < 0x1p-26, avoid raising underflow */\n        if ix < 0x3e500000 && ix >= 0x00100000 {\n            return x;\n        } else {\n            return x + x * comp_r(x * x);\n        }\n    }\n    /* 1 > |x| >= 0.5 */\n    z = (1.0 - fabs(x)) * 0.5;\n    s = sqrt(z);\n    r = comp_r(z);\n    if ix >= 0x3fef3333 {\n        /* if |x| > 0.975 */\n        x = PIO2_HI - (2. * (s + s * r) - PIO2_LO);\n    } else {\n        let f: f64;\n        let c: f64;\n        /* f+c = sqrt(z) */\n        f = with_set_low_word(s, 0);\n        c = (z - f * f) / (s + f);\n        x = 0.5 * PIO2_HI - (2.0 * s * r - (PIO2_LO - 2.0 * c) - (0.5 * PIO2_HI - 2.0 * f));\n    }\n    if hx >> 31 != 0 {\n        return -x;\n    } else {\n        return x;\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_atan2.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n *\n */\n/* atan2(y,x)\n * Method :\n *      1. Reduce y to positive by atan2(y,x)=-atan2(-y,x).\n *      2. Reduce x to positive by (if x and y are unexceptional):\n *              ARG (x+iy) = arctan(y/x)           ... if x > 0,\n *              ARG (x+iy) = pi - arctan[y/(-x)]   ... if x < 0,\n *\n * Special cases:\n *\n *      ATAN2((anything), NaN ) is NaN;\n *      ATAN2(NAN , (anything) ) is NaN;\n *      ATAN2(+-0, +(anything but NaN)) is +-0  ;\n *      ATAN2(+-0, -(anything but NaN)) is +-pi ;\n *      ATAN2(+-(anything but 0 and NaN), 0) is +-pi/2;\n *      ATAN2(+-(anything but INF and NaN), +INF) is +-0 ;\n *      ATAN2(+-(anything but INF and NaN), -INF) is +-pi;\n *      ATAN2(+-INF,+INF ) is +-pi/4 ;\n *      ATAN2(+-INF,-INF ) is +-3pi/4;\n *      ATAN2(+-INF, (anything but,0,NaN, and INF)) is +-pi/2;\n *\n * Constants:\n * The hexadecimal values are the intended ones for the following\n * constants. The decimal values may be used, provided that the\n * compiler will convert from decimal to binary accurately enough\n * to produce the hexadecimal values shown.\n */\n\nuse super::atan;\nuse super::fabs;\n\nconst PI: f64 = 3.1415926535897931160E+00; /* 0x400921FB, 0x54442D18 */\nconst PI_LO: f64 = 1.2246467991473531772E-16; /* 0x3CA1A626, 0x33145C07 */\n\n#[inline]\npub fn atan2(y: f64, x: f64) -> f64 {\n    if x.is_nan() || y.is_nan() {\n        return x + y;\n    }\n    let mut ix = (x.to_bits() >> 32) as u32;\n    let lx = x.to_bits() as u32;\n    let mut iy = (y.to_bits() >> 32) as u32;\n    let ly = y.to_bits() as u32;\n    if (ix - 0x3ff00000 | lx) == 0 {\n        /* x = 1.0 */\n        return atan(y);\n    }\n    let m = ((iy >> 31) & 1) | ((ix >> 30) & 2); /* 2*sign(x)+sign(y) */\n    ix &= 0x7fffffff;\n    iy &= 0x7fffffff;\n\n    /* when y = 0 */\n    if (iy | ly) == 0 {\n        return match m {\n            0 | 1 => y, /* atan(+-0,+anything)=+-0 */\n            2 => PI,    /* atan(+0,-anything) = PI */\n            _ => -PI,   /* atan(-0,-anything) =-PI */\n        };\n    }\n    /* when x = 0 */\n    if (ix | lx) == 0 {\n        return if m & 1 != 0 { -PI / 2.0 } else { PI / 2.0 };\n    }\n    /* when x is INF */\n    if ix == 0x7ff00000 {\n        if iy == 0x7ff00000 {\n            return match m {\n                0 => PI / 4.0,        /* atan(+INF,+INF) */\n                1 => -PI / 4.0,       /* atan(-INF,+INF) */\n                2 => 3.0 * PI / 4.0,  /* atan(+INF,-INF) */\n                _ => -3.0 * PI / 4.0, /* atan(-INF,-INF) */\n            };\n        } else {\n            return match m {\n                0 => 0.0,  /* atan(+...,+INF) */\n                1 => -0.0, /* atan(-...,+INF) */\n                2 => PI,   /* atan(+...,-INF) */\n                _ => -PI,  /* atan(-...,-INF) */\n            };\n        }\n    }\n    /* |y/x| > 0x1p64 */\n    if ix + (64 << 20) < iy || iy == 0x7ff00000 {\n        return if m & 1 != 0 { -PI / 2.0 } else { PI / 2.0 };\n    }\n\n    /* z = atan(|y/x|) without spurious underflow */\n    let z = if (m & 2 != 0) && iy + (64 << 20) < ix {\n        /* |y/x| < 0x1p-64, x<0 */\n        0.0\n    } else {\n        atan(fabs(y / x))\n    };\n    match m {\n        0 => z,                /* atan(+,+) */\n        1 => -z,               /* atan(-,+) */\n        2 => PI - (z - PI_LO), /* atan(+,-) */\n        _ => (z - PI_LO) - PI, /* atan(-,-) */\n    }\n}\n\n#[test]\nfn sanity_check() {\n    assert_eq!(atan2(0.0, 1.0), 0.0);\n    assert_eq!(atan2(0.0, -1.0), PI);\n    assert_eq!(atan2(-0.0, -1.0), -PI);\n    assert_eq!(atan2(3.0, 2.0), atan(3.0 / 2.0));\n    assert_eq!(atan2(2.0, -1.0), atan(2.0 / -1.0) + PI);\n    assert_eq!(atan2(-2.0, -1.0), atan(-2.0 / -1.0) - PI);\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/s_cbrt.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n *\n * Optimized by Bruce D. Evans.\n */\n/* cbrt(x)\n * Return cube root of x\n */\n\nuse core::f64;\n\nconst B1: u32 = 715094163; /* B1 = (1023-1023/3-0.03306235651)*2**20 */\nconst B2: u32 = 696219795; /* B2 = (1023-1023/3-54/3-0.03306235651)*2**20 */\n\n/* |1/cbrt(x) - p(x)| < 2**-23.5 (~[-7.93e-8, 7.929e-8]). */\nconst P0: f64 = 1.87595182427177009643; /* 0x3ffe03e6, 0x0f61e692 */\nconst P1: f64 = -1.88497979543377169875; /* 0xbffe28e0, 0x92f02420 */\nconst P2: f64 = 1.621429720105354466140; /* 0x3ff9f160, 0x4a49d6c2 */\nconst P3: f64 = -0.758397934778766047437; /* 0xbfe844cb, 0xbee751d9 */\nconst P4: f64 = 0.145996192886612446982; /* 0x3fc2b000, 0xd4e4edd7 */\n\n#[inline]\npub fn cbrt(x: f64) -> f64 {\n    let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54\n\n    let mut ui: u64 = x.to_bits();\n    let mut r: f64;\n    let s: f64;\n    let mut t: f64;\n    let w: f64;\n    let mut hx: u32 = (ui >> 32) as u32 & 0x7fffffff;\n\n    if hx >= 0x7ff00000 {\n        /* cbrt(NaN,INF) is itself */\n        return x + x;\n    }\n\n    /*\n     * Rough cbrt to 5 bits:\n     *    cbrt(2**e*(1+m) ~= 2**(e/3)*(1+(e%3+m)/3)\n     * where e is integral and >= 0, m is real and in [0, 1), and \"/\" and\n     * \"%\" are integer division and modulus with rounding towards minus\n     * infinity.  The RHS is always >= the LHS and has a maximum relative\n     * error of about 1 in 16.  Adding a bias of -0.03306235651 to the\n     * (e%3+m)/3 term reduces the error to about 1 in 32. With the IEEE\n     * floating point representation, for finite positive normal values,\n     * ordinary integer divison of the value in bits magically gives\n     * almost exactly the RHS of the above provided we first subtract the\n     * exponent bias (1023 for doubles) and later add it back.  We do the\n     * subtraction virtually to keep e >= 0 so that ordinary integer\n     * division rounds towards minus infinity; this is also efficient.\n     */\n    if hx < 0x00100000 {\n        /* zero or subnormal? */\n        ui = (x * x1p54).to_bits();\n        hx = (ui >> 32) as u32 & 0x7fffffff;\n        if hx == 0 {\n            return x; /* cbrt(0) is itself */\n        }\n        hx = hx / 3 + B2;\n    } else {\n        hx = hx / 3 + B1;\n    }\n    ui &= 1 << 63;\n    ui |= (hx as u64) << 32;\n    t = f64::from_bits(ui);\n\n    /*\n     * New cbrt to 23 bits:\n     *    cbrt(x) = t*cbrt(x/t**3) ~= t*P(t**3/x)\n     * where P(r) is a polynomial of degree 4 that approximates 1/cbrt(r)\n     * to within 2**-23.5 when |r - 1| < 1/10.  The rough approximation\n     * has produced t such than |t/cbrt(x) - 1| ~< 1/32, and cubing this\n     * gives us bounds for r = t**3/x.\n     *\n     * Try to optimize for parallel evaluation as in __tanf.c.\n     */\n    r = (t * t) * (t / x);\n    t = t * ((P0 + r * (P1 + r * P2)) + ((r * r) * r) * (P3 + r * P4));\n\n    /*\n     * Round t away from zero to 23 bits (sloppily except for ensuring that\n     * the result is larger in magnitude than cbrt(x) but not much more than\n     * 2 23-bit ulps larger).  With rounding towards zero, the error bound\n     * would be ~5/6 instead of ~4/6.  With a maximum error of 2 23-bit ulps\n     * in the rounded t, the infinite-precision error in the Newton\n     * approximation barely affects third digit in the final error\n     * 0.667; the error in the rounded t can be up to about 3 23-bit ulps\n     * before the final error is larger than 0.667 ulps.\n     */\n    ui = t.to_bits();\n    ui = (ui + 0x80000000) & 0xffffffffc0000000;\n    t = f64::from_bits(ui);\n\n    /* one step Newton iteration to 53 bits with error < 0.667 ulps */\n    s = t * t; /* t*t is exact */\n    r = x / s; /* error <= 0.5 ulps; |r| < |t| */\n    w = t + t; /* t+t is exact */\n    r = (r - t) / (w + r); /* r-t is exact; w+r ~= 3*t */\n    t = t + t * r; /* error <= 0.5 + 0.5/3 + epsilon */\n    t\n}\n","use super::exp;\nuse super::expm1;\nuse super::k_expo2;\n\n#[inline]\npub fn cosh(mut x: f64) -> f64 {\n    /* |x| */\n    let mut ix = x.to_bits();\n    ix &= 0x7fffffffffffffff;\n    x = f64::from_bits(ix);\n    let w = ix >> 32;\n\n    /* |x| < log(2) */\n    if w < 0x3fe62e42 {\n        if w < 0x3ff00000 - (26 << 20) {\n            let x1p120 = f64::from_bits(0x4770000000000000);\n            force_eval!(x + x1p120);\n            return 1.;\n        }\n        let t = expm1(x); // exponential minus 1\n        return 1. + t * t / (2. * (1. + t));\n    }\n\n    /* |x| < log(DBL_MAX) */\n    if w < 0x40862e42 {\n        let t = exp(x);\n        /* note: if x>log(0x1p26) then the 1/t is not needed */\n        return 0.5 * (t + 1. / t);\n    }\n\n    /* |x| > log(DBL_MAX) or nan */\n    k_expo2(x)\n}\n","use super::exp;\n\n/* k is such that k*ln2 has minimal relative error and x - kln2 > log(FLT_MIN) */\nconst K: i32 = 2043;\n\n/* expf(x)/2 for x >= log(FLT_MAX), slightly better than 0.5f*expf(x/2)*expf(x/2) */\n#[inline]\npub(crate) fn k_expo2(x: f64) -> f64 {\n    let k_ln2 = f64::from_bits(0x40962066151add8b);\n    /* note that k is odd and scale*scale overflows */\n    let scale = f64::from_bits(((((0x3ff + K / 2) as u32) << 20) as u64) << 32);\n    /* exp(x - k ln2) * 2**(k-1) */\n    exp(x - k_ln2) * scale * scale\n}\n","use core::f64;\n\nuse super::sqrt;\n\nconst SPLIT: f64 = 134217728. + 1.; // 0x1p27 + 1 === (2 ^ 27) + 1\n\n#[inline]\nfn sq(x: f64) -> (f64, f64) {\n    let xh: f64;\n    let xl: f64;\n    let xc: f64;\n\n    xc = x * SPLIT;\n    xh = x - xc + xc;\n    xl = x - xh;\n    let hi = x * x;\n    let lo = xh * xh - hi + 2. * xh * xl + xl * xl;\n    (hi, lo)\n}\n\n#[inline]\npub fn hypot(mut x: f64, mut y: f64) -> f64 {\n    let x1p700 = f64::from_bits(0x6bb0000000000000); // 0x1p700 === 2 ^ 700\n    let x1p_700 = f64::from_bits(0x1430000000000000); // 0x1p-700 === 2 ^ -700\n\n    let mut uxi = x.to_bits();\n    let mut uyi = y.to_bits();\n    let uti;\n    let ex: i64;\n    let ey: i64;\n    let mut z: f64;\n\n    /* arrange |x| >= |y| */\n    uxi &= -1i64 as u64 >> 1;\n    uyi &= -1i64 as u64 >> 1;\n    if uxi < uyi {\n        uti = uxi;\n        uxi = uyi;\n        uyi = uti;\n    }\n\n    /* special cases */\n    ex = (uxi >> 52) as i64;\n    ey = (uyi >> 52) as i64;\n    x = f64::from_bits(uxi);\n    y = f64::from_bits(uyi);\n    /* note: hypot(inf,nan) == inf */\n    if ey == 0x7ff {\n        return y;\n    }\n    if ex == 0x7ff || uyi == 0 {\n        return x;\n    }\n    /* note: hypot(x,y) ~= x + y*y/x/2 with inexact for small y/x */\n    /* 64 difference is enough for ld80 double_t */\n    if ex - ey > 64 {\n        return x + y;\n    }\n\n    /* precise sqrt argument in nearest rounding mode without overflow */\n    /* xh*xh must not overflow and xl*xl must not underflow in sq */\n    z = 1.;\n    if ex > 0x3ff + 510 {\n        z = x1p700;\n        x *= x1p_700;\n        y *= x1p_700;\n    } else if ey < 0x3ff - 450 {\n        z = x1p_700;\n        x *= x1p700;\n        y *= x1p700;\n    }\n    let (hx, lx) = sq(x);\n    let (hy, ly) = sq(y);\n    return z * sqrt(ly + lx + hy + hx);\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/s_log1p.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/* double log1p(double x)\n * Return the natural logarithm of 1+x.\n *\n * Method :\n *   1. Argument Reduction: find k and f such that\n *                      1+x = 2^k * (1+f),\n *         where  sqrt(2)/2 < 1+f < sqrt(2) .\n *\n *      Note. If k=0, then f=x is exact. However, if k!=0, then f\n *      may not be representable exactly. In that case, a correction\n *      term is need. Let u=1+x rounded. Let c = (1+x)-u, then\n *      log(1+x) - log(u) ~ c/u. Thus, we proceed to compute log(u),\n *      and add back the correction term c/u.\n *      (Note: when x > 2**53, one can simply return log(x))\n *\n *   2. Approximation of log(1+f): See log.c\n *\n *   3. Finally, log1p(x) = k*ln2 + log(1+f) + c/u. See log.c\n *\n * Special cases:\n *      log1p(x) is NaN with signal if x < -1 (including -INF) ;\n *      log1p(+INF) is +INF; log1p(-1) is -INF with signal;\n *      log1p(NaN) is that NaN with no signal.\n *\n * Accuracy:\n *      according to an error analysis, the error is always less than\n *      1 ulp (unit in the last place).\n *\n * Constants:\n * The hexadecimal values are the intended ones for the following\n * constants. The decimal values may be used, provided that the\n * compiler will convert from decimal to binary accurately enough\n * to produce the hexadecimal values shown.\n *\n * Note: Assuming log() return accurate answer, the following\n *       algorithm can be used to compute log1p(x) to within a few ULP:\n *\n *              u = 1+x;\n *              if(u==1.0) return x ; else\n *                         return log(u)*(x/(u-1.0));\n *\n *       See HP-15C Advanced Functions Handbook, p.193.\n */\n\nuse core::f64;\n\nconst LN2_HI: f64 = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */\nconst LN2_LO: f64 = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */\nconst LG1: f64 = 6.666666666666735130e-01; /* 3FE55555 55555593 */\nconst LG2: f64 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */\nconst LG3: f64 = 2.857142874366239149e-01; /* 3FD24924 94229359 */\nconst LG4: f64 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */\nconst LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */\nconst LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */\nconst LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */\n\n#[inline]\npub fn log1p(x: f64) -> f64 {\n    let mut ui: u64 = x.to_bits();\n    let hfsq: f64;\n    let mut f: f64 = 0.;\n    let mut c: f64 = 0.;\n    let s: f64;\n    let z: f64;\n    let r: f64;\n    let w: f64;\n    let t1: f64;\n    let t2: f64;\n    let dk: f64;\n    let hx: u32;\n    let mut hu: u32;\n    let mut k: i32;\n\n    hx = (ui >> 32) as u32;\n    k = 1;\n    if hx < 0x3fda827a || (hx >> 31) > 0 {\n        /* 1+x < sqrt(2)+ */\n        if hx >= 0xbff00000 {\n            /* x <= -1.0 */\n            if x == -1. {\n                return x / 0.0; /* log1p(-1) = -inf */\n            }\n            return (x - x) / 0.0; /* log1p(x<-1) = NaN */\n        }\n        if hx << 1 < 0x3ca00000 << 1 {\n            /* |x| < 2**-53 */\n            /* underflow if subnormal */\n            if (hx & 0x7ff00000) == 0 {\n                force_eval!(x as f32);\n            }\n            return x;\n        }\n        if hx <= 0xbfd2bec4 {\n            /* sqrt(2)/2- <= 1+x < sqrt(2)+ */\n            k = 0;\n            c = 0.;\n            f = x;\n        }\n    } else if hx >= 0x7ff00000 {\n        return x;\n    }\n    if k > 0 {\n        ui = (1. + x).to_bits();\n        hu = (ui >> 32) as u32;\n        hu += 0x3ff00000 - 0x3fe6a09e;\n        k = (hu >> 20) as i32 - 0x3ff;\n        /* correction term ~ log(1+x)-log(u), avoid underflow in c/u */\n        if k < 54 {\n            c = if k >= 2 {\n                1. - (f64::from_bits(ui) - x)\n            } else {\n                x - (f64::from_bits(ui) - 1.)\n            };\n            c /= f64::from_bits(ui);\n        } else {\n            c = 0.;\n        }\n        /* reduce u into [sqrt(2)/2, sqrt(2)] */\n        hu = (hu & 0x000fffff) + 0x3fe6a09e;\n        ui = (hu as u64) << 32 | (ui & 0xffffffff);\n        f = f64::from_bits(ui) - 1.;\n    }\n    hfsq = 0.5 * f * f;\n    s = f / (2.0 + f);\n    z = s * s;\n    w = z * z;\n    t1 = w * (LG2 + w * (LG4 + w * LG6));\n    t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));\n    r = t2 + t1;\n    dk = k as f64;\n    return s * (hfsq + r) + (dk * LN2_LO + c) - hfsq + f + dk * LN2_HI;\n}\n","use super::{expm1, expo2};\n\n// sinh(x) = (exp(x) - 1/exp(x))/2\n//         = (exp(x)-1 + (exp(x)-1)/exp(x))/2\n//         = x + x^3/6 + o(x^5)\n//\n#[inline]\npub fn sinh(x: f64) -> f64 {\n    // union {double f; uint64_t i;} u = {.f = x};\n    // uint32_t w;\n    // double t, h, absx;\n\n    let mut uf: f64 = x;\n    let mut ui: u64 = f64::to_bits(uf);\n    let w: u32;\n    let t: f64;\n    let mut h: f64;\n    let absx: f64;\n\n    h = 0.5;\n    if ui >> 63 != 0 {\n        h = -h;\n    }\n    /* |x| */\n    ui &= !1 / 2;\n    uf = f64::from_bits(ui);\n    absx = uf;\n    w = (ui >> 32) as u32;\n\n    /* |x| < log(DBL_MAX) */\n    if w < 0x40862e42 {\n        t = expm1(absx);\n        if w < 0x3ff00000 {\n            if w < 0x3ff00000 - (26 << 20) {\n                /* note: inexact and underflow are raised by expm1 */\n                /* note: this branch avoids spurious underflow */\n                return x;\n            }\n            return h * (2.0 * t - t * t / (t + 1.0));\n        }\n        /* note: |x|>log(0x1p26)+eps could be just h*exp(x) */\n        return h * (t + t / (t + 1.0));\n    }\n\n    /* |x| > log(DBL_MAX) or nan */\n    /* note: the result is stored to handle overflow */\n    t = 2.0 * h * expo2(absx);\n    return t;\n}\n","use super::{combine_words, exp};\n\n/* exp(x)/2 for x >= log(DBL_MAX), slightly better than 0.5*exp(x/2)*exp(x/2) */\n#[inline]\npub fn expo2(x: f64) -> f64 {\n    /* k is such that k*ln2 has minimal relative error and x - kln2 > log(DBL_MIN) */\n    const K: i32 = 2043;\n    let kln2 = f64::from_bits(0x40962066151add8b);\n\n    /* note that k is odd and scale*scale overflows */\n    let scale = combine_words(((0x3ff + K / 2) as u32) << 20, 0);\n    /* exp(x - k ln2) * 2**(k-1) */\n    return exp(x - kln2) * scale * scale;\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/s_tan.c */\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\nuse super::{k_tan, rem_pio2};\n\n// tan(x)\n// Return tangent function of x.\n//\n// kernel function:\n//      k_tan           ... tangent function on [-pi/4,pi/4]\n//      rem_pio2        ... argument reduction routine\n//\n// Method.\n//      Let S,C and T denote the sin, cos and tan respectively on\n//      [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2\n//      in [-pi/4 , +pi/4], and let n = k mod 4.\n//      We have\n//\n//          n        sin(x)      cos(x)        tan(x)\n//     ----------------------------------------------------------\n//          0          S           C             T\n//          1          C          -S            -1/T\n//          2         -S          -C             T\n//          3         -C           S            -1/T\n//     ----------------------------------------------------------\n//\n// Special cases:\n//      Let trig be any of sin, cos, or tan.\n//      trig(+-INF)  is NaN, with signals;\n//      trig(NaN)    is that NaN;\n//\n// Accuracy:\n//      TRIG(x) returns trig(x) nearly rounded\n#[inline]\npub fn tan(x: f64) -> f64 {\n    let x1p120 = f32::from_bits(0x7b800000); // 0x1p120f === 2 ^ 120\n\n    let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;\n    /* |x| ~< pi/4 */\n    if ix <= 0x3fe921fb {\n        if ix < 0x3e400000 {\n            /* |x| < 2**-27 */\n            /* raise inexact if x!=0 and underflow if subnormal */\n            force_eval!(if ix < 0x00100000 {\n                x / x1p120 as f64\n            } else {\n                x + x1p120 as f64\n            });\n            return x;\n        }\n        return k_tan(x, 0.0, 0);\n    }\n\n    /* tan(Inf or NaN) is NaN */\n    if ix >= 0x7ff00000 {\n        return x - x;\n    }\n\n    /* argument reduction */\n    let (n, y0, y1) = rem_pio2(x);\n    k_tan(y0, y1, n & 1)\n}\n","use super::expm1;\n\n/* tanh(x) = (exp(x) - exp(-x))/(exp(x) + exp(-x))\n *         = (exp(2*x) - 1)/(exp(2*x) - 1 + 2)\n *         = (1 - exp(-2*x))/(exp(-2*x) - 1 + 2)\n */\n#[inline]\npub fn tanh(mut x: f64) -> f64 {\n    let mut uf: f64 = x;\n    let mut ui: u64 = f64::to_bits(uf);\n\n    let w: u32;\n    let sign: bool;\n    let mut t: f64;\n\n    /* x = |x| */\n    sign = ui >> 63 != 0;\n    ui &= !1 / 2;\n    uf = f64::from_bits(ui);\n    x = uf;\n    w = (ui >> 32) as u32;\n\n    if w > 0x3fe193ea {\n        /* |x| > log(3)/2 ~= 0.5493 or nan */\n        if w > 0x40340000 {\n            /* |x| > 20 or nan */\n            /* note: this branch avoids raising overflow */\n            t = 1.0 - 0.0 / x;\n        } else {\n            t = expm1(2.0 * x);\n            t = 1.0 - 2.0 / (t + 2.0);\n        }\n    } else if w > 0x3fd058ae {\n        /* |x| > log(5/3)/2 ~= 0.2554 */\n        t = expm1(2.0 * x);\n        t = t / (t + 2.0);\n    } else if w >= 0x00100000 {\n        /* |x| >= 0x1p-1022, up to 2ulp error in [0.1,0.2554] */\n        t = expm1(-2.0 * x);\n        t = -t / (t + 2.0);\n    } else {\n        /* |x| is subnormal */\n        /* note: the branch above would not raise underflow in [0x1p-1023,0x1p-1022) */\n        force_eval!(x as f32);\n        t = x;\n    }\n\n    if sign {\n        -t\n    } else {\n        t\n    }\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/s_cos.c */\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\nuse super::{k_cos, k_sin, rem_pio2};\n\n// cos(x)\n// Return cosine function of x.\n//\n// kernel function:\n//      k_sin           ... sine function on [-pi/4,pi/4]\n//      k_cos           ... cosine function on [-pi/4,pi/4]\n//      rem_pio2        ... argument reduction routine\n//\n// Method.\n//      Let S,C and T denote the sin, cos and tan respectively on\n//      [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2\n//      in [-pi/4 , +pi/4], and let n = k mod 4.\n//      We have\n//\n//          n        sin(x)      cos(x)        tan(x)\n//     ----------------------------------------------------------\n//          0          S           C             T\n//          1          C          -S            -1/T\n//          2         -S          -C             T\n//          3         -C           S            -1/T\n//     ----------------------------------------------------------\n//\n// Special cases:\n//      Let trig be any of sin, cos, or tan.\n//      trig(+-INF)  is NaN, with signals;\n//      trig(NaN)    is that NaN;\n//\n// Accuracy:\n//      TRIG(x) returns trig(x) nearly rounded\n//\n#[inline]\npub fn cos(x: f64) -> f64 {\n    let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;\n\n    /* |x| ~< pi/4 */\n    if ix <= 0x3fe921fb {\n        if ix < 0x3e46a09e {\n            /* if x < 2**-27 * sqrt(2) */\n            /* raise inexact if x != 0 */\n            if x as i32 == 0 {\n                return 1.0;\n            }\n        }\n        return k_cos(x, 0.0);\n    }\n\n    /* cos(Inf or NaN) is NaN */\n    if ix >= 0x7ff00000 {\n        return x - x;\n    }\n\n    /* argument reduction needed */\n    let (n, y0, y1) = rem_pio2(x);\n    match n & 3 {\n        0 => k_cos(y0, y1),\n        1 => -k_sin(y0, y1, 1),\n        2 => -k_cos(y0, y1),\n        _ => k_sin(y0, y1, 1),\n    }\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/k_cos.c\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunSoft, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\nconst C1: f64 = 4.16666666666666019037e-02; /* 0x3FA55555, 0x5555554C */\nconst C2: f64 = -1.38888888888741095749e-03; /* 0xBF56C16C, 0x16C15177 */\nconst C3: f64 = 2.48015872894767294178e-05; /* 0x3EFA01A0, 0x19CB1590 */\nconst C4: f64 = -2.75573143513906633035e-07; /* 0xBE927E4F, 0x809C52AD */\nconst C5: f64 = 2.08757232129817482790e-09; /* 0x3E21EE9E, 0xBDB4B1C4 */\nconst C6: f64 = -1.13596475577881948265e-11; /* 0xBDA8FAE9, 0xBE8838D4 */\n\n// kernel cos function on [-pi/4, pi/4], pi/4 ~ 0.785398164\n// Input x is assumed to be bounded by ~pi/4 in magnitude.\n// Input y is the tail of x.\n//\n// Algorithm\n//      1. Since cos(-x) = cos(x), we need only to consider positive x.\n//      2. if x < 2^-27 (hx<0x3e400000 0), return 1 with inexact if x!=0.\n//      3. cos(x) is approximated by a polynomial of degree 14 on\n//         [0,pi/4]\n//                                       4            14\n//              cos(x) ~ 1 - x*x/2 + C1*x + ... + C6*x\n//         where the remez error is\n//\n//      |              2     4     6     8     10    12     14 |     -58\n//      |cos(x)-(1-.5*x +C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  )| <= 2\n//      |                                                      |\n//\n//                     4     6     8     10    12     14\n//      4. let r = C1*x +C2*x +C3*x +C4*x +C5*x  +C6*x  , then\n//             cos(x) ~ 1 - x*x/2 + r\n//         since cos(x+y) ~ cos(x) - sin(x)*y\n//                        ~ cos(x) - x*y,\n//         a correction term is necessary in cos(x) and hence\n//              cos(x+y) = 1 - (x*x/2 - (r - x*y))\n//         For better accuracy, rearrange to\n//              cos(x+y) ~ w + (tmp + (r-x*y))\n//         where w = 1 - x*x/2 and tmp is a tiny correction term\n//         (1 - x*x/2 == w + tmp exactly in infinite precision).\n//         The exactness of w + tmp in infinite precision depends on w\n//         and tmp having the same precision as x.  If they have extra\n//         precision due to compiler bugs, then the extra precision is\n//         only good provided it is retained in all terms of the final\n//         expression for cos().  Retention happens in all cases tested\n//         under FreeBSD, so don't pessimize things by forcibly clipping\n//         any extra precision in w.\n#[inline]\npub fn k_cos(x: f64, y: f64) -> f64 {\n    let z = x * x;\n    let w = z * z;\n    let r = z * (C1 + z * (C2 + z * C3)) + w * w * (C4 + z * (C5 + z * C6));\n    let hz = 0.5 * z;\n    let w = 1.0 - hz;\n    w + (((1.0 - w) - hz) + (z * r - x * y))\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/k_sin.c\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunSoft, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\nconst S1: f64 = -1.66666666666666324348e-01; /* 0xBFC55555, 0x55555549 */\nconst S2: f64 = 8.33333333332248946124e-03; /* 0x3F811111, 0x1110F8A6 */\nconst S3: f64 = -1.98412698298579493134e-04; /* 0xBF2A01A0, 0x19C161D5 */\nconst S4: f64 = 2.75573137070700676789e-06; /* 0x3EC71DE3, 0x57B1FE7D */\nconst S5: f64 = -2.50507602534068634195e-08; /* 0xBE5AE5E6, 0x8A2B9CEB */\nconst S6: f64 = 1.58969099521155010221e-10; /* 0x3DE5D93A, 0x5ACFD57C */\n\n// kernel sin function on ~[-pi/4, pi/4] (except on -0), pi/4 ~ 0.7854\n// Input x is assumed to be bounded by ~pi/4 in magnitude.\n// Input y is the tail of x.\n// Input iy indicates whether y is 0. (if iy=0, y assume to be 0).\n//\n// Algorithm\n//      1. Since sin(-x) = -sin(x), we need only to consider positive x.\n//      2. Callers must return sin(-0) = -0 without calling here since our\n//         odd polynomial is not evaluated in a way that preserves -0.\n//         Callers may do the optimization sin(x) ~ x for tiny x.\n//      3. sin(x) is approximated by a polynomial of degree 13 on\n//         [0,pi/4]\n//                               3            13\n//              sin(x) ~ x + S1*x + ... + S6*x\n//         where\n//\n//      |sin(x)         2     4     6     8     10     12  |     -58\n//      |----- - (1+S1*x +S2*x +S3*x +S4*x +S5*x  +S6*x   )| <= 2\n//      |  x                                               |\n//\n//      4. sin(x+y) = sin(x) + sin'(x')*y\n//                  ~ sin(x) + (1-x*x/2)*y\n//         For better accuracy, let\n//                   3      2      2      2      2\n//              r = x *(S2+x *(S3+x *(S4+x *(S5+x *S6))))\n//         then                   3    2\n//              sin(x) = x + (S1*x + (x *(r-y/2)+y))\n#[inline]\npub fn k_sin(x: f64, y: f64, iy: i32) -> f64 {\n    let z = x * x;\n    let w = z * z;\n    let r = S2 + z * (S3 + z * S4) + z * w * (S5 + z * S6);\n    let v = z * x;\n    if iy == 0 {\n        x + v * (S1 + z * r)\n    } else {\n        x - ((z * (0.5 * y - v * r) - y) - v * S1)\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/s_cosf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n * Optimized by Bruce D. Evans.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nuse super::{k_cosf, k_sinf, rem_pio2f};\n\nuse core::f64::consts::FRAC_PI_2;\n\n/* Small multiples of pi/2 rounded to double precision. */\nconst C1_PIO2: f64 = 1. * FRAC_PI_2; /* 0x3FF921FB, 0x54442D18 */\nconst C2_PIO2: f64 = 2. * FRAC_PI_2; /* 0x400921FB, 0x54442D18 */\nconst C3_PIO2: f64 = 3. * FRAC_PI_2; /* 0x4012D97C, 0x7F3321D2 */\nconst C4_PIO2: f64 = 4. * FRAC_PI_2; /* 0x401921FB, 0x54442D18 */\n\n#[inline]\npub fn cosf(x: f32) -> f32 {\n    let x64 = x as f64;\n\n    let x1p120 = f32::from_bits(0x7b800000); // 0x1p120f === 2 ^ 120\n\n    let mut ix = x.to_bits();\n    let sign = (ix >> 31) != 0;\n    ix &= 0x7fffffff;\n\n    if ix <= 0x3f490fda {\n        /* |x| ~<= pi/4 */\n        if ix < 0x39800000 {\n            /* |x| < 2**-12 */\n            /* raise inexact if x != 0 */\n            force_eval!(x + x1p120);\n            return 1.;\n        }\n        return k_cosf(x64);\n    }\n    if ix <= 0x407b53d1 {\n        /* |x| ~<= 5*pi/4 */\n        if ix > 0x4016cbe3 {\n            /* |x|  ~> 3*pi/4 */\n            return -k_cosf(if sign { x64 + C2_PIO2 } else { x64 - C2_PIO2 });\n        } else {\n            if sign {\n                return k_sinf(x64 + C1_PIO2);\n            } else {\n                return k_sinf(C1_PIO2 - x64);\n            }\n        }\n    }\n    if ix <= 0x40e231d5 {\n        /* |x| ~<= 9*pi/4 */\n        if ix > 0x40afeddf {\n            /* |x| ~> 7*pi/4 */\n            return k_cosf(if sign { x64 + C4_PIO2 } else { x64 - C4_PIO2 });\n        } else {\n            if sign {\n                return k_sinf(-x64 - C3_PIO2);\n            } else {\n                return k_sinf(x64 - C3_PIO2);\n            }\n        }\n    }\n\n    /* cos(Inf or NaN) is NaN */\n    if ix >= 0x7f800000 {\n        return x - x;\n    }\n\n    /* general argument reduction needed */\n    let (n, y) = rem_pio2f(x);\n    match n & 3 {\n        0 => k_cosf(y),\n        1 => k_sinf(-y),\n        2 => -k_cosf(y),\n        _ => k_sinf(y),\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/k_cosf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n * Debugged and optimized by Bruce D. Evans.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\n/* |cos(x) - c(x)| < 2**-34.1 (~[-5.37e-11, 5.295e-11]). */\nconst C0: f64 = -0.499999997251031003120; /* -0x1ffffffd0c5e81.0p-54 */\nconst C1: f64 = 0.0416666233237390631894; /*  0x155553e1053a42.0p-57 */\nconst C2: f64 = -0.00138867637746099294692; /* -0x16c087e80f1e27.0p-62 */\nconst C3: f64 = 0.0000243904487962774090654; /*  0x199342e0ee5069.0p-68 */\n\n#[inline]\npub fn k_cosf(x: f64) -> f32 {\n    let z = x * x;\n    let w = z * z;\n    let r = C2 + z * C3;\n    (((1.0 + z * C0) + w * C1) + (w * z) * r) as f32\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/k_sinf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n * Optimized by Bruce D. Evans.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\n/* |sin(x)/x - s(x)| < 2**-37.5 (~[-4.89e-12, 4.824e-12]). */\nconst S1: f64 = -0.166666666416265235595; /* -0x15555554cbac77.0p-55 */\nconst S2: f64 = 0.0083333293858894631756; /*  0x111110896efbb2.0p-59 */\nconst S3: f64 = -0.000198393348360966317347; /* -0x1a00f9e2cae774.0p-65 */\nconst S4: f64 = 0.0000027183114939898219064; /*  0x16cd878c3b46a7.0p-71 */\n\n#[inline]\npub fn k_sinf(x: f64) -> f32 {\n    let z = x * x;\n    let w = z * z;\n    let r = S3 + z * S4;\n    let s = z * x;\n    ((x + s * (S1 + z * S2)) + s * w * r) as f32\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_rem_pio2f.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n * Debugged and optimized by Bruce D. Evans.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nuse super::rem_pio2_large;\n\nuse core::f64;\n\nconst TOINT: f64 = 1.5 / f64::EPSILON;\n\n/// 53 bits of 2/pi\nconst INV_PIO2: f64 = 6.36619772367581382433e-01; /* 0x3FE45F30, 0x6DC9C883 */\n/// first 25 bits of pi/2\nconst PIO2_1: f64 = 1.57079631090164184570e+00; /* 0x3FF921FB, 0x50000000 */\n/// pi/2 - pio2_1\nconst PIO2_1T: f64 = 1.58932547735281966916e-08; /* 0x3E5110b4, 0x611A6263 */\n\n/// Return the remainder of x rem pi/2 in *y\n///\n/// use double precision for everything except passing x\n/// use __rem_pio2_large() for large x\n#[inline]\npub fn rem_pio2f(x: f32) -> (i32, f64) {\n    let x64 = x as f64;\n\n    let mut tx: [f64; 1] = [0.];\n    let mut ty: [f64; 1] = [0.];\n\n    let ix = x.to_bits() & 0x7fffffff;\n    /* 25+53 bit pi is good enough for medium size */\n    if ix < 0x4dc90fdb {\n        /* |x| ~< 2^28*(pi/2), medium size */\n        /* Use a specialized rint() to get fn.  Assume round-to-nearest. */\n        let f_n = x64 * INV_PIO2 + TOINT - TOINT;\n        return (f_n as i32, x64 - f_n * PIO2_1 - f_n * PIO2_1T);\n    }\n    if ix >= 0x7f800000 {\n        /* x is inf or NaN */\n        return (0, x64 - x64);\n    }\n    /* scale x into [2^23, 2^24-1] */\n    let sign = (x.to_bits() >> 31) != 0;\n    let e0 = ((ix >> 23) - (0x7f + 23)) as i32; /* e0 = ilogb(|x|)-23, positive */\n    tx[0] = f32::from_bits(ix - (e0 << 23) as u32) as f64;\n    let n = rem_pio2_large(&tx, &mut ty, e0, 0);\n    if sign {\n        return (-n, -ty[0]);\n    }\n    (n, ty[0])\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_expf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nuse super::scalbnf;\n\nconst HALF: [f32; 2] = [0.5, -0.5];\nconst LN2_HI: f32 = 6.9314575195e-01; /* 0x3f317200 */\nconst LN2_LO: f32 = 1.4286067653e-06; /* 0x35bfbe8e */\nconst INV_LN2: f32 = 1.4426950216e+00; /* 0x3fb8aa3b */\n/*\n * Domain [-0.34568, 0.34568], range ~[-4.278e-9, 4.447e-9]:\n * |x*(exp(x)+1)/(exp(x)-1) - p(x)| < 2**-27.74\n */\nconst P1: f32 = 1.6666625440e-1; /*  0xaaaa8f.0p-26 */\nconst P2: f32 = -2.7667332906e-3; /* -0xb55215.0p-32 */\n\n#[inline]\npub fn expf(mut x: f32) -> f32 {\n    let x1p127 = f32::from_bits(0x7f000000); // 0x1p127f === 2 ^ 127\n    let x1p_126 = f32::from_bits(0x800000); // 0x1p-126f === 2 ^ -126  /*original 0x1p-149f    ??????????? */\n\n    let mut hx = x.to_bits();\n    let sign = (hx >> 31) as i32; /* sign bit of x */\n    let signb: bool = sign != 0;\n    hx &= 0x7fffffff; /* high word of |x| */\n\n    /* special cases */\n    if hx >= 0x42aeac50 {\n        /* if |x| >= -87.33655f or NaN */\n        if hx > 0x7f800000 {\n            /* NaN */\n            return x;\n        }\n        if (hx >= 0x42b17218) && (!signb) {\n            /* x >= 88.722839f */\n            /* overflow */\n            x *= x1p127;\n            return x;\n        }\n        if signb {\n            /* underflow */\n            force_eval!(-x1p_126 / x);\n            if hx >= 0x42cff1b5 {\n                /* x <= -103.972084f */\n                return 0.;\n            }\n        }\n    }\n\n    /* argument reduction */\n    let k: i32;\n    let hi: f32;\n    let lo: f32;\n    if hx > 0x3eb17218 {\n        /* if |x| > 0.5 ln2 */\n        if hx > 0x3f851592 {\n            /* if |x| > 1.5 ln2 */\n            k = (INV_LN2 * x + HALF[sign as usize]) as i32;\n        } else {\n            k = 1 - sign - sign;\n        }\n        let kf = k as f32;\n        hi = x - kf * LN2_HI; /* k*ln2hi is exact here */\n        lo = kf * LN2_LO;\n        x = hi - lo;\n    } else if hx > 0x39000000 {\n        /* |x| > 2**-14 */\n        k = 0;\n        hi = x;\n        lo = 0.;\n    } else {\n        /* raise inexact */\n        force_eval!(x1p127 + x);\n        return 1. + x;\n    }\n\n    /* x is now in primary range */\n    let xx = x * x;\n    let c = x - xx * (P1 + xx * P2);\n    let y = 1. + (x * c / (2. - c) - lo + hi);\n    if k == 0 {\n        y\n    } else {\n        scalbnf(y, k)\n    }\n}\n","#[inline]\npub fn scalbnf(mut x: f32, mut n: i32) -> f32 {\n    let x1p127 = f32::from_bits(0x7f000000); // 0x1p127f === 2 ^ 127\n    let x1p_126 = f32::from_bits(0x800000); // 0x1p-126f === 2 ^ -126\n    let x1p24 = f32::from_bits(0x4b800000); // 0x1p24f === 2 ^ 24\n\n    if n > 127 {\n        x *= x1p127;\n        n -= 127;\n        if n > 127 {\n            x *= x1p127;\n            n -= 127;\n            if n > 127 {\n                n = 127;\n            }\n        }\n    } else if n < -126 {\n        x *= x1p_126 * x1p24;\n        n += 126 - 24;\n        if n < -126 {\n            x *= x1p_126 * x1p24;\n            n += 126 - 24;\n            if n < -126 {\n                n = -126;\n            }\n        }\n    }\n    x * f32::from_bits(((0x7f + n) as u32) << 23)\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_log2.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/*\n * Return the base 2 logarithm of x.  See log.c for most comments.\n *\n * Reduce x to 2^k (1+f) and calculate r = log(1+f) - f + f*f/2\n * as in log.c, then combine and scale in extra precision:\n *    log2(x) = (f - f*f/2 + r)/log(2) + k\n */\n\nuse core::f64;\n\nconst IVLN2HI: f64 = 1.44269504072144627571e+00; /* 0x3ff71547, 0x65200000 */\nconst IVLN2LO: f64 = 1.67517131648865118353e-10; /* 0x3de705fc, 0x2eefa200 */\nconst LG1: f64 = 6.666666666666735130e-01; /* 3FE55555 55555593 */\nconst LG2: f64 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */\nconst LG3: f64 = 2.857142874366239149e-01; /* 3FD24924 94229359 */\nconst LG4: f64 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */\nconst LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */\nconst LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */\nconst LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */\n\n#[inline]\npub fn log2(mut x: f64) -> f64 {\n    let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54\n\n    let mut ui: u64 = x.to_bits();\n    let hfsq: f64;\n    let f: f64;\n    let s: f64;\n    let z: f64;\n    let r: f64;\n    let mut w: f64;\n    let t1: f64;\n    let t2: f64;\n    let y: f64;\n    let mut hi: f64;\n    let lo: f64;\n    let mut val_hi: f64;\n    let mut val_lo: f64;\n    let mut hx: u32;\n    let mut k: i32;\n\n    hx = (ui >> 32) as u32;\n    k = 0;\n    if hx < 0x00100000 || (hx >> 31) > 0 {\n        if ui << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if (hx >> 31) > 0 {\n            return (x - x) / 0.0; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale x up */\n        k -= 54;\n        x *= x1p54;\n        ui = x.to_bits();\n        hx = (ui >> 32) as u32;\n    } else if hx >= 0x7ff00000 {\n        return x;\n    } else if hx == 0x3ff00000 && ui << 32 == 0 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    hx += 0x3ff00000 - 0x3fe6a09e;\n    k += (hx >> 20) as i32 - 0x3ff;\n    hx = (hx & 0x000fffff) + 0x3fe6a09e;\n    ui = (hx as u64) << 32 | (ui & 0xffffffff);\n    x = f64::from_bits(ui);\n\n    f = x - 1.0;\n    hfsq = 0.5 * f * f;\n    s = f / (2.0 + f);\n    z = s * s;\n    w = z * z;\n    t1 = w * (LG2 + w * (LG4 + w * LG6));\n    t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));\n    r = t2 + t1;\n\n    /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */\n    hi = f - hfsq;\n    ui = hi.to_bits();\n    ui &= (-1i64 as u64) << 32;\n    hi = f64::from_bits(ui);\n    lo = f - hi - hfsq + s * (hfsq + r);\n\n    val_hi = hi * IVLN2HI;\n    val_lo = (lo + hi) * IVLN2LO + lo * IVLN2HI;\n\n    /* spadd(val_hi, val_lo, y), except for not using double_t: */\n    y = k.into();\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    val_hi = w;\n\n    return val_lo + val_hi;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_log2f.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/*\n * See comments in log2.c.\n */\n\nuse core::f32;\n\nconst IVLN2HI: f32 = 1.4428710938e+00; /* 0x3fb8b000 */\nconst IVLN2LO: f32 = -1.7605285393e-04; /* 0xb9389ad4 */\n/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */\nconst LG1: f32 = 0.66666662693; /* 0xaaaaaa.0p-24 */\nconst LG2: f32 = 0.40000972152; /* 0xccce13.0p-25 */\nconst LG3: f32 = 0.28498786688; /* 0x91e9ee.0p-25 */\nconst LG4: f32 = 0.24279078841; /* 0xf89e26.0p-26 */\n\n#[inline]\npub fn log2f(mut x: f32) -> f32 {\n    let x1p25f = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25\n\n    let mut ui: u32 = x.to_bits();\n    let hfsq: f32;\n    let f: f32;\n    let s: f32;\n    let z: f32;\n    let r: f32;\n    let w: f32;\n    let t1: f32;\n    let t2: f32;\n    let mut hi: f32;\n    let lo: f32;\n    let mut ix: u32;\n    let mut k: i32;\n\n    ix = ui;\n    k = 0;\n    if ix < 0x00800000 || (ix >> 31) > 0 {\n        /* x < 2**-126  */\n        if ix << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if (ix >> 31) > 0 {\n            return (x - x) / 0.0; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale up x */\n        k -= 25;\n        x *= x1p25f;\n        ui = x.to_bits();\n        ix = ui;\n    } else if ix >= 0x7f800000 {\n        return x;\n    } else if ix == 0x3f800000 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    ix += 0x3f800000 - 0x3f3504f3;\n    k += (ix >> 23) as i32 - 0x7f;\n    ix = (ix & 0x007fffff) + 0x3f3504f3;\n    ui = ix;\n    x = f32::from_bits(ui);\n\n    f = x - 1.0;\n    s = f / (2.0 + f);\n    z = s * s;\n    w = z * z;\n    t1 = w * (LG2 + w * LG4);\n    t2 = z * (LG1 + w * LG3);\n    r = t2 + t1;\n    hfsq = 0.5 * f * f;\n\n    hi = f - hfsq;\n    ui = hi.to_bits();\n    ui &= 0xfffff000;\n    hi = f32::from_bits(ui);\n    lo = f - hi - hfsq + s * (hfsq + r);\n    return (lo + hi) * IVLN2LO + lo * IVLN2HI + hi * IVLN2HI + k as f32;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_log10.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/*\n * Return the base 10 logarithm of x.  See log.c for most comments.\n *\n * Reduce x to 2^k (1+f) and calculate r = log(1+f) - f + f*f/2\n * as in log.c, then combine and scale in extra precision:\n *    log10(x) = (f - f*f/2 + r)/log(10) + k*log10(2)\n */\n\nuse core::f64;\n\nconst IVLN10HI: f64 = 4.34294481878168880939e-01; /* 0x3fdbcb7b, 0x15200000 */\nconst IVLN10LO: f64 = 2.50829467116452752298e-11; /* 0x3dbb9438, 0xca9aadd5 */\nconst LOG10_2HI: f64 = 3.01029995663611771306e-01; /* 0x3FD34413, 0x509F6000 */\nconst LOG10_2LO: f64 = 3.69423907715893078616e-13; /* 0x3D59FEF3, 0x11F12B36 */\nconst LG1: f64 = 6.666666666666735130e-01; /* 3FE55555 55555593 */\nconst LG2: f64 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */\nconst LG3: f64 = 2.857142874366239149e-01; /* 3FD24924 94229359 */\nconst LG4: f64 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */\nconst LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */\nconst LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */\nconst LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */\n\n#[inline]\npub fn log10(mut x: f64) -> f64 {\n    let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54\n\n    let mut ui: u64 = x.to_bits();\n    let hfsq: f64;\n    let f: f64;\n    let s: f64;\n    let z: f64;\n    let r: f64;\n    let mut w: f64;\n    let t1: f64;\n    let t2: f64;\n    let dk: f64;\n    let y: f64;\n    let mut hi: f64;\n    let lo: f64;\n    let mut val_hi: f64;\n    let mut val_lo: f64;\n    let mut hx: u32;\n    let mut k: i32;\n\n    hx = (ui >> 32) as u32;\n    k = 0;\n    if hx < 0x00100000 || (hx >> 31) > 0 {\n        if ui << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if (hx >> 31) > 0 {\n            return (x - x) / 0.0; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale x up */\n        k -= 54;\n        x *= x1p54;\n        ui = x.to_bits();\n        hx = (ui >> 32) as u32;\n    } else if hx >= 0x7ff00000 {\n        return x;\n    } else if hx == 0x3ff00000 && ui << 32 == 0 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    hx += 0x3ff00000 - 0x3fe6a09e;\n    k += (hx >> 20) as i32 - 0x3ff;\n    hx = (hx & 0x000fffff) + 0x3fe6a09e;\n    ui = (hx as u64) << 32 | (ui & 0xffffffff);\n    x = f64::from_bits(ui);\n\n    f = x - 1.0;\n    hfsq = 0.5 * f * f;\n    s = f / (2.0 + f);\n    z = s * s;\n    w = z * z;\n    t1 = w * (LG2 + w * (LG4 + w * LG6));\n    t2 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));\n    r = t2 + t1;\n\n    /* See log2.c for details. */\n    /* hi+lo = f - hfsq + s*(hfsq+R) ~ log(1+f) */\n    hi = f - hfsq;\n    ui = hi.to_bits();\n    ui &= (-1i64 as u64) << 32;\n    hi = f64::from_bits(ui);\n    lo = f - hi - hfsq + s * (hfsq + r);\n\n    /* val_hi+val_lo ~ log10(1+f) + k*log10(2) */\n    val_hi = hi * IVLN10HI;\n    dk = k as f64;\n    y = dk * LOG10_2HI;\n    val_lo = dk * LOG10_2LO + (lo + hi) * IVLN10LO + lo * IVLN10HI;\n\n    /*\n     * Extra precision in for adding y is not strictly needed\n     * since there is no very large cancellation near x = sqrt(2) or\n     * x = 1/sqrt(2), but we do it anyway since it costs little on CPUs\n     * with some parallelism and it reduces the error for many args.\n     */\n    w = y + val_hi;\n    val_lo += (y - w) + val_hi;\n    val_hi = w;\n\n    return val_lo + val_hi;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_log10f.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/*\n * See comments in log10.c.\n */\n\nuse core::f32;\n\nconst IVLN10HI: f32 = 4.3432617188e-01; /* 0x3ede6000 */\nconst IVLN10LO: f32 = -3.1689971365e-05; /* 0xb804ead9 */\nconst LOG10_2HI: f32 = 3.0102920532e-01; /* 0x3e9a2080 */\nconst LOG10_2LO: f32 = 7.9034151668e-07; /* 0x355427db */\n/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */\nconst LG1: f32 = 0.66666662693; /* 0xaaaaaa.0p-24 */\nconst LG2: f32 = 0.40000972152; /* 0xccce13.0p-25 */\nconst LG3: f32 = 0.28498786688; /* 0x91e9ee.0p-25 */\nconst LG4: f32 = 0.24279078841; /* 0xf89e26.0p-26 */\n\n#[inline]\npub fn log10f(mut x: f32) -> f32 {\n    let x1p25f = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25\n\n    let mut ui: u32 = x.to_bits();\n    let hfsq: f32;\n    let f: f32;\n    let s: f32;\n    let z: f32;\n    let r: f32;\n    let w: f32;\n    let t1: f32;\n    let t2: f32;\n    let dk: f32;\n    let mut hi: f32;\n    let lo: f32;\n    let mut ix: u32;\n    let mut k: i32;\n\n    ix = ui;\n    k = 0;\n    if ix < 0x00800000 || (ix >> 31) > 0 {\n        /* x < 2**-126  */\n        if ix << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if (ix >> 31) > 0 {\n            return (x - x) / 0.0; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale up x */\n        k -= 25;\n        x *= x1p25f;\n        ui = x.to_bits();\n        ix = ui;\n    } else if ix >= 0x7f800000 {\n        return x;\n    } else if ix == 0x3f800000 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    ix += 0x3f800000 - 0x3f3504f3;\n    k += (ix >> 23) as i32 - 0x7f;\n    ix = (ix & 0x007fffff) + 0x3f3504f3;\n    ui = ix;\n    x = f32::from_bits(ui);\n\n    f = x - 1.0;\n    s = f / (2.0 + f);\n    z = s * s;\n    w = z * z;\n    t1 = w * (LG2 + w * LG4);\n    t2 = z * (LG1 + w * LG3);\n    r = t2 + t1;\n    hfsq = 0.5 * f * f;\n\n    hi = f - hfsq;\n    ui = hi.to_bits();\n    ui &= 0xfffff000;\n    hi = f32::from_bits(ui);\n    lo = f - hi - hfsq + s * (hfsq + r);\n    dk = k as f32;\n    return dk * LOG10_2LO + (lo + hi) * IVLN10LO + lo * IVLN10HI + hi * IVLN10HI + dk * LOG10_2HI;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_log.c */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunSoft, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n/* log(x)\n * Return the logarithm of x\n *\n * Method :\n *   1. Argument Reduction: find k and f such that\n *                      x = 2^k * (1+f),\n *         where  sqrt(2)/2 < 1+f < sqrt(2) .\n *\n *   2. Approximation of log(1+f).\n *      Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s)\n *               = 2s + 2/3 s**3 + 2/5 s**5 + .....,\n *               = 2s + s*R\n *      We use a special Remez algorithm on [0,0.1716] to generate\n *      a polynomial of degree 14 to approximate R The maximum error\n *      of this polynomial approximation is bounded by 2**-58.45. In\n *      other words,\n *                      2      4      6      8      10      12      14\n *          R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s  +Lg6*s  +Lg7*s\n *      (the values of Lg1 to Lg7 are listed in the program)\n *      and\n *          |      2          14          |     -58.45\n *          | Lg1*s +...+Lg7*s    -  R(z) | <= 2\n *          |                             |\n *      Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2.\n *      In order to guarantee error in log below 1ulp, we compute log\n *      by\n *              log(1+f) = f - s*(f - R)        (if f is not too large)\n *              log(1+f) = f - (hfsq - s*(hfsq+R)).     (better accuracy)\n *\n *      3. Finally,  log(x) = k*ln2 + log(1+f).\n *                          = k*ln2_hi+(f-(hfsq-(s*(hfsq+R)+k*ln2_lo)))\n *         Here ln2 is split into two floating point number:\n *                      ln2_hi + ln2_lo,\n *         where n*ln2_hi is always exact for |n| < 2000.\n *\n * Special cases:\n *      log(x) is NaN with signal if x < 0 (including -INF) ;\n *      log(+INF) is +INF; log(0) is -INF with signal;\n *      log(NaN) is that NaN with no signal.\n *\n * Accuracy:\n *      according to an error analysis, the error is always less than\n *      1 ulp (unit in the last place).\n *\n * Constants:\n * The hexadecimal values are the intended ones for the following\n * constants. The decimal values may be used, provided that the\n * compiler will convert from decimal to binary accurately enough\n * to produce the hexadecimal values shown.\n */\n\nconst LN2_HI: f64 = 6.93147180369123816490e-01; /* 3fe62e42 fee00000 */\nconst LN2_LO: f64 = 1.90821492927058770002e-10; /* 3dea39ef 35793c76 */\nconst LG1: f64 = 6.666666666666735130e-01; /* 3FE55555 55555593 */\nconst LG2: f64 = 3.999999999940941908e-01; /* 3FD99999 9997FA04 */\nconst LG3: f64 = 2.857142874366239149e-01; /* 3FD24924 94229359 */\nconst LG4: f64 = 2.222219843214978396e-01; /* 3FCC71C5 1D8E78AF */\nconst LG5: f64 = 1.818357216161805012e-01; /* 3FC74664 96CB03DE */\nconst LG6: f64 = 1.531383769920937332e-01; /* 3FC39A09 D078C69F */\nconst LG7: f64 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */\n\n#[inline]\npub fn log(mut x: f64) -> f64 {\n    let x1p54 = f64::from_bits(0x4350000000000000); // 0x1p54 === 2 ^ 54\n\n    let mut ui = x.to_bits();\n    let mut hx: u32 = (ui >> 32) as u32;\n    let mut k: i32 = 0;\n\n    if (hx < 0x00100000) || ((hx >> 31) != 0) {\n        /* x < 2**-126  */\n        if ui << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if hx >> 31 != 0 {\n            return (x - x) / 0.0; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale x up */\n        k -= 54;\n        x *= x1p54;\n        ui = x.to_bits();\n        hx = (ui >> 32) as u32;\n    } else if hx >= 0x7ff00000 {\n        return x;\n    } else if hx == 0x3ff00000 && ui << 32 == 0 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    hx += 0x3ff00000 - 0x3fe6a09e;\n    k += ((hx >> 20) as i32) - 0x3ff;\n    hx = (hx & 0x000fffff) + 0x3fe6a09e;\n    ui = ((hx as u64) << 32) | (ui & 0xffffffff);\n    x = f64::from_bits(ui);\n\n    let f: f64 = x - 1.0;\n    let hfsq: f64 = 0.5 * f * f;\n    let s: f64 = f / (2.0 + f);\n    let z: f64 = s * s;\n    let w: f64 = z * z;\n    let t1: f64 = w * (LG2 + w * (LG4 + w * LG6));\n    let t2: f64 = z * (LG1 + w * (LG3 + w * (LG5 + w * LG7)));\n    let r: f64 = t2 + t1;\n    let dk: f64 = k as f64;\n    return s * (hfsq + r) + dk * LN2_LO - hfsq + f + dk * LN2_HI;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_logf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nconst LN2_HI: f32 = 6.9313812256e-01; /* 0x3f317180 */\nconst LN2_LO: f32 = 9.0580006145e-06; /* 0x3717f7d1 */\n/* |(log(1+s)-log(1-s))/s - Lg(s)| < 2**-34.24 (~[-4.95e-11, 4.97e-11]). */\nconst LG1: f32 = 0.66666662693; /*  0xaaaaaa.0p-24*/\nconst LG2: f32 = 0.40000972152; /*  0xccce13.0p-25 */\nconst LG3: f32 = 0.28498786688; /*  0x91e9ee.0p-25 */\nconst LG4: f32 = 0.24279078841; /*  0xf89e26.0p-26 */\n\n#[inline]\npub fn logf(mut x: f32) -> f32 {\n    let x1p25 = f32::from_bits(0x4c000000); // 0x1p25f === 2 ^ 25\n\n    let mut ix = x.to_bits();\n    let mut k = 0i32;\n\n    if (ix < 0x00800000) || ((ix >> 31) != 0) {\n        /* x < 2**-126  */\n        if ix << 1 == 0 {\n            return -1. / (x * x); /* log(+-0)=-inf */\n        }\n        if (ix >> 31) != 0 {\n            return (x - x) / 0.; /* log(-#) = NaN */\n        }\n        /* subnormal number, scale up x */\n        k -= 25;\n        x *= x1p25;\n        ix = x.to_bits();\n    } else if ix >= 0x7f800000 {\n        return x;\n    } else if ix == 0x3f800000 {\n        return 0.;\n    }\n\n    /* reduce x into [sqrt(2)/2, sqrt(2)] */\n    ix += 0x3f800000 - 0x3f3504f3;\n    k += ((ix >> 23) as i32) - 0x7f;\n    ix = (ix & 0x007fffff) + 0x3f3504f3;\n    x = f32::from_bits(ix);\n\n    let f = x - 1.;\n    let s = f / (2. + f);\n    let z = s * s;\n    let w = z * z;\n    let t1 = w * (LG2 + w * LG4);\n    let t2 = z * (LG1 + w * LG3);\n    let r = t2 + t1;\n    let hfsq = 0.5 * f * f;\n    let dk = k as f32;\n    s * (hfsq + r) + dk * LN2_LO - hfsq + f + dk * LN2_HI\n}\n","use core::f64;\n\nconst TOINT: f64 = 1.0 / f64::EPSILON;\n\n#[inline]\npub fn round(mut x: f64) -> f64 {\n    let (f, i) = (x, x.to_bits());\n    let e: u64 = i >> 52 & 0x7ff;\n    let mut y: f64;\n\n    if e >= 0x3ff + 52 {\n        return x;\n    }\n    if i >> 63 != 0 {\n        x = -x;\n    }\n    if e < 0x3ff - 1 {\n        // raise inexact if x!=0\n        force_eval!(x + TOINT);\n        return 0.0 * f;\n    }\n    y = x + TOINT - TOINT - x;\n    if y > 0.5 {\n        y = y + x - 1.0;\n    } else if y <= -0.5 {\n        y = y + x + 1.0;\n    } else {\n        y = y + x;\n    }\n\n    if i >> 63 != 0 {\n        -y\n    } else {\n        y\n    }\n}\n","use core::f32;\n\nconst TOINT: f32 = 1.0 / f32::EPSILON;\n\n#[inline]\npub fn roundf(mut x: f32) -> f32 {\n    let i = x.to_bits();\n    let e: u32 = i >> 23 & 0xff;\n    let mut y: f32;\n\n    if e >= 0x7f + 23 {\n        return x;\n    }\n    if i >> 31 != 0 {\n        x = -x;\n    }\n    if e < 0x7f - 1 {\n        force_eval!(x + TOINT);\n        return 0.0 * x;\n    }\n    y = x + TOINT - TOINT - x;\n    if y > 0.5f32 {\n        y = y + x - 1.0;\n    } else if y <= -0.5f32 {\n        y = y + x + 1.0;\n    } else {\n        y = y + x;\n    }\n    if i >> 31 != 0 {\n        -y\n    } else {\n        y\n    }\n}\n","// origin: FreeBSD /usr/src/lib/msun/src/s_sin.c */\n//\n// ====================================================\n// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n//\n// Developed at SunPro, a Sun Microsystems, Inc. business.\n// Permission to use, copy, modify, and distribute this\n// software is freely granted, provided that this notice\n// is preserved.\n// ====================================================\n\nuse super::{k_cos, k_sin, rem_pio2};\n\n// sin(x)\n// Return sine function of x.\n//\n// kernel function:\n//      k_sin            ... sine function on [-pi/4,pi/4]\n//      k_cos            ... cose function on [-pi/4,pi/4]\n//      rem_pio2         ... argument reduction routine\n//\n// Method.\n//      Let S,C and T denote the sin, cos and tan respectively on\n//      [-PI/4, +PI/4]. Reduce the argument x to y1+y2 = x-k*pi/2\n//      in [-pi/4 , +pi/4], and let n = k mod 4.\n//      We have\n//\n//          n        sin(x)      cos(x)        tan(x)\n//     ----------------------------------------------------------\n//          0          S           C             T\n//          1          C          -S            -1/T\n//          2         -S          -C             T\n//          3         -C           S            -1/T\n//     ----------------------------------------------------------\n//\n// Special cases:\n//      Let trig be any of sin, cos, or tan.\n//      trig(+-INF)  is NaN, with signals;\n//      trig(NaN)    is that NaN;\n//\n// Accuracy:\n//      TRIG(x) returns trig(x) nearly rounded\n#[inline]\npub fn sin(x: f64) -> f64 {\n    let x1p120 = f64::from_bits(0x4770000000000000); // 0x1p120f === 2 ^ 120\n\n    /* High word of x. */\n    let ix = (f64::to_bits(x) >> 32) as u32 & 0x7fffffff;\n\n    /* |x| ~< pi/4 */\n    if ix <= 0x3fe921fb {\n        if ix < 0x3e500000 {\n            /* |x| < 2**-26 */\n            /* raise inexact if x != 0 and underflow if subnormal*/\n            if ix < 0x00100000 {\n                force_eval!(x / x1p120);\n            } else {\n                force_eval!(x + x1p120);\n            }\n            return x;\n        }\n        return k_sin(x, 0.0, 0);\n    }\n\n    /* sin(Inf or NaN) is NaN */\n    if ix >= 0x7ff00000 {\n        return x - x;\n    }\n\n    /* argument reduction needed */\n    let (n, y0, y1) = rem_pio2(x);\n    match n & 3 {\n        0 => k_sin(y0, y1, 1),\n        1 => k_cos(y0, y1),\n        2 => -k_sin(y0, y1, 1),\n        _ => -k_cos(y0, y1),\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/s_sinf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n * Optimized by Bruce D. Evans.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nuse super::{k_cosf, k_sinf, rem_pio2f};\n\nuse core::f64::consts::FRAC_PI_2;\n\n/* Small multiples of pi/2 rounded to double precision. */\nconst S1_PIO2: f64 = 1. * FRAC_PI_2; /* 0x3FF921FB, 0x54442D18 */\nconst S2_PIO2: f64 = 2. * FRAC_PI_2; /* 0x400921FB, 0x54442D18 */\nconst S3_PIO2: f64 = 3. * FRAC_PI_2; /* 0x4012D97C, 0x7F3321D2 */\nconst S4_PIO2: f64 = 4. * FRAC_PI_2; /* 0x401921FB, 0x54442D18 */\n\n#[inline]\npub fn sinf(x: f32) -> f32 {\n    let x64 = x as f64;\n\n    let x1p120 = f32::from_bits(0x7b800000); // 0x1p120f === 2 ^ 120\n\n    let mut ix = x.to_bits();\n    let sign = (ix >> 31) != 0;\n    ix &= 0x7fffffff;\n\n    if ix <= 0x3f490fda {\n        /* |x| ~<= pi/4 */\n        if ix < 0x39800000 {\n            /* |x| < 2**-12 */\n            /* raise inexact if x!=0 and underflow if subnormal */\n            force_eval!(if ix < 0x00800000 {\n                x / x1p120\n            } else {\n                x + x1p120\n            });\n            return x;\n        }\n        return k_sinf(x64);\n    }\n    if ix <= 0x407b53d1 {\n        /* |x| ~<= 5*pi/4 */\n        if ix <= 0x4016cbe3 {\n            /* |x| ~<= 3pi/4 */\n            if sign {\n                return -k_cosf(x64 + S1_PIO2);\n            } else {\n                return k_cosf(x64 - S1_PIO2);\n            }\n        }\n        return k_sinf(if sign {\n            -(x64 + S2_PIO2)\n        } else {\n            -(x64 - S2_PIO2)\n        });\n    }\n    if ix <= 0x40e231d5 {\n        /* |x| ~<= 9*pi/4 */\n        if ix <= 0x40afeddf {\n            /* |x| ~<= 7*pi/4 */\n            if sign {\n                return k_cosf(x64 + S3_PIO2);\n            } else {\n                return -k_cosf(x64 - S3_PIO2);\n            }\n        }\n        return k_sinf(if sign { x64 + S4_PIO2 } else { x64 - S4_PIO2 });\n    }\n\n    /* sin(Inf or NaN) is NaN */\n    if ix >= 0x7f800000 {\n        return x - x;\n    }\n\n    /* general argument reduction needed */\n    let (n, y) = rem_pio2f(x);\n    match n & 3 {\n        0 => k_sinf(y),\n        1 => k_cosf(y),\n        2 => return k_sinf(-y),\n        _ => -k_cosf(y),\n    }\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_pow.c */\n/*\n * ====================================================\n * Copyright (C) 2004 by Sun Microsystems, Inc. All rights reserved.\n *\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\n// pow(x,y) return x**y\n//\n//                    n\n// Method:  Let x =  2   * (1+f)\n//      1. Compute and return log2(x) in two pieces:\n//              log2(x) = w1 + w2,\n//         where w1 has 53-24 = 29 bit trailing zeros.\n//      2. Perform y*log2(x) = n+y' by simulating muti-precision\n//         arithmetic, where |y'|<=0.5.\n//      3. Return x**y = 2**n*exp(y'*log2)\n//\n// Special cases:\n//      1.  (anything) ** 0  is 1\n//      2.  1 ** (anything)  is 1\n//      3.  (anything except 1) ** NAN is NAN\n//      4.  NAN ** (anything except 0) is NAN\n//      5.  +-(|x| > 1) **  +INF is +INF\n//      6.  +-(|x| > 1) **  -INF is +0\n//      7.  +-(|x| < 1) **  +INF is +0\n//      8.  +-(|x| < 1) **  -INF is +INF\n//      9.  -1          ** +-INF is 1\n//      10. +0 ** (+anything except 0, NAN)               is +0\n//      11. -0 ** (+anything except 0, NAN, odd integer)  is +0\n//      12. +0 ** (-anything except 0, NAN)               is +INF, raise divbyzero\n//      13. -0 ** (-anything except 0, NAN, odd integer)  is +INF, raise divbyzero\n//      14. -0 ** (+odd integer) is -0\n//      15. -0 ** (-odd integer) is -INF, raise divbyzero\n//      16. +INF ** (+anything except 0,NAN) is +INF\n//      17. +INF ** (-anything except 0,NAN) is +0\n//      18. -INF ** (+odd integer) is -INF\n//      19. -INF ** (anything) = -0 ** (-anything), (anything except odd integer)\n//      20. (anything) ** 1 is (anything)\n//      21. (anything) ** -1 is 1/(anything)\n//      22. (-anything) ** (integer) is (-1)**(integer)*(+anything**integer)\n//      23. (-anything except 0 and inf) ** (non-integer) is NAN\n//\n// Accuracy:\n//      pow(x,y) returns x**y nearly rounded. In particular\n//                      pow(integer,integer)\n//      always returns the correct integer provided it is\n//      representable.\n//\n// Constants :\n// The hexadecimal values are the intended ones for the following\n// constants. The decimal values may be used, provided that the\n// compiler will convert from decimal to binary accurately enough\n// to produce the hexadecimal values shown.\n//\nuse super::{fabs, get_high_word, scalbn, sqrt, with_set_high_word, with_set_low_word};\n\nconst BP: [f64; 2] = [1.0, 1.5];\nconst DP_H: [f64; 2] = [0.0, 5.84962487220764160156e-01]; /* 0x3fe2b803_40000000 */\nconst DP_L: [f64; 2] = [0.0, 1.35003920212974897128e-08]; /* 0x3E4CFDEB, 0x43CFD006 */\nconst TWO53: f64 = 9007199254740992.0; /* 0x43400000_00000000 */\nconst HUGE: f64 = 1.0e300;\nconst TINY: f64 = 1.0e-300;\n\n// poly coefs for (3/2)*(log(x)-2s-2/3*s**3:\nconst L1: f64 = 5.99999999999994648725e-01; /* 0x3fe33333_33333303 */\nconst L2: f64 = 4.28571428578550184252e-01; /* 0x3fdb6db6_db6fabff */\nconst L3: f64 = 3.33333329818377432918e-01; /* 0x3fd55555_518f264d */\nconst L4: f64 = 2.72728123808534006489e-01; /* 0x3fd17460_a91d4101 */\nconst L5: f64 = 2.30660745775561754067e-01; /* 0x3fcd864a_93c9db65 */\nconst L6: f64 = 2.06975017800338417784e-01; /* 0x3fca7e28_4a454eef */\nconst P1: f64 = 1.66666666666666019037e-01; /* 0x3fc55555_5555553e */\nconst P2: f64 = -2.77777777770155933842e-03; /* 0xbf66c16c_16bebd93 */\nconst P3: f64 = 6.61375632143793436117e-05; /* 0x3f11566a_af25de2c */\nconst P4: f64 = -1.65339022054652515390e-06; /* 0xbebbbd41_c5d26bf1 */\nconst P5: f64 = 4.13813679705723846039e-08; /* 0x3e663769_72bea4d0 */\nconst LG2: f64 = 6.93147180559945286227e-01; /* 0x3fe62e42_fefa39ef */\nconst LG2_H: f64 = 6.93147182464599609375e-01; /* 0x3fe62e43_00000000 */\nconst LG2_L: f64 = -1.90465429995776804525e-09; /* 0xbe205c61_0ca86c39 */\nconst OVT: f64 = 8.0085662595372944372e-017; /* -(1024-log2(ovfl+.5ulp)) */\nconst CP: f64 = 9.61796693925975554329e-01; /* 0x3feec709_dc3a03fd =2/(3ln2) */\nconst CP_H: f64 = 9.61796700954437255859e-01; /* 0x3feec709_e0000000 =(float)cp */\nconst CP_L: f64 = -7.02846165095275826516e-09; /* 0xbe3e2fe0_145b01f5 =tail of cp_h*/\nconst IVLN2: f64 = 1.44269504088896338700e+00; /* 0x3ff71547_652b82fe =1/ln2 */\nconst IVLN2_H: f64 = 1.44269502162933349609e+00; /* 0x3ff71547_60000000 =24b 1/ln2*/\nconst IVLN2_L: f64 = 1.92596299112661746887e-08; /* 0x3e54ae0b_f85ddf44 =1/ln2 tail*/\n\n#[inline]\npub fn pow(x: f64, y: f64) -> f64 {\n    let t1: f64;\n    let t2: f64;\n\n    let (hx, lx): (i32, u32) = ((x.to_bits() >> 32) as i32, x.to_bits() as u32);\n    let (hy, ly): (i32, u32) = ((y.to_bits() >> 32) as i32, y.to_bits() as u32);\n\n    let mut ix: i32 = (hx & 0x7fffffff) as i32;\n    let iy: i32 = (hy & 0x7fffffff) as i32;\n\n    /* x**0 = 1, even if x is NaN */\n    if ((iy as u32) | ly) == 0 {\n        return 1.0;\n    }\n\n    /* 1**y = 1, even if y is NaN */\n    if hx == 0x3ff00000 && lx == 0 {\n        return 1.0;\n    }\n\n    /* NaN if either arg is NaN */\n    if ix > 0x7ff00000\n        || (ix == 0x7ff00000 && lx != 0)\n        || iy > 0x7ff00000\n        || (iy == 0x7ff00000 && ly != 0)\n    {\n        return x + y;\n    }\n\n    /* determine if y is an odd int when x < 0\n     * yisint = 0       ... y is not an integer\n     * yisint = 1       ... y is an odd int\n     * yisint = 2       ... y is an even int\n     */\n    let mut yisint: i32 = 0;\n    let mut k: i32;\n    let mut j: i32;\n    if hx < 0 {\n        if iy >= 0x43400000 {\n            yisint = 2; /* even integer y */\n        } else if iy >= 0x3ff00000 {\n            k = (iy >> 20) - 0x3ff; /* exponent */\n\n            if k > 20 {\n                j = (ly >> (52 - k)) as i32;\n\n                if (j << (52 - k)) == (ly as i32) {\n                    yisint = 2 - (j & 1);\n                }\n            } else if ly == 0 {\n                j = iy >> (20 - k);\n\n                if (j << (20 - k)) == iy {\n                    yisint = 2 - (j & 1);\n                }\n            }\n        }\n    }\n\n    if ly == 0 {\n        /* special value of y */\n        if iy == 0x7ff00000 {\n            /* y is +-inf */\n\n            return if ((ix - 0x3ff00000) | (lx as i32)) == 0 {\n                /* (-1)**+-inf is 1 */\n                1.0\n            } else if ix >= 0x3ff00000 {\n                /* (|x|>1)**+-inf = inf,0 */\n                if hy >= 0 {\n                    y\n                } else {\n                    0.0\n                }\n            } else {\n                /* (|x|<1)**+-inf = 0,inf */\n                if hy >= 0 {\n                    0.0\n                } else {\n                    -y\n                }\n            };\n        }\n\n        if iy == 0x3ff00000 {\n            /* y is +-1 */\n            return if hy >= 0 { x } else { 1.0 / x };\n        }\n\n        if hy == 0x40000000 {\n            /* y is 2 */\n            return x * x;\n        }\n\n        if hy == 0x3fe00000 {\n            /* y is 0.5 */\n            if hx >= 0 {\n                /* x >= +0 */\n                return sqrt(x);\n            }\n        }\n    }\n\n    let mut ax: f64 = fabs(x);\n    if lx == 0 {\n        /* special value of x */\n        if ix == 0x7ff00000 || ix == 0 || ix == 0x3ff00000 {\n            /* x is +-0,+-inf,+-1 */\n            let mut z: f64 = ax;\n\n            if hy < 0 {\n                /* z = (1/|x|) */\n                z = 1.0 / z;\n            }\n\n            if hx < 0 {\n                if ((ix - 0x3ff00000) | yisint) == 0 {\n                    z = (z - z) / (z - z); /* (-1)**non-int is NaN */\n                } else if yisint == 1 {\n                    z = -z; /* (x<0)**odd = -(|x|**odd) */\n                }\n            }\n\n            return z;\n        }\n    }\n\n    let mut s: f64 = 1.0; /* sign of result */\n    if hx < 0 {\n        if yisint == 0 {\n            /* (x<0)**(non-int) is NaN */\n            return (x - x) / (x - x);\n        }\n\n        if yisint == 1 {\n            /* (x<0)**(odd int) */\n            s = -1.0;\n        }\n    }\n\n    /* |y| is HUGE */\n    if iy > 0x41e00000 {\n        /* if |y| > 2**31 */\n        if iy > 0x43f00000 {\n            /* if |y| > 2**64, must o/uflow */\n            if ix <= 0x3fefffff {\n                return if hy < 0 { HUGE * HUGE } else { TINY * TINY };\n            }\n\n            if ix >= 0x3ff00000 {\n                return if hy > 0 { HUGE * HUGE } else { TINY * TINY };\n            }\n        }\n\n        /* over/underflow if x is not close to one */\n        if ix < 0x3fefffff {\n            return if hy < 0 {\n                s * HUGE * HUGE\n            } else {\n                s * TINY * TINY\n            };\n        }\n        if ix > 0x3ff00000 {\n            return if hy > 0 {\n                s * HUGE * HUGE\n            } else {\n                s * TINY * TINY\n            };\n        }\n\n        /* now |1-x| is TINY <= 2**-20, suffice to compute\n           log(x) by x-x^2/2+x^3/3-x^4/4 */\n        let t: f64 = ax - 1.0; /* t has 20 trailing zeros */\n        let w: f64 = (t * t) * (0.5 - t * (0.3333333333333333333333 - t * 0.25));\n        let u: f64 = IVLN2_H * t; /* ivln2_h has 21 sig. bits */\n        let v: f64 = t * IVLN2_L - w * IVLN2;\n        t1 = with_set_low_word(u + v, 0);\n        t2 = v - (t1 - u);\n    } else {\n        // double ss,s2,s_h,s_l,t_h,t_l;\n        let mut n: i32 = 0;\n\n        if ix < 0x00100000 {\n            /* take care subnormal number */\n            ax *= TWO53;\n            n -= 53;\n            ix = get_high_word(ax) as i32;\n        }\n\n        n += (ix >> 20) - 0x3ff;\n        j = ix & 0x000fffff;\n\n        /* determine interval */\n        let k: i32;\n        ix = j | 0x3ff00000; /* normalize ix */\n        if j <= 0x3988E {\n            /* |x|<sqrt(3/2) */\n            k = 0;\n        } else if j < 0xBB67A {\n            /* |x|<sqrt(3)   */\n            k = 1;\n        } else {\n            k = 0;\n            n += 1;\n            ix -= 0x00100000;\n        }\n        ax = with_set_high_word(ax, ix as u32);\n\n        /* compute ss = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */\n        let u: f64 = ax - BP[k as usize]; /* bp[0]=1.0, bp[1]=1.5 */\n        let v: f64 = 1.0 / (ax + BP[k as usize]);\n        let ss: f64 = u * v;\n        let s_h = with_set_low_word(ss, 0);\n\n        /* t_h=ax+bp[k] High */\n        let t_h: f64 = with_set_high_word(\n            0.0,\n            ((ix as u32 >> 1) | 0x20000000) + 0x00080000 + ((k as u32) << 18),\n        );\n        let t_l: f64 = ax - (t_h - BP[k as usize]);\n        let s_l: f64 = v * ((u - s_h * t_h) - s_h * t_l);\n\n        /* compute log(ax) */\n        let s2: f64 = ss * ss;\n        let mut r: f64 = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + ss);\n        let s2: f64 = s_h * s_h;\n        let t_h: f64 = with_set_low_word(3.0 + s2 + r, 0);\n        let t_l: f64 = r - ((t_h - 3.0) - s2);\n\n        /* u+v = ss*(1+...) */\n        let u: f64 = s_h * t_h;\n        let v: f64 = s_l * t_h + t_l * ss;\n\n        /* 2/(3log2)*(ss+...) */\n        let p_h: f64 = with_set_low_word(u + v, 0);\n        let p_l = v - (p_h - u);\n        let z_h: f64 = CP_H * p_h; /* cp_h+cp_l = 2/(3*log2) */\n        let z_l: f64 = CP_L * p_h + p_l * CP + DP_L[k as usize];\n\n        /* log2(ax) = (ss+..)*2/(3*log2) = n + dp_h + z_h + z_l */\n        let t: f64 = n as f64;\n        t1 = with_set_low_word(((z_h + z_l) + DP_H[k as usize]) + t, 0);\n        t2 = z_l - (((t1 - t) - DP_H[k as usize]) - z_h);\n    }\n\n    /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */\n    let y1: f64 = with_set_low_word(y, 0);\n    let p_l: f64 = (y - y1) * t1 + y * t2;\n    let mut p_h: f64 = y1 * t1;\n    let z: f64 = p_l + p_h;\n    let mut j: i32 = (z.to_bits() >> 32) as i32;\n    let i: i32 = z.to_bits() as i32;\n    // let (j, i): (i32, i32) = ((z.to_bits() >> 32) as i32, z.to_bits() as i32);\n\n    if j >= 0x40900000 {\n        /* z >= 1024 */\n        if (j - 0x40900000) | i != 0 {\n            /* if z > 1024 */\n            return s * HUGE * HUGE; /* overflow */\n        }\n\n        if p_l + OVT > z - p_h {\n            return s * HUGE * HUGE; /* overflow */\n        }\n    } else if (j & 0x7fffffff) >= 0x4090cc00 {\n        /* z <= -1075 */\n        // FIXME: instead of abs(j) use unsigned j\n\n        if (((j as u32) - 0xc090cc00) | (i as u32)) != 0 {\n            /* z < -1075 */\n            return s * TINY * TINY; /* underflow */\n        }\n\n        if p_l <= z - p_h {\n            return s * TINY * TINY; /* underflow */\n        }\n    }\n\n    /* compute 2**(p_h+p_l) */\n    let i: i32 = j & (0x7fffffff as i32);\n    k = (i >> 20) - 0x3ff;\n    let mut n: i32 = 0;\n\n    if i > 0x3fe00000 {\n        /* if |z| > 0.5, set n = [z+0.5] */\n        n = j + (0x00100000 >> (k + 1));\n        k = ((n & 0x7fffffff) >> 20) - 0x3ff; /* new k for n */\n        let t: f64 = with_set_high_word(0.0, (n & !(0x000fffff >> k)) as u32);\n        n = ((n & 0x000fffff) | 0x00100000) >> (20 - k);\n        if j < 0 {\n            n = -n;\n        }\n        p_h -= t;\n    }\n\n    let t: f64 = with_set_low_word(p_l + p_h, 0);\n    let u: f64 = t * LG2_H;\n    let v: f64 = (p_l - (t - p_h)) * LG2 + t * LG2_L;\n    let mut z: f64 = u + v;\n    let w: f64 = v - (z - u);\n    let t: f64 = z * z;\n    let t1: f64 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n    let r: f64 = (z * t1) / (t1 - 2.0) - (w + z * w);\n    z = 1.0 - (r - z);\n    j = get_high_word(z) as i32;\n    j += n << 20;\n\n    if (j >> 20) <= 0 {\n        /* subnormal output */\n        z = scalbn(z, n);\n    } else {\n        z = with_set_high_word(z, j as u32);\n    }\n\n    return s * z;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_powf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nuse super::{fabsf, scalbnf, sqrtf};\n\nconst BP: [f32; 2] = [1.0, 1.5];\nconst DP_H: [f32; 2] = [0.0, 5.84960938e-01]; /* 0x3f15c000 */\nconst DP_L: [f32; 2] = [0.0, 1.56322085e-06]; /* 0x35d1cfdc */\nconst TWO24: f32 = 16777216.0; /* 0x4b800000 */\nconst HUGE: f32 = 1.0e30;\nconst TINY: f32 = 1.0e-30;\nconst L1: f32 = 6.0000002384e-01; /* 0x3f19999a */\nconst L2: f32 = 4.2857143283e-01; /* 0x3edb6db7 */\nconst L3: f32 = 3.3333334327e-01; /* 0x3eaaaaab */\nconst L4: f32 = 2.7272811532e-01; /* 0x3e8ba305 */\nconst L5: f32 = 2.3066075146e-01; /* 0x3e6c3255 */\nconst L6: f32 = 2.0697501302e-01; /* 0x3e53f142 */\nconst P1: f32 = 1.6666667163e-01; /* 0x3e2aaaab */\nconst P2: f32 = -2.7777778450e-03; /* 0xbb360b61 */\nconst P3: f32 = 6.6137559770e-05; /* 0x388ab355 */\nconst P4: f32 = -1.6533901999e-06; /* 0xb5ddea0e */\nconst P5: f32 = 4.1381369442e-08; /* 0x3331bb4c */\nconst LG2: f32 = 6.9314718246e-01; /* 0x3f317218 */\nconst LG2_H: f32 = 6.93145752e-01; /* 0x3f317200 */\nconst LG2_L: f32 = 1.42860654e-06; /* 0x35bfbe8c */\nconst OVT: f32 = 4.2995665694e-08; /* -(128-log2(ovfl+.5ulp)) */\nconst CP: f32 = 9.6179670095e-01; /* 0x3f76384f =2/(3ln2) */\nconst CP_H: f32 = 9.6191406250e-01; /* 0x3f764000 =12b cp */\nconst CP_L: f32 = -1.1736857402e-04; /* 0xb8f623c6 =tail of cp_h */\nconst IVLN2: f32 = 1.4426950216e+00;\nconst IVLN2_H: f32 = 1.4426879883e+00;\nconst IVLN2_L: f32 = 7.0526075433e-06;\n\n#[inline]\npub fn powf(x: f32, y: f32) -> f32 {\n    let mut z: f32;\n    let mut ax: f32;\n    let z_h: f32;\n    let z_l: f32;\n    let mut p_h: f32;\n    let mut p_l: f32;\n    let y1: f32;\n    let mut t1: f32;\n    let t2: f32;\n    let mut r: f32;\n    let s: f32;\n    let mut sn: f32;\n    let mut t: f32;\n    let mut u: f32;\n    let mut v: f32;\n    let mut w: f32;\n    let i: i32;\n    let mut j: i32;\n    let mut k: i32;\n    let mut yisint: i32;\n    let mut n: i32;\n    let hx: i32;\n    let hy: i32;\n    let mut ix: i32;\n    let iy: i32;\n    let mut is: i32;\n\n    hx = x.to_bits() as i32;\n    hy = y.to_bits() as i32;\n\n    ix = hx & 0x7fffffff;\n    iy = hy & 0x7fffffff;\n\n    /* x**0 = 1, even if x is NaN */\n    if iy == 0 {\n        return 1.0;\n    }\n\n    /* 1**y = 1, even if y is NaN */\n    if hx == 0x3f800000 {\n        return 1.0;\n    }\n\n    /* NaN if either arg is NaN */\n    if ix > 0x7f800000 || iy > 0x7f800000 {\n        return x + y;\n    }\n\n    /* determine if y is an odd int when x < 0\n     * yisint = 0       ... y is not an integer\n     * yisint = 1       ... y is an odd int\n     * yisint = 2       ... y is an even int\n     */\n    yisint = 0;\n    if hx < 0 {\n        if iy >= 0x4b800000 {\n            yisint = 2; /* even integer y */\n        } else if iy >= 0x3f800000 {\n            k = (iy >> 23) - 0x7f; /* exponent */\n            j = iy >> (23 - k);\n            if (j << (23 - k)) == iy {\n                yisint = 2 - (j & 1);\n            }\n        }\n    }\n\n    /* special value of y */\n    if iy == 0x7f800000 {\n        /* y is +-inf */\n        if ix == 0x3f800000 {\n            /* (-1)**+-inf is 1 */\n            return 1.0;\n        } else if ix > 0x3f800000 {\n            /* (|x|>1)**+-inf = inf,0 */\n            return if hy >= 0 { y } else { 0.0 };\n        } else {\n            /* (|x|<1)**+-inf = 0,inf */\n            return if hy >= 0 { 0.0 } else { -y };\n        }\n    }\n    if iy == 0x3f800000 {\n        /* y is +-1 */\n        return if hy >= 0 { x } else { 1.0 / x };\n    }\n\n    if hy == 0x40000000 {\n        /* y is 2 */\n        return x * x;\n    }\n\n    if hy == 0x3f000000 {\n        /* y is  0.5 */\n        if hx >= 0 {\n            /* x >= +0 */\n            return sqrtf(x);\n        }\n    }\n\n    ax = fabsf(x);\n    /* special value of x */\n    if ix == 0x7f800000 || ix == 0 || ix == 0x3f800000 {\n        /* x is +-0,+-inf,+-1 */\n        z = ax;\n        if hy < 0 {\n            /* z = (1/|x|) */\n            z = 1.0 / z;\n        }\n\n        if hx < 0 {\n            if ((ix - 0x3f800000) | yisint) == 0 {\n                z = (z - z) / (z - z); /* (-1)**non-int is NaN */\n            } else if yisint == 1 {\n                z = -z; /* (x<0)**odd = -(|x|**odd) */\n            }\n        }\n        return z;\n    }\n\n    sn = 1.0; /* sign of result */\n    if hx < 0 {\n        if yisint == 0 {\n            /* (x<0)**(non-int) is NaN */\n            return (x - x) / (x - x);\n        }\n\n        if yisint == 1 {\n            /* (x<0)**(odd int) */\n            sn = -1.0;\n        }\n    }\n\n    /* |y| is HUGE */\n    if iy > 0x4d000000 {\n        /* if |y| > 2**27 */\n        /* over/underflow if x is not close to one */\n        if ix < 0x3f7ffff8 {\n            return if hy < 0 {\n                sn * HUGE * HUGE\n            } else {\n                sn * TINY * TINY\n            };\n        }\n\n        if ix > 0x3f800007 {\n            return if hy > 0 {\n                sn * HUGE * HUGE\n            } else {\n                sn * TINY * TINY\n            };\n        }\n\n        /* now |1-x| is TINY <= 2**-20, suffice to compute\n       log(x) by x-x^2/2+x^3/3-x^4/4 */\n        t = ax - 1.; /* t has 20 trailing zeros */\n        w = (t * t) * (0.5 - t * (0.333333333333 - t * 0.25));\n        u = IVLN2_H * t; /* IVLN2_H has 16 sig. bits */\n        v = t * IVLN2_L - w * IVLN2;\n        t1 = u + v;\n        is = t1.to_bits() as i32;\n        t1 = f32::from_bits(is as u32 & 0xfffff000);\n        t2 = v - (t1 - u);\n    } else {\n        let mut s2: f32;\n        let mut s_h: f32;\n        let s_l: f32;\n        let mut t_h: f32;\n        let mut t_l: f32;\n\n        n = 0;\n        /* take care subnormal number */\n        if ix < 0x00800000 {\n            ax *= TWO24;\n            n -= 24;\n            ix = ax.to_bits() as i32;\n        }\n        n += ((ix) >> 23) - 0x7f;\n        j = ix & 0x007fffff;\n        /* determine interval */\n        ix = j | 0x3f800000; /* normalize ix */\n        if j <= 0x1cc471 {\n            /* |x|<sqrt(3/2) */\n            k = 0;\n        } else if j < 0x5db3d7 {\n            /* |x|<sqrt(3)   */\n            k = 1;\n        } else {\n            k = 0;\n            n += 1;\n            ix -= 0x00800000;\n        }\n        ax = f32::from_bits(ix as u32);\n\n        /* compute s = s_h+s_l = (x-1)/(x+1) or (x-1.5)/(x+1.5) */\n        u = ax - BP[k as usize]; /* bp[0]=1.0, bp[1]=1.5 */\n        v = 1.0 / (ax + BP[k as usize]);\n        s = u * v;\n        s_h = s;\n        is = s_h.to_bits() as i32;\n        s_h = f32::from_bits(is as u32 & 0xfffff000);\n        /* t_h=ax+bp[k] High */\n        is = (((ix as u32 >> 1) & 0xfffff000) | 0x20000000) as i32;\n        t_h = f32::from_bits(is as u32 + 0x00400000 + ((k as u32) << 21));\n        t_l = ax - (t_h - BP[k as usize]);\n        s_l = v * ((u - s_h * t_h) - s_h * t_l);\n        /* compute log(ax) */\n        s2 = s * s;\n        r = s2 * s2 * (L1 + s2 * (L2 + s2 * (L3 + s2 * (L4 + s2 * (L5 + s2 * L6)))));\n        r += s_l * (s_h + s);\n        s2 = s_h * s_h;\n        t_h = 3.0 + s2 + r;\n        is = t_h.to_bits() as i32;\n        t_h = f32::from_bits(is as u32 & 0xfffff000);\n        t_l = r - ((t_h - 3.0) - s2);\n        /* u+v = s*(1+...) */\n        u = s_h * t_h;\n        v = s_l * t_h + t_l * s;\n        /* 2/(3log2)*(s+...) */\n        p_h = u + v;\n        is = p_h.to_bits() as i32;\n        p_h = f32::from_bits(is as u32 & 0xfffff000);\n        p_l = v - (p_h - u);\n        z_h = CP_H * p_h; /* cp_h+cp_l = 2/(3*log2) */\n        z_l = CP_L * p_h + p_l * CP + DP_L[k as usize];\n        /* log2(ax) = (s+..)*2/(3*log2) = n + dp_h + z_h + z_l */\n        t = n as f32;\n        t1 = ((z_h + z_l) + DP_H[k as usize]) + t;\n        is = t1.to_bits() as i32;\n        t1 = f32::from_bits(is as u32 & 0xfffff000);\n        t2 = z_l - (((t1 - t) - DP_H[k as usize]) - z_h);\n    };\n\n    /* split up y into y1+y2 and compute (y1+y2)*(t1+t2) */\n    is = y.to_bits() as i32;\n    y1 = f32::from_bits(is as u32 & 0xfffff000);\n    p_l = (y - y1) * t1 + y * t2;\n    p_h = y1 * t1;\n    z = p_l + p_h;\n    j = z.to_bits() as i32;\n    if j > 0x43000000 {\n        /* if z > 128 */\n        return sn * HUGE * HUGE; /* overflow */\n    } else if j == 0x43000000 {\n        /* if z == 128 */\n        if p_l + OVT > z - p_h {\n            return sn * HUGE * HUGE; /* overflow */\n        }\n    } else if (j & 0x7fffffff) > 0x43160000 {\n        /* z < -150 */\n        // FIXME: check should be  (uint32_t)j > 0xc3160000\n        return sn * TINY * TINY; /* underflow */\n    } else if j as u32 == 0xc3160000 {\n        /* z == -150 */\n        if p_l <= z - p_h {\n            return sn * TINY * TINY; /* underflow */\n        }\n    }\n\n    /*\n     * compute 2**(p_h+p_l)\n     */\n    i = j & 0x7fffffff;\n    k = (i >> 23) - 0x7f;\n    n = 0;\n    if i > 0x3f000000 {\n        /* if |z| > 0.5, set n = [z+0.5] */\n        n = j + (0x00800000 >> (k + 1));\n        k = ((n & 0x7fffffff) >> 23) - 0x7f; /* new k for n */\n        t = f32::from_bits(n as u32 & !(0x007fffff >> k));\n        n = ((n & 0x007fffff) | 0x00800000) >> (23 - k);\n        if j < 0 {\n            n = -n;\n        }\n        p_h -= t;\n    }\n    t = p_l + p_h;\n    is = t.to_bits() as i32;\n    t = f32::from_bits(is as u32 & 0xffff8000);\n    u = t * LG2_H;\n    v = (p_l - (t - p_h)) * LG2 + t * LG2_L;\n    z = u + v;\n    w = v - (z - u);\n    t = z * z;\n    t1 = z - t * (P1 + t * (P2 + t * (P3 + t * (P4 + t * P5))));\n    r = (z * t1) / (t1 - 2.0) - (w + z * w);\n    z = 1.0 - (r - z);\n    j = z.to_bits() as i32;\n    j += n << 23;\n    if (j >> 23) <= 0 {\n        /* subnormal output */\n        z = scalbnf(z, n);\n    } else {\n        z = f32::from_bits(j as u32);\n    }\n    return sn * z;\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/e_sqrtf.c */\n/*\n * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.\n */\n/*\n * ====================================================\n * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.\n *\n * Developed at SunPro, a Sun Microsystems, Inc. business.\n * Permission to use, copy, modify, and distribute this\n * software is freely granted, provided that this notice\n * is preserved.\n * ====================================================\n */\n\nconst TINY: f32 = 1.0e-30;\n\n#[inline]\npub fn sqrtf(x: f32) -> f32 {\n    // On wasm32 we know that LLVM's intrinsic will compile to an optimized\n    // `f32.sqrt` native instruction, so we can leverage this for both code size\n    // and speed.\n    llvm_intrinsically_optimized! {\n        #[cfg(target_arch = \"wasm32\")] {\n            return if x < 0.0 {\n                ::core::f32::NAN\n            } else {\n                unsafe { ::core::intrinsics::sqrtf32(x) }\n            }\n        }\n    }\n    let mut z: f32;\n    let sign: i32 = 0x80000000u32 as i32;\n    let mut ix: i32;\n    let mut s: i32;\n    let mut q: i32;\n    let mut m: i32;\n    let mut t: i32;\n    let mut i: i32;\n    let mut r: u32;\n\n    ix = x.to_bits() as i32;\n\n    /* take care of Inf and NaN */\n    if (ix as u32 & 0x7f800000) == 0x7f800000 {\n        return x * x + x; /* sqrt(NaN)=NaN, sqrt(+inf)=+inf, sqrt(-inf)=sNaN */\n    }\n\n    /* take care of zero */\n    if ix <= 0 {\n        if (ix & !sign) == 0 {\n            return x; /* sqrt(+-0) = +-0 */\n        }\n        if ix < 0 {\n            return (x - x) / (x - x); /* sqrt(-ve) = sNaN */\n        }\n    }\n\n    /* normalize x */\n    m = ix >> 23;\n    if m == 0 {\n        /* subnormal x */\n        i = 0;\n        while ix & 0x00800000 == 0 {\n            ix <<= 1;\n            i = i + 1;\n        }\n        m -= i - 1;\n    }\n    m -= 127; /* unbias exponent */\n    ix = (ix & 0x007fffff) | 0x00800000;\n    if m & 1 == 1 {\n        /* odd m, double x to make it even */\n        ix += ix;\n    }\n    m >>= 1; /* m = [m/2] */\n\n    /* generate sqrt(x) bit by bit */\n    ix += ix;\n    q = 0;\n    s = 0;\n    r = 0x01000000; /* r = moving bit from right to left */\n\n    while r != 0 {\n        t = s + r as i32;\n        if t <= ix {\n            s = t + r as i32;\n            ix -= t;\n            q += r as i32;\n        }\n        ix += ix;\n        r >>= 1;\n    }\n\n    /* use floating add to find out rounding direction */\n    if ix != 0 {\n        z = 1.0 - TINY; /* raise inexact flag */\n        if z >= 1.0 {\n            z = 1.0 + TINY;\n            if z > 1.0 {\n                q += 2;\n            } else {\n                q += q & 1;\n            }\n        }\n    }\n\n    ix = (q >> 1) + 0x3f000000;\n    ix += m << 23;\n    f32::from_bits(ix as u32)\n}\n","#[inline]\npub fn fabsf(x: f32) -> f32 {\n    // On wasm32 we know that LLVM's intrinsic will compile to an optimized\n    // `f32.abs` native instruction, so we can leverage this for both code size\n    // and speed.\n    llvm_intrinsically_optimized! {\n        #[cfg(target_arch = \"wasm32\")] {\n            return unsafe { ::core::intrinsics::fabsf32(x) }\n        }\n    }\n    f32::from_bits(x.to_bits() & 0x7fffffff)\n}\n","use core::u64;\n\n#[inline]\npub fn fmod(x: f64, y: f64) -> f64 {\n    let mut uxi = x.to_bits();\n    let mut uyi = y.to_bits();\n    let mut ex = (uxi >> 52 & 0x7ff) as i64;\n    let mut ey = (uyi >> 52 & 0x7ff) as i64;\n    let sx = uxi >> 63;\n    let mut i;\n\n    if uyi << 1 == 0 || y.is_nan() || ex == 0x7ff {\n        return (x * y) / (x * y);\n    }\n    if uxi << 1 <= uyi << 1 {\n        if uxi << 1 == uyi << 1 {\n            return 0.0 * x;\n        }\n        return x;\n    }\n\n    /* normalize x and y */\n    if ex == 0 {\n        i = uxi << 12;\n        while i >> 63 == 0 {\n            ex -= 1;\n            i <<= 1;\n        }\n        uxi <<= -ex + 1;\n    } else {\n        uxi &= u64::MAX >> 12;\n        uxi |= 1 << 52;\n    }\n    if ey == 0 {\n        i = uyi << 12;\n        while i >> 63 == 0 {\n            ey -= 1;\n            i <<= 1;\n        }\n        uyi <<= -ey + 1;\n    } else {\n        uyi &= u64::MAX >> 12;\n        uyi |= 1 << 52;\n    }\n\n    /* x mod y */\n    while ex > ey {\n        i = uxi - uyi;\n        if i >> 63 == 0 {\n            if i == 0 {\n                return 0.0 * x;\n            }\n            uxi = i;\n        }\n        uxi <<= 1;\n        ex -= 1;\n    }\n    i = uxi - uyi;\n    if i >> 63 == 0 {\n        if i == 0 {\n            return 0.0 * x;\n        }\n        uxi = i;\n    }\n    while uxi >> 52 == 0 {\n        uxi <<= 1;\n        ex -= 1;\n    }\n\n    /* scale result */\n    if ex > 0 {\n        uxi -= 1 << 52;\n        uxi |= (ex as u64) << 52;\n    } else {\n        uxi >>= -ex + 1;\n    }\n    uxi |= (sx as u64) << 63;\n\n    f64::from_bits(uxi)\n}\n","use core::f32;\nuse core::u32;\n\n#[inline]\npub fn fmodf(x: f32, y: f32) -> f32 {\n    let mut uxi = x.to_bits();\n    let mut uyi = y.to_bits();\n    let mut ex = (uxi >> 23 & 0xff) as i32;\n    let mut ey = (uyi >> 23 & 0xff) as i32;\n    let sx = uxi & 0x80000000;\n    let mut i;\n\n    if uyi << 1 == 0 || y.is_nan() || ex == 0xff {\n        return (x * y) / (x * y);\n    }\n\n    if uxi << 1 <= uyi << 1 {\n        if uxi << 1 == uyi << 1 {\n            return 0.0 * x;\n        }\n\n        return x;\n    }\n\n    /* normalize x and y */\n    if ex == 0 {\n        i = uxi << 9;\n        while i >> 31 == 0 {\n            ex -= 1;\n            i <<= 1;\n        }\n\n        uxi <<= -ex + 1;\n    } else {\n        uxi &= u32::MAX >> 9;\n        uxi |= 1 << 23;\n    }\n\n    if ey == 0 {\n        i = uyi << 9;\n        while i >> 31 == 0 {\n            ey -= 1;\n            i <<= 1;\n        }\n\n        uyi <<= -ey + 1;\n    } else {\n        uyi &= u32::MAX >> 9;\n        uyi |= 1 << 23;\n    }\n\n    /* x mod y */\n    while ex > ey {\n        i = uxi - uyi;\n        if i >> 31 == 0 {\n            if i == 0 {\n                return 0.0 * x;\n            }\n            uxi = i;\n        }\n        uxi <<= 1;\n\n        ex -= 1;\n    }\n\n    i = uxi - uyi;\n    if i >> 31 == 0 {\n        if i == 0 {\n            return 0.0 * x;\n        }\n        uxi = i;\n    }\n\n    while uxi >> 23 == 0 {\n        uxi <<= 1;\n        ex -= 1;\n    }\n\n    /* scale result up */\n    if ex > 0 {\n        uxi -= 1 << 23;\n        uxi |= (ex as u32) << 23;\n    } else {\n        uxi >>= -ex + 1;\n    }\n    uxi |= sx;\n\n    f32::from_bits(uxi)\n}\n","use core::{f32, f64};\n\nuse super::scalbn;\n\nconst ZEROINFNAN: i32 = 0x7ff - 0x3ff - 52 - 1;\n\nstruct Num {\n    m: u64,\n    e: i32,\n    sign: i32,\n}\n\n#[inline]\nfn normalize(x: f64) -> Num {\n    let x1p63: f64 = f64::from_bits(0x43e0000000000000); // 0x1p63 === 2 ^ 63\n\n    let mut ix: u64 = x.to_bits();\n    let mut e: i32 = (ix >> 52) as i32;\n    let sign: i32 = e & 0x800;\n    e &= 0x7ff;\n    if e == 0 {\n        ix = (x * x1p63).to_bits();\n        e = (ix >> 52) as i32 & 0x7ff;\n        e = if e != 0 { e - 63 } else { 0x800 };\n    }\n    ix &= (1 << 52) - 1;\n    ix |= 1 << 52;\n    ix <<= 1;\n    e -= 0x3ff + 52 + 1;\n    Num { m: ix, e, sign }\n}\n\n#[inline]\nfn mul(x: u64, y: u64) -> (u64, u64) {\n    let t1: u64;\n    let t2: u64;\n    let t3: u64;\n    let xlo: u64 = x as u32 as u64;\n    let xhi: u64 = x >> 32;\n    let ylo: u64 = y as u32 as u64;\n    let yhi: u64 = y >> 32;\n\n    t1 = xlo * ylo;\n    t2 = xlo * yhi + xhi * ylo;\n    t3 = xhi * yhi;\n    let lo = t1 + (t2 << 32);\n    let hi = t3 + (t2 >> 32) + (t1 > lo) as u64;\n    (hi, lo)\n}\n\n#[inline]\npub fn fma(x: f64, y: f64, z: f64) -> f64 {\n    let x1p63: f64 = f64::from_bits(0x43e0000000000000); // 0x1p63 === 2 ^ 63\n    let x0_ffffff8p_63 = f64::from_bits(0x3bfffffff0000000); // 0x0.ffffff8p-63\n\n    /* normalize so top 10bits and last bit are 0 */\n    let nx = normalize(x);\n    let ny = normalize(y);\n    let nz = normalize(z);\n\n    if nx.e >= ZEROINFNAN || ny.e >= ZEROINFNAN {\n        return x * y + z;\n    }\n    if nz.e >= ZEROINFNAN {\n        if nz.e > ZEROINFNAN {\n            /* z==0 */\n            return x * y + z;\n        }\n        return z;\n    }\n\n    /* mul: r = x*y */\n    let zhi: u64;\n    let zlo: u64;\n    let (mut rhi, mut rlo) = mul(nx.m, ny.m);\n    /* either top 20 or 21 bits of rhi and last 2 bits of rlo are 0 */\n\n    /* align exponents */\n    let mut e: i32 = nx.e + ny.e;\n    let mut d: i32 = nz.e - e;\n    /* shift bits z<<=kz, r>>=kr, so kz+kr == d, set e = e+kr (== ez-kz) */\n    if d > 0 {\n        if d < 64 {\n            zlo = nz.m << d;\n            zhi = nz.m >> 64 - d;\n        } else {\n            zlo = 0;\n            zhi = nz.m;\n            e = nz.e - 64;\n            d -= 64;\n            if d == 0 {\n            } else if d < 64 {\n                rlo = rhi << 64 - d | rlo >> d | ((rlo << 64 - d) != 0) as u64;\n                rhi = rhi >> d;\n            } else {\n                rlo = 1;\n                rhi = 0;\n            }\n        }\n    } else {\n        zhi = 0;\n        d = -d;\n        if d == 0 {\n            zlo = nz.m;\n        } else if d < 64 {\n            zlo = nz.m >> d | ((nz.m << 64 - d) != 0) as u64;\n        } else {\n            zlo = 1;\n        }\n    }\n\n    /* add */\n    let mut sign: i32 = nx.sign ^ ny.sign;\n    let samesign: bool = (sign ^ nz.sign) == 0;\n    let mut nonzero: i32 = 1;\n    if samesign {\n        /* r += z */\n        rlo += zlo;\n        rhi += zhi + (rlo < zlo) as u64;\n    } else {\n        /* r -= z */\n        let t = rlo;\n        rlo -= zlo;\n        rhi = rhi - zhi - (t < rlo) as u64;\n        if (rhi >> 63) != 0 {\n            rlo = (-(rlo as i64)) as u64;\n            rhi = (-(rhi as i64)) as u64 - (rlo != 0) as u64;\n            sign = (sign == 0) as i32;\n        }\n        nonzero = (rhi != 0) as i32;\n    }\n\n    /* set rhi to top 63bit of the result (last bit is sticky) */\n    if nonzero != 0 {\n        e += 64;\n        d = rhi.leading_zeros() as i32 - 1;\n        /* note: d > 0 */\n        rhi = rhi << d | rlo >> 64 - d | ((rlo << d) != 0) as u64;\n    } else if rlo != 0 {\n        d = rlo.leading_zeros() as i32 - 1;\n        if d < 0 {\n            rhi = rlo >> 1 | (rlo & 1);\n        } else {\n            rhi = rlo << d;\n        }\n    } else {\n        /* exact +-0 */\n        return x * y + z;\n    }\n    e -= d;\n\n    /* convert to double */\n    let mut i: i64 = rhi as i64; /* i is in [1<<62,(1<<63)-1] */\n    if sign != 0 {\n        i = -i;\n    }\n    let mut r: f64 = i as f64; /* |r| is in [0x1p62,0x1p63] */\n\n    if e < -1022 - 62 {\n        /* result is subnormal before rounding */\n        if e == -1022 - 63 {\n            let mut c: f64 = x1p63;\n            if sign != 0 {\n                c = -c;\n            }\n            if r == c {\n                /* min normal after rounding, underflow depends\n                   on arch behaviour which can be imitated by\n                   a double to float conversion */\n                let fltmin: f32 = (x0_ffffff8p_63 * f32::MIN_POSITIVE as f64 * r) as f32;\n                return f64::MIN_POSITIVE / f32::MIN_POSITIVE as f64 * fltmin as f64;\n            }\n            /* one bit is lost when scaled, add another top bit to\n               only round once at conversion if it is inexact */\n            if (rhi << 53) != 0 {\n                i = (rhi >> 1 | (rhi & 1) | 1 << 62) as i64;\n                if sign != 0 {\n                    i = -i;\n                }\n                r = i as f64;\n                r = 2. * r - c; /* remove top bit */\n\n                /* raise underflow portably, such that it\n                   cannot be optimized away */\n                {\n                    let tiny: f64 = f64::MIN_POSITIVE / f32::MIN_POSITIVE as f64 * r;\n                    r += (tiny * tiny) * (r - r);\n                }\n            }\n        } else {\n            /* only round once when scaled */\n            d = 10;\n            i = ((rhi >> d | ((rhi << 64 - d) != 0) as u64) << d) as i64;\n            if sign != 0 {\n                i = -i;\n            }\n            r = i as f64;\n        }\n    }\n    scalbn(r, e)\n}\n","/* origin: FreeBSD /usr/src/lib/msun/src/s_fmaf.c */\n/*-\n * Copyright (c) 2005-2011 David Schultz <das@FreeBSD.ORG>\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\n * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\n * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\n * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\n * SUCH DAMAGE.\n */\n\nuse core::f32;\nuse core::ptr::read_volatile;\n\nuse super::fenv::{\n    feclearexcept, fegetround, feraiseexcept, fesetround, fetestexcept, FE_INEXACT, FE_TONEAREST,\n    FE_TOWARDZERO, FE_UNDERFLOW,\n};\n\n/*\n * Fused multiply-add: Compute x * y + z with a single rounding error.\n *\n * A double has more than twice as much precision than a float, so\n * direct double-precision arithmetic suffices, except where double\n * rounding occurs.\n */\n#[inline]\npub fn fmaf(x: f32, y: f32, mut z: f32) -> f32 {\n    let xy: f64;\n    let mut result: f64;\n    let mut ui: u64;\n    let e: i32;\n\n    xy = x as f64 * y as f64;\n    result = xy + z as f64;\n    ui = result.to_bits();\n    e = (ui >> 52) as i32 & 0x7ff;\n    /* Common case: The double precision result is fine. */\n    if (\n        /* not a halfway case */\n        ui & 0x1fffffff) != 0x10000000 ||\n        /* NaN */\n        e == 0x7ff ||\n        /* exact */\n        (result - xy == z as f64 && result - z as f64 == xy) ||\n        /* not round-to-nearest */\n        fegetround() != FE_TONEAREST\n    {\n        /*\n            underflow may not be raised correctly, example:\n            fmaf(0x1p-120f, 0x1p-120f, 0x1p-149f)\n        */\n        if e < 0x3ff - 126 && e >= 0x3ff - 149 && fetestexcept(FE_INEXACT) != 0 {\n            feclearexcept(FE_INEXACT);\n            // prevent `xy + vz` from being CSE'd with `xy + z` above\n            let vz: f32 = unsafe { read_volatile(&z) };\n            result = xy + vz as f64;\n            if fetestexcept(FE_INEXACT) != 0 {\n                feraiseexcept(FE_UNDERFLOW);\n            } else {\n                feraiseexcept(FE_INEXACT);\n            }\n        }\n        z = result as f32;\n        return z;\n    }\n\n    /*\n     * If result is inexact, and exactly halfway between two float values,\n     * we need to adjust the low-order bit in the direction of the error.\n     */\n    fesetround(FE_TOWARDZERO);\n    // prevent `vxy + z` from being CSE'd with `xy + z` above\n    let vxy: f64 = unsafe { read_volatile(&xy) };\n    let mut adjusted_result: f64 = vxy + z as f64;\n    fesetround(FE_TONEAREST);\n    if result == adjusted_result {\n        ui = adjusted_result.to_bits();\n        ui += 1;\n        adjusted_result = f64::from_bits(ui);\n    }\n    z = adjusted_result as f32;\n    z\n}\n","#![allow(unreachable_code)]\n\nuse int::{Int, CastInto};\nuse float::Float;\n\n#[derive(Clone, Copy)]\nenum Result {\n    Less,\n    Equal,\n    Greater,\n    Unordered\n}\n\nimpl Result {\n    fn to_le_abi(self) -> i32 {\n        match self {\n            Result::Less      => -1,\n            Result::Equal     => 0,\n            Result::Greater   => 1,\n            Result::Unordered => 1\n        }\n    }\n\n    fn to_ge_abi(self) -> i32 {\n        match self {\n            Result::Less      => -1,\n            Result::Equal     => 0,\n            Result::Greater   => 1,\n            Result::Unordered => -1\n        }\n    }\n}\n\nfn cmp<F: Float>(a: F, b: F) -> Result where\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n{\n    let one   = F::Int::ONE;\n    let zero  = F::Int::ZERO;\n    let szero = F::SignedInt::ZERO;\n\n    let sign_bit =      F::SIGN_MASK as F::Int;\n    let abs_mask =      sign_bit - one;\n    let exponent_mask = F::EXPONENT_MASK;\n    let inf_rep =       exponent_mask;\n\n    let a_rep  = a.repr();\n    let b_rep  = b.repr();\n    let a_abs  = a_rep & abs_mask;\n    let b_abs  = b_rep & abs_mask;\n\n    // If either a or b is NaN, they are unordered.\n    if a_abs > inf_rep || b_abs > inf_rep {\n        return Result::Unordered\n    }\n\n    // If a and b are both zeros, they are equal.\n    if a_abs | b_abs == zero {\n        return Result::Equal\n    }\n\n    let a_srep = a.signed_repr();\n    let b_srep = b.signed_repr();\n\n    // If at least one of a and b is positive, we get the same result comparing\n    // a and b as signed integers as we would with a fp_ting-point compare.\n    if a_srep & b_srep >= szero {\n        if a_srep < b_srep {\n            return Result::Less\n        } else if a_srep == b_srep {\n            return Result::Equal\n        } else {\n            return Result::Greater\n        }\n    }\n\n    // Otherwise, both are negative, so we need to flip the sense of the\n    // comparison to get the correct result.  (This assumes a twos- or ones-\n    // complement integer representation; if integers are represented in a\n    // sign-magnitude representation, then this flip is incorrect).\n    else {\n        if a_srep > b_srep {\n            return Result::Less\n        } else if a_srep == b_srep {\n            return Result::Equal\n        } else {\n            return Result::Greater\n        }\n    }\n}\nfn unord<F: Float>(a: F, b: F) -> bool where\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n{\n    let one = F::Int::ONE;\n\n    let sign_bit =      F::SIGN_MASK as F::Int;\n    let abs_mask =      sign_bit - one;\n    let exponent_mask = F::EXPONENT_MASK;\n    let inf_rep =       exponent_mask;\n\n    let a_rep = a.repr();\n    let b_rep = b.repr();\n    let a_abs = a_rep & abs_mask;\n    let b_abs = b_rep & abs_mask;\n\n    a_abs > inf_rep || b_abs > inf_rep\n}\n\nintrinsics! {\n    pub extern \"C\" fn __lesf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __gesf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_ge_abi()\n    }\n\n    #[arm_aeabi_alias = __aeabi_fcmpun]\n    pub extern \"C\" fn __unordsf2(a: f32, b: f32) -> i32 {\n        unord(a, b) as i32\n    }\n\n    pub extern \"C\" fn __eqsf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __ltsf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __nesf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __gtsf2(a: f32, b: f32) -> i32 {\n        cmp(a, b).to_ge_abi()\n    }\n\n    pub extern \"C\" fn __ledf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __gedf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_ge_abi()\n    }\n\n    #[arm_aeabi_alias = __aeabi_dcmpun]\n    pub extern \"C\" fn __unorddf2(a: f64, b: f64) -> i32 {\n        unord(a, b) as i32\n    }\n\n    pub extern \"C\" fn __eqdf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __ltdf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __nedf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_le_abi()\n    }\n\n    pub extern \"C\" fn __gtdf2(a: f64, b: f64) -> i32 {\n        cmp(a, b).to_ge_abi()\n    }\n}\n\n#[cfg(target_arch = \"arm\")]\nintrinsics! {\n    pub extern \"aapcs\" fn __aeabi_fcmple(a: f32, b: f32) -> i32 {\n        (__lesf2(a, b) <= 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_fcmpge(a: f32, b: f32) -> i32 {\n        (__gesf2(a, b) >= 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_fcmpeq(a: f32, b: f32) -> i32 {\n        (__eqsf2(a, b) == 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_fcmplt(a: f32, b: f32) -> i32 {\n        (__ltsf2(a, b) < 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_fcmpgt(a: f32, b: f32) -> i32 {\n        (__gtsf2(a, b) > 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_dcmple(a: f64, b: f64) -> i32 {\n        (__ledf2(a, b) <= 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_dcmpge(a: f64, b: f64) -> i32 {\n        (__gedf2(a, b) >= 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_dcmpeq(a: f64, b: f64) -> i32 {\n        (__eqdf2(a, b) == 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_dcmplt(a: f64, b: f64) -> i32 {\n        (__ltdf2(a, b) < 0) as i32\n    }\n\n    pub extern \"aapcs\" fn __aeabi_dcmpgt(a: f64, b: f64) -> i32 {\n        (__gtdf2(a, b) > 0) as i32\n    }\n\n    // On hard-float targets LLVM will use native instructions\n    // for all VFP intrinsics below\n\n    pub extern \"C\" fn __gesf2vfp(a: f32, b: f32) -> i32 {\n        (a >= b) as i32\n    }\n\n    pub extern \"C\" fn __gedf2vfp(a: f64, b: f64) -> i32 {\n        (a >= b) as i32\n    }\n\n    pub extern \"C\" fn __gtsf2vfp(a: f32, b: f32) -> i32 {\n        (a > b) as i32\n    }\n\n    pub extern \"C\" fn __gtdf2vfp(a: f64, b: f64) -> i32 {\n        (a > b) as i32\n    }\n\n    pub extern \"C\" fn __ltsf2vfp(a: f32, b: f32) -> i32 {\n        (a < b) as i32\n    }\n\n    pub extern \"C\" fn __ltdf2vfp(a: f64, b: f64) -> i32 {\n        (a < b) as i32\n    }\n\n    pub extern \"C\" fn __lesf2vfp(a: f32, b: f32) -> i32 {\n        (a <= b) as i32\n    }\n\n    pub extern \"C\" fn __ledf2vfp(a: f64, b: f64) -> i32 {\n        (a <= b) as i32\n    }\n\n    pub extern \"C\" fn __nesf2vfp(a: f32, b: f32) -> i32 {\n        (a != b) as i32\n    }\n\n    pub extern \"C\" fn __nedf2vfp(a: f64, b: f64) -> i32 {\n        (a != b) as i32\n    }\n\n    pub extern \"C\" fn __eqsf2vfp(a: f32, b: f32) -> i32 {\n        (a == b) as i32\n    }\n\n    pub extern \"C\" fn __eqdf2vfp(a: f64, b: f64) -> i32 {\n        (a == b) as i32\n    }\n}\n","use core::mem;\nuse core::ops;\n\nuse super::int::Int;\n\npub mod conv;\npub mod cmp;\npub mod add;\npub mod pow;\npub mod sub;\npub mod mul;\npub mod div;\npub mod extend;\n\n/// Trait for some basic operations on floats\npub trait Float:\n    Copy +\n    PartialEq +\n    PartialOrd +\n    ops::AddAssign +\n    ops::MulAssign +\n    ops::Add<Output = Self> +\n    ops::Sub<Output = Self> +\n    ops::Div<Output = Self> +\n    ops::Rem<Output = Self> +\n{\n    /// A uint of the same with as the float\n    type Int: Int;\n\n    /// A int of the same with as the float\n    type SignedInt: Int;\n\n    const ZERO: Self;\n    const ONE: Self;\n\n    /// The bitwidth of the float type\n    const BITS: u32;\n\n    /// The bitwidth of the significand\n    const SIGNIFICAND_BITS: u32;\n\n    /// The bitwidth of the exponent\n    const EXPONENT_BITS: u32 = Self::BITS - Self::SIGNIFICAND_BITS - 1;\n\n    /// The maximum value of the exponent\n    const EXPONENT_MAX: u32 = (1 << Self::EXPONENT_BITS) - 1;\n\n    /// The exponent bias value\n    const EXPONENT_BIAS: u32 = Self::EXPONENT_MAX >> 1;\n\n    /// A mask for the sign bit\n    const SIGN_MASK: Self::Int;\n\n    /// A mask for the significand\n    const SIGNIFICAND_MASK: Self::Int;\n\n    // The implicit bit of the float format\n    const IMPLICIT_BIT: Self::Int;\n\n    /// A mask for the exponent\n    const EXPONENT_MASK: Self::Int;\n\n    /// Returns `self` transmuted to `Self::Int`\n    fn repr(self) -> Self::Int;\n\n    /// Returns `self` transmuted to `Self::SignedInt`\n    fn signed_repr(self) -> Self::SignedInt;\n\n    #[cfg(test)]\n    /// Checks if two floats have the same bit representation. *Except* for NaNs! NaN can be\n    /// represented in multiple different ways. This method returns `true` if two NaNs are\n    /// compared.\n    fn eq_repr(self, rhs: Self) -> bool;\n\n    /// Returns a `Self::Int` transmuted back to `Self`\n    fn from_repr(a: Self::Int) -> Self;\n\n    /// Constructs a `Self` from its parts. Inputs are treated as bits and shifted into position.\n    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self;\n\n    /// Returns (normalized exponent, normalized significand)\n    fn normalize(significand: Self::Int) -> (i32, Self::Int);\n}\n\n// FIXME: Some of this can be removed if RFC Issue #1424 is resolved\n//        https://github.com/rust-lang/rfcs/issues/1424\nmacro_rules! float_impl {\n    ($ty:ident, $ity:ident, $sity:ident, $bits:expr, $significand_bits:expr) => {\n        impl Float for $ty {\n            type Int = $ity;\n            type SignedInt = $sity;\n            const ZERO: Self = 0.0;\n            const ONE: Self = 1.0;\n\n            const BITS: u32 = $bits;\n            const SIGNIFICAND_BITS: u32 = $significand_bits;\n\n            const SIGN_MASK: Self::Int = 1 << (Self::BITS - 1);\n            const SIGNIFICAND_MASK: Self::Int = (1 << Self::SIGNIFICAND_BITS) - 1;\n            const IMPLICIT_BIT: Self::Int = 1 << Self::SIGNIFICAND_BITS;\n            const EXPONENT_MASK: Self::Int = !(Self::SIGN_MASK | Self::SIGNIFICAND_MASK);\n\n            fn repr(self) -> Self::Int {\n                unsafe { mem::transmute(self) }\n            }\n            fn signed_repr(self) -> Self::SignedInt {\n                unsafe { mem::transmute(self) }\n            }\n            #[cfg(test)]\n            fn eq_repr(self, rhs: Self) -> bool {\n                if self.is_nan() && rhs.is_nan() {\n                    true\n                } else {\n                    self.repr() == rhs.repr()\n                }\n            }\n            fn from_repr(a: Self::Int) -> Self {\n                unsafe { mem::transmute(a) }\n            }\n            fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self {\n                Self::from_repr(((sign as Self::Int) << (Self::BITS - 1)) |\n                    ((exponent << Self::SIGNIFICAND_BITS) & Self::EXPONENT_MASK) |\n                    (significand & Self::SIGNIFICAND_MASK))\n            }\n            fn normalize(significand: Self::Int) -> (i32, Self::Int) {\n                let shift = significand.leading_zeros()\n                    .wrapping_sub((Self::Int::ONE << Self::SIGNIFICAND_BITS).leading_zeros());\n                (1i32.wrapping_sub(shift as i32), significand << shift as Self::Int)\n            }\n        }\n    }\n}\n\nfloat_impl!(f32, u32, i32, 32, 23);\nfloat_impl!(f64, u64, i64, 64, 52);\n","use int::{Int, CastInto};\nuse float::Float;\n\n/// Returns `a + b`\nfn add<F: Float>(a: F, b: F) -> F where\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n{\n    let one = F::Int::ONE;\n    let zero = F::Int::ZERO;\n\n    let bits =             F::BITS.cast();\n    let significand_bits = F::SIGNIFICAND_BITS;\n    let max_exponent =     F::EXPONENT_MAX;\n\n    let implicit_bit =     F::IMPLICIT_BIT;\n    let significand_mask = F::SIGNIFICAND_MASK;\n    let sign_bit =         F::SIGN_MASK as F::Int;\n    let abs_mask =         sign_bit - one;\n    let exponent_mask =    F::EXPONENT_MASK;\n    let inf_rep =          exponent_mask;\n    let quiet_bit =        implicit_bit >> 1;\n    let qnan_rep =         exponent_mask | quiet_bit;\n\n    let mut a_rep = a.repr();\n    let mut b_rep = b.repr();\n    let a_abs = a_rep & abs_mask;\n    let b_abs = b_rep & abs_mask;\n\n    // Detect if a or b is zero, infinity, or NaN.\n    if a_abs.wrapping_sub(one) >= inf_rep - one ||\n        b_abs.wrapping_sub(one) >= inf_rep - one {\n        // NaN + anything = qNaN\n        if a_abs > inf_rep {\n            return F::from_repr(a_abs | quiet_bit);\n        }\n        // anything + NaN = qNaN\n        if b_abs > inf_rep {\n            return F::from_repr(b_abs | quiet_bit);\n        }\n\n        if a_abs == inf_rep {\n            // +/-infinity + -/+infinity = qNaN\n            if (a.repr() ^ b.repr()) == sign_bit {\n                return F::from_repr(qnan_rep);\n            } else {\n                // +/-infinity + anything remaining = +/- infinity\n                return a;\n            }\n        }\n\n        // anything remaining + +/-infinity = +/-infinity\n        if b_abs == inf_rep {\n            return b;\n        }\n\n        // zero + anything = anything\n        if a_abs == Int::ZERO {\n            // but we need to get the sign right for zero + zero\n            if b_abs == Int::ZERO {\n                return F::from_repr(a.repr() & b.repr());\n            } else {\n                return b;\n            }\n        }\n\n        // anything + zero = anything\n        if b_abs == Int::ZERO {\n             return a;\n        }\n    }\n\n    // Swap a and b if necessary so that a has the larger absolute value.\n    if b_abs > a_abs {\n        // Don't use mem::swap because it may generate references to memcpy in unoptimized code.\n        let tmp = a_rep;\n        a_rep = b_rep;\n        b_rep = tmp;\n    }\n\n    // Extract the exponent and significand from the (possibly swapped) a and b.\n    let mut a_exponent: i32 = ((a_rep & exponent_mask) >> significand_bits).cast();\n    let mut b_exponent: i32 = ((b_rep & exponent_mask) >> significand_bits).cast();\n    let mut a_significand = a_rep & significand_mask;\n    let mut b_significand = b_rep & significand_mask;\n\n    // normalize any denormals, and adjust the exponent accordingly.\n    if a_exponent == 0 {\n        let (exponent, significand) = F::normalize(a_significand);\n        a_exponent = exponent;\n        a_significand = significand;\n    }\n    if b_exponent == 0 {\n        let (exponent, significand) = F::normalize(b_significand);\n        b_exponent = exponent;\n        b_significand = significand;\n    }\n\n    // The sign of the result is the sign of the larger operand, a.  If they\n    // have opposite signs, we are performing a subtraction; otherwise addition.\n    let result_sign = a_rep & sign_bit;\n    let subtraction = ((a_rep ^ b_rep) & sign_bit) != zero;\n\n    // Shift the significands to give us round, guard and sticky, and or in the\n    // implicit significand bit.  (If we fell through from the denormal path it\n    // was already set by normalize(), but setting it twice won't hurt\n    // anything.)\n    a_significand = (a_significand | implicit_bit) << 3;\n    b_significand = (b_significand | implicit_bit) << 3;\n\n    // Shift the significand of b by the difference in exponents, with a sticky\n    // bottom bit to get rounding correct.\n    let align = a_exponent.wrapping_sub(b_exponent).cast();\n    if align != Int::ZERO {\n        if align < bits {\n            let sticky = F::Int::from_bool(b_significand << bits.wrapping_sub(align).cast() != Int::ZERO);\n            b_significand = (b_significand >> align.cast()) | sticky;\n        } else {\n            b_significand = one; // sticky; b is known to be non-zero.\n        }\n    }\n    if subtraction {\n        a_significand = a_significand.wrapping_sub(b_significand);\n        // If a == -b, return +zero.\n        if a_significand == Int::ZERO {\n            return F::from_repr(Int::ZERO);\n        }\n\n        // If partial cancellation occured, we need to left-shift the result\n        // and adjust the exponent:\n        if a_significand < implicit_bit << 3 {\n            let shift = a_significand.leading_zeros() as i32\n                - (implicit_bit << 3).leading_zeros() as i32;\n            a_significand <<= shift;\n            a_exponent -= shift;\n        }\n    } else /* addition */ {\n        a_significand += b_significand;\n\n        // If the addition carried up, we need to right-shift the result and\n        // adjust the exponent:\n        if a_significand & implicit_bit << 4 != Int::ZERO {\n            let sticky = F::Int::from_bool(a_significand & one != Int::ZERO);\n            a_significand = a_significand >> 1 | sticky;\n            a_exponent += 1;\n        }\n    }\n\n    // If we have overflowed the type, return +/- infinity:\n    if a_exponent >= max_exponent as i32 {\n        return F::from_repr(inf_rep | result_sign);\n    }\n\n    if a_exponent <= 0 {\n        // Result is denormal before rounding; the exponent is zero and we\n        // need to shift the significand.\n        let shift = (1 - a_exponent).cast();\n        let sticky = F::Int::from_bool((a_significand << bits.wrapping_sub(shift).cast()) != Int::ZERO);\n        a_significand = a_significand >> shift.cast() | sticky;\n        a_exponent = 0;\n    }\n\n    // Low three bits are round, guard, and sticky.\n    let a_significand_i32: i32 = a_significand.cast();\n    let round_guard_sticky: i32 = a_significand_i32 & 0x7;\n\n    // Shift the significand into place, and mask off the implicit bit.\n    let mut result = a_significand >> 3 & significand_mask;\n\n    // Insert the exponent and sign.\n    result |= a_exponent.cast() << significand_bits;\n    result |= result_sign;\n\n    // Final rounding.  The result may overflow to infinity, but that is the\n    // correct result in that case.\n    if round_guard_sticky > 0x4 { result += one; }\n    if round_guard_sticky == 0x4 { result += result & one; }\n\n    F::from_repr(result)\n}\n\nintrinsics! {\n    #[aapcs_on_arm]\n    #[arm_aeabi_alias = __aeabi_fadd]\n    pub extern \"C\" fn __addsf3(a: f32, b: f32) -> f32 {\n        add(a, b)\n    }\n\n    #[aapcs_on_arm]\n    #[arm_aeabi_alias = __aeabi_dadd]\n    pub extern \"C\" fn __adddf3(a: f64, b: f64) -> f64 {\n        add(a, b)\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __addsf3vfp(a: f32, b: f32) -> f32 {\n        a + b\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __adddf3vfp(a: f64, b: f64) -> f64 {\n        a + b\n    }\n}\n","use int::Int;\nuse float::Float;\n\ntrait Pow: Float {\n    /// Returns `a` raised to the power `b`\n    fn pow(self, mut b: i32) -> Self {\n        let mut a = self;\n        let recip = b < 0;\n        let mut r = Self::ONE;\n        loop {\n            if (b & 1) != 0 {\n                r *= a;\n            }\n            b = b.aborting_div(2);\n            if b == 0 {\n                break;\n            }\n            a *= a;\n        }\n\n        if recip {\n            Self::ONE / r\n        } else {\n            r\n        }\n    }\n}\n\nimpl Pow for f32 {}\nimpl Pow for f64 {}\n\nintrinsics! {\n    pub extern \"C\" fn __powisf2(a: f32, b: i32) -> f32 {\n        a.pow(b)\n    }\n\n    pub extern \"C\" fn __powidf2(a: f64, b: i32) -> f64 {\n        a.pow(b)\n    }\n}\n","use int::{CastInto, Int, WideInt};\nuse float::Float;\n\nfn mul<F: Float>(a: F, b: F) -> F\nwhere\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n    F::Int: WideInt,\n{\n    let one = F::Int::ONE;\n    let zero = F::Int::ZERO;\n\n    let bits = F::BITS;\n    let significand_bits = F::SIGNIFICAND_BITS;\n    let max_exponent = F::EXPONENT_MAX;\n\n    let exponent_bias = F::EXPONENT_BIAS;\n\n    let implicit_bit = F::IMPLICIT_BIT;\n    let significand_mask = F::SIGNIFICAND_MASK;\n    let sign_bit = F::SIGN_MASK as F::Int;\n    let abs_mask = sign_bit - one;\n    let exponent_mask = F::EXPONENT_MASK;\n    let inf_rep = exponent_mask;\n    let quiet_bit = implicit_bit >> 1;\n    let qnan_rep = exponent_mask | quiet_bit;\n    let exponent_bits = F::EXPONENT_BITS;\n\n    let a_rep = a.repr();\n    let b_rep = b.repr();\n\n    let a_exponent = (a_rep >> significand_bits) & max_exponent.cast();\n    let b_exponent = (b_rep >> significand_bits) & max_exponent.cast();\n    let product_sign = (a_rep ^ b_rep) & sign_bit;\n\n    let mut a_significand = a_rep & significand_mask;\n    let mut b_significand = b_rep & significand_mask;\n    let mut scale = 0;\n\n    // Detect if a or b is zero, denormal, infinity, or NaN.\n    if a_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n        || b_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n    {\n        let a_abs = a_rep & abs_mask;\n        let b_abs = b_rep & abs_mask;\n\n        // NaN + anything = qNaN\n        if a_abs > inf_rep {\n            return F::from_repr(a_rep | quiet_bit);\n        }\n        // anything + NaN = qNaN\n        if b_abs > inf_rep {\n            return F::from_repr(b_rep | quiet_bit);\n        }\n\n        if a_abs == inf_rep {\n            if b_abs != zero {\n                // infinity * non-zero = +/- infinity\n                return F::from_repr(a_abs | product_sign);\n            } else {\n                // infinity * zero = NaN\n                return F::from_repr(qnan_rep);\n            }\n        }\n\n        if b_abs == inf_rep {\n            if a_abs != zero {\n                // infinity * non-zero = +/- infinity\n                return F::from_repr(b_abs | product_sign);\n            } else {\n                // infinity * zero = NaN\n                return F::from_repr(qnan_rep);\n            }\n        }\n\n        // zero * anything = +/- zero\n        if a_abs == zero {\n            return F::from_repr(product_sign);\n        }\n\n        // anything * zero = +/- zero\n        if b_abs == zero {\n            return F::from_repr(product_sign);\n        }\n\n        // one or both of a or b is denormal, the other (if applicable) is a\n        // normal number.  Renormalize one or both of a and b, and set scale to\n        // include the necessary exponent adjustment.\n        if a_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(a_significand);\n            scale += exponent;\n            a_significand = significand;\n        }\n\n        if b_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(b_significand);\n            scale += exponent;\n            b_significand = significand;\n        }\n    }\n\n    // Or in the implicit significand bit.  (If we fell through from the\n    // denormal path it was already set by normalize( ), but setting it twice\n    // won't hurt anything.)\n    a_significand |= implicit_bit;\n    b_significand |= implicit_bit;\n\n    // Get the significand of a*b.  Before multiplying the significands, shift\n    // one of them left to left-align it in the field.  Thus, the product will\n    // have (exponentBits + 2) integral digits, all but two of which must be\n    // zero.  Normalizing this result is just a conditional left-shift by one\n    // and bumping the exponent accordingly.\n    let (mut product_high, mut product_low) =\n        <F::Int as WideInt>::wide_mul(a_significand, b_significand << exponent_bits);\n\n    let a_exponent_i32: i32 = a_exponent.cast();\n    let b_exponent_i32: i32 = b_exponent.cast();\n    let mut product_exponent: i32 = a_exponent_i32\n        .wrapping_add(b_exponent_i32)\n        .wrapping_add(scale)\n        .wrapping_sub(exponent_bias as i32);\n\n    // Normalize the significand, adjust exponent if needed.\n    if (product_high & implicit_bit) != zero {\n        product_exponent = product_exponent.wrapping_add(1);\n    } else {\n        <F::Int as WideInt>::wide_shift_left(&mut product_high, &mut product_low, 1);\n    }\n\n    // If we have overflowed the type, return +/- infinity.\n    if product_exponent >= max_exponent as i32 {\n        return F::from_repr(inf_rep | product_sign);\n    }\n\n    if product_exponent <= 0 {\n        // Result is denormal before rounding\n        //\n        // If the result is so small that it just underflows to zero, return\n        // a zero of the appropriate sign.  Mathematically there is no need to\n        // handle this case separately, but we make it a special case to\n        // simplify the shift logic.\n        let shift = one.wrapping_sub(product_exponent.cast()).cast();\n        if shift >= bits as i32 {\n            return F::from_repr(product_sign);\n        }\n\n        // Otherwise, shift the significand of the result so that the round\n        // bit is the high bit of productLo.\n        <F::Int as WideInt>::wide_shift_right_with_sticky(\n            &mut product_high,\n            &mut product_low,\n            shift,\n        )\n    } else {\n        // Result is normal before rounding; insert the exponent.\n        product_high &= significand_mask;\n        product_high |= product_exponent.cast() << significand_bits;\n    }\n\n    // Insert the sign of the result:\n    product_high |= product_sign;\n\n    // Final rounding.  The final result may overflow to infinity, or underflow\n    // to zero, but those are the correct results in those cases.  We use the\n    // default IEEE-754 round-to-nearest, ties-to-even rounding mode.\n    if product_low > sign_bit {\n        product_high += one;\n    }\n\n    if product_low == sign_bit {\n        product_high += product_high & one;\n    }\n\n    return F::from_repr(product_high);\n}\n\nintrinsics! {\n    #[aapcs_on_arm]\n    #[arm_aeabi_alias = __aeabi_fmul]\n    pub extern \"C\" fn __mulsf3(a: f32, b: f32) -> f32 {\n        mul(a, b)\n    }\n\n    #[aapcs_on_arm]\n    #[arm_aeabi_alias = __aeabi_dmul]\n    pub extern \"C\" fn __muldf3(a: f64, b: f64) -> f64 {\n        mul(a, b)\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __mulsf3vfp(a: f32, b: f32) -> f32 {\n        a * b\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __muldf3vfp(a: f64, b: f64) -> f64 {\n        a * b\n    }\n}\n","use int::{CastInto, Int, WideInt};\nuse float::Float;\n\n\n\nfn div32<F: Float>(a: F, b: F) -> F\nwhere\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n    F::Int: WideInt,\n{\n    let one = F::Int::ONE;\n    let zero = F::Int::ZERO;\n\n    // let bits = F::BITS;\n    let significand_bits = F::SIGNIFICAND_BITS;\n    let max_exponent = F::EXPONENT_MAX;\n\n    let exponent_bias = F::EXPONENT_BIAS;\n\n    let implicit_bit = F::IMPLICIT_BIT;\n    let significand_mask = F::SIGNIFICAND_MASK;\n    let sign_bit = F::SIGN_MASK as F::Int;\n    let abs_mask = sign_bit - one;\n    let exponent_mask = F::EXPONENT_MASK;\n    let inf_rep = exponent_mask;\n    let quiet_bit = implicit_bit >> 1;\n    let qnan_rep = exponent_mask | quiet_bit;\n\n    #[inline(always)]\n    fn negate_u32(a: u32) -> u32 {\n        (<i32>::wrapping_neg(a as i32)) as u32\n    }\n\n    let a_rep = a.repr();\n    let b_rep = b.repr();\n\n    let a_exponent = (a_rep >> significand_bits) & max_exponent.cast();\n    let b_exponent = (b_rep >> significand_bits) & max_exponent.cast();\n    let quotient_sign = (a_rep ^ b_rep) & sign_bit;\n\n    let mut a_significand = a_rep & significand_mask;\n    let mut b_significand = b_rep & significand_mask;\n    let mut scale = 0;\n\n    // Detect if a or b is zero, denormal, infinity, or NaN.\n    if a_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n        || b_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n    {\n        let a_abs = a_rep & abs_mask;\n        let b_abs = b_rep & abs_mask;\n\n        // NaN / anything = qNaN\n        if a_abs > inf_rep {\n            return F::from_repr(a_rep | quiet_bit);\n        }\n        // anything / NaN = qNaN\n        if b_abs > inf_rep {\n            return F::from_repr(b_rep | quiet_bit);\n        }\n\n        if a_abs == inf_rep {\n            if b_abs == inf_rep {\n                // infinity / infinity = NaN\n                return F::from_repr(qnan_rep);\n            } else {\n                // infinity / anything else = +/- infinity\n                return F::from_repr(a_abs | quotient_sign);\n            }\n        }\n\n        // anything else / infinity = +/- 0\n        if b_abs == inf_rep {\n            return F::from_repr(quotient_sign);\n        }\n\n        if a_abs == zero {\n            if b_abs == zero {\n                // zero / zero = NaN\n                return F::from_repr(qnan_rep);\n            } else {\n                // zero / anything else = +/- zero\n                return F::from_repr(quotient_sign);\n            }\n        }\n\n        // anything else / zero = +/- infinity\n        if b_abs == zero {\n            return F::from_repr(inf_rep | quotient_sign);\n        }\n\n        // one or both of a or b is denormal, the other (if applicable) is a\n        // normal number.  Renormalize one or both of a and b, and set scale to\n        // include the necessary exponent adjustment.\n        if a_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(a_significand);\n            scale += exponent;\n            a_significand = significand;\n        }\n\n        if b_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(b_significand);\n            scale -= exponent;\n            b_significand = significand;\n        }\n    }\n\n    // Or in the implicit significand bit.  (If we fell through from the\n    // denormal path it was already set by normalize( ), but setting it twice\n    // won't hurt anything.)\n    a_significand |= implicit_bit;\n    b_significand |= implicit_bit;\n    let mut quotient_exponent: i32 = CastInto::<i32>::cast(a_exponent)\n        .wrapping_sub(CastInto::<i32>::cast(b_exponent))\n        .wrapping_add(scale);\n\n    // Align the significand of b as a Q31 fixed-point number in the range\n    // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax\n    // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This\n    // is accurate to about 3.5 binary digits.\n    let q31b = CastInto::<u32>::cast(b_significand << 8.cast());\n    let mut reciprocal = (0x7504f333u32).wrapping_sub(q31b);\n\n    // Now refine the reciprocal estimate using a Newton-Raphson iteration:\n    //\n    //     x1 = x0 * (2 - x0 * b)\n    //\n    // This doubles the number of correct binary digits in the approximation\n    // with each iteration, so after three iterations, we have about 28 binary\n    // digits of accuracy.\n    let mut correction: u32;\n    correction = negate_u32(((reciprocal as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    reciprocal = ((reciprocal as u64).wrapping_mul(correction as u64) as u64 >> 31) as u32;\n    correction = negate_u32(((reciprocal as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    reciprocal = ((reciprocal as u64).wrapping_mul(correction as u64) as u64 >> 31) as u32;\n    correction = negate_u32(((reciprocal as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    reciprocal = ((reciprocal as u64).wrapping_mul(correction as u64) as u64 >> 31) as u32;\n\n    // Exhaustive testing shows that the error in reciprocal after three steps\n    // is in the interval [-0x1.f58108p-31, 0x1.d0e48cp-29], in line with our\n    // expectations.  We bump the reciprocal by a tiny value to force the error\n    // to be strictly positive (in the range [0x1.4fdfp-37,0x1.287246p-29], to\n    // be specific).  This also causes 1/1 to give a sensible approximation\n    // instead of zero (due to overflow).\n    reciprocal = reciprocal.wrapping_sub(2);\n\n    // The numerical reciprocal is accurate to within 2^-28, lies in the\n    // interval [0x1.000000eep-1, 0x1.fffffffcp-1], and is strictly smaller\n    // than the true reciprocal of b.  Multiplying a by this reciprocal thus\n    // gives a numerical q = a/b in Q24 with the following properties:\n    //\n    //    1. q < a/b\n    //    2. q is in the interval [0x1.000000eep-1, 0x1.fffffffcp0)\n    //    3. the error in q is at most 2^-24 + 2^-27 -- the 2^24 term comes\n    //       from the fact that we truncate the product, and the 2^27 term\n    //       is the error in the reciprocal of b scaled by the maximum\n    //       possible value of a.  As a consequence of this error bound,\n    //       either q or nextafter(q) is the correctly rounded\n    let (mut quotient, _) = <F::Int as WideInt>::wide_mul(a_significand << 1, reciprocal.cast());\n\n    // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).\n    // In either case, we are going to compute a residual of the form\n    //\n    //     r = a - q*b\n    //\n    // We know from the construction of q that r satisfies:\n    //\n    //     0 <= r < ulp(q)*b\n    //\n    // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we\n    // already have the correct result.  The exact halfway case cannot occur.\n    // We also take this time to right shift quotient if it falls in the [1,2)\n    // range and adjust the exponent accordingly.\n    let residual = if quotient < (implicit_bit << 1) {\n        quotient_exponent = quotient_exponent.wrapping_sub(1);\n        (a_significand << (significand_bits + 1)).wrapping_sub(quotient.wrapping_mul(b_significand))\n    } else {\n        quotient >>= 1;\n        (a_significand << significand_bits).wrapping_sub(quotient.wrapping_mul(b_significand))\n    };\n\n    let written_exponent = quotient_exponent.wrapping_add(exponent_bias as i32);\n\n    if written_exponent >= max_exponent as i32 {\n        // If we have overflowed the exponent, return infinity.\n        return F::from_repr(inf_rep | quotient_sign);\n    } else if written_exponent < 1 {\n        // Flush denormals to zero.  In the future, it would be nice to add\n        // code to round them correctly.\n        return F::from_repr(quotient_sign);\n    } else {\n        let round = ((residual << 1) > b_significand) as u32;\n        // Clear the implicit bits\n        let mut abs_result = quotient & significand_mask;\n        // Insert the exponent\n        abs_result |= written_exponent.cast() << significand_bits;\n        // Round\n        abs_result = abs_result.wrapping_add(round.cast());\n        // Insert the sign and return\n        return F::from_repr(abs_result | quotient_sign);\n    }\n}\n\nfn div64<F: Float>(a: F, b: F) -> F\nwhere\n    u32: CastInto<F::Int>,\n    F::Int: CastInto<u32>,\n    i32: CastInto<F::Int>,\n    F::Int: CastInto<i32>,\n    u64: CastInto<F::Int>,\n    F::Int: CastInto<u64>,\n    i64: CastInto<F::Int>,\n    F::Int: CastInto<i64>,\n    F::Int: WideInt,\n{\n    let one = F::Int::ONE;\n    let zero = F::Int::ZERO;\n\n    // let bits = F::BITS;\n    let significand_bits = F::SIGNIFICAND_BITS;\n    let max_exponent = F::EXPONENT_MAX;\n\n    let exponent_bias = F::EXPONENT_BIAS;\n\n    let implicit_bit = F::IMPLICIT_BIT;\n    let significand_mask = F::SIGNIFICAND_MASK;\n    let sign_bit = F::SIGN_MASK as F::Int;\n    let abs_mask = sign_bit - one;\n    let exponent_mask = F::EXPONENT_MASK;\n    let inf_rep = exponent_mask;\n    let quiet_bit = implicit_bit >> 1;\n    let qnan_rep = exponent_mask | quiet_bit;\n    // let exponent_bits = F::EXPONENT_BITS;\n\n    #[inline(always)]\n    fn negate_u32(a: u32) -> u32 {\n        (<i32>::wrapping_neg(a as i32)) as u32\n    }\n\n    #[inline(always)]\n    fn negate_u64(a: u64) -> u64 {\n        (<i64>::wrapping_neg(a as i64)) as u64\n    }\n\n    let a_rep = a.repr();\n    let b_rep = b.repr();\n\n    let a_exponent = (a_rep >> significand_bits) & max_exponent.cast();\n    let b_exponent = (b_rep >> significand_bits) & max_exponent.cast();\n    let quotient_sign = (a_rep ^ b_rep) & sign_bit;\n\n    let mut a_significand = a_rep & significand_mask;\n    let mut b_significand = b_rep & significand_mask;\n    let mut scale = 0;\n\n    // Detect if a or b is zero, denormal, infinity, or NaN.\n    if a_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n        || b_exponent.wrapping_sub(one) >= (max_exponent - 1).cast()\n    {\n        let a_abs = a_rep & abs_mask;\n        let b_abs = b_rep & abs_mask;\n\n        // NaN / anything = qNaN\n        if a_abs > inf_rep {\n            return F::from_repr(a_rep | quiet_bit);\n        }\n        // anything / NaN = qNaN\n        if b_abs > inf_rep {\n            return F::from_repr(b_rep | quiet_bit);\n        }\n\n        if a_abs == inf_rep {\n            if b_abs == inf_rep {\n                // infinity / infinity = NaN\n                return F::from_repr(qnan_rep);\n            } else {\n                // infinity / anything else = +/- infinity\n                return F::from_repr(a_abs | quotient_sign);\n            }\n        }\n\n        // anything else / infinity = +/- 0\n        if b_abs == inf_rep {\n            return F::from_repr(quotient_sign);\n        }\n\n        if a_abs == zero {\n            if b_abs == zero {\n                // zero / zero = NaN\n                return F::from_repr(qnan_rep);\n            } else {\n                // zero / anything else = +/- zero\n                return F::from_repr(quotient_sign);\n            }\n        }\n\n        // anything else / zero = +/- infinity\n        if b_abs == zero {\n            return F::from_repr(inf_rep | quotient_sign);\n        }\n\n        // one or both of a or b is denormal, the other (if applicable) is a\n        // normal number.  Renormalize one or both of a and b, and set scale to\n        // include the necessary exponent adjustment.\n        if a_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(a_significand);\n            scale += exponent;\n            a_significand = significand;\n        }\n\n        if b_abs < implicit_bit {\n            let (exponent, significand) = F::normalize(b_significand);\n            scale -= exponent;\n            b_significand = significand;\n        }\n    }\n\n    // Or in the implicit significand bit.  (If we fell through from the\n    // denormal path it was already set by normalize( ), but setting it twice\n    // won't hurt anything.)\n    a_significand |= implicit_bit;\n    b_significand |= implicit_bit;\n    let mut quotient_exponent: i32 = CastInto::<i32>::cast(a_exponent)\n        .wrapping_sub(CastInto::<i32>::cast(b_exponent))\n        .wrapping_add(scale);\n\n    // Align the significand of b as a Q31 fixed-point number in the range\n    // [1, 2.0) and get a Q32 approximate reciprocal using a small minimax\n    // polynomial approximation: reciprocal = 3/4 + 1/sqrt(2) - b/2.  This\n    // is accurate to about 3.5 binary digits.\n    let q31b = CastInto::<u32>::cast(b_significand >> 21.cast());\n    let mut recip32 = (0x7504f333u32).wrapping_sub(q31b);\n\n    // Now refine the reciprocal estimate using a Newton-Raphson iteration:\n    //\n    //     x1 = x0 * (2 - x0 * b)\n    //\n    // This doubles the number of correct binary digits in the approximation\n    // with each iteration, so after three iterations, we have about 28 binary\n    // digits of accuracy.\n    let mut correction32: u32;\n    correction32 = negate_u32(((recip32 as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    recip32 = ((recip32 as u64).wrapping_mul(correction32 as u64) >> 31) as u32;\n    correction32 = negate_u32(((recip32 as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    recip32 = ((recip32 as u64).wrapping_mul(correction32 as u64) >> 31) as u32;\n    correction32 = negate_u32(((recip32 as u64).wrapping_mul(q31b as u64) >> 32) as u32);\n    recip32 = ((recip32 as u64).wrapping_mul(correction32 as u64) >> 31) as u32;\n\n    // recip32 might have overflowed to exactly zero in the preceeding\n    // computation if the high word of b is exactly 1.0.  This would sabotage\n    // the full-width final stage of the computation that follows, so we adjust\n    // recip32 downward by one bit.\n    recip32 = recip32.wrapping_sub(1);\n\n    // We need to perform one more iteration to get us to 56 binary digits;\n    // The last iteration needs to happen with extra precision.\n    let q63blo = CastInto::<u32>::cast(b_significand << 11.cast());\n    let correction: u64;\n    let mut reciprocal: u64;\n    correction = negate_u64(\n        (recip32 as u64)\n            .wrapping_mul(q31b as u64)\n            .wrapping_add((recip32 as u64).wrapping_mul(q63blo as u64) >> 32),\n    );\n    let c_hi = (correction >> 32) as u32;\n    let c_lo = correction as u32;\n    reciprocal = (recip32 as u64)\n        .wrapping_mul(c_hi as u64)\n        .wrapping_add((recip32 as u64).wrapping_mul(c_lo as u64) >> 32);\n\n    // We already adjusted the 32-bit estimate, now we need to adjust the final\n    // 64-bit reciprocal estimate downward to ensure that it is strictly smaller\n    // than the infinitely precise exact reciprocal.  Because the computation\n    // of the Newton-Raphson step is truncating at every step, this adjustment\n    // is small; most of the work is already done.\n    reciprocal = reciprocal.wrapping_sub(2);\n\n    // The numerical reciprocal is accurate to within 2^-56, lies in the\n    // interval [0.5, 1.0), and is strictly smaller than the true reciprocal\n    // of b.  Multiplying a by this reciprocal thus gives a numerical q = a/b\n    // in Q53 with the following properties:\n    //\n    //    1. q < a/b\n    //    2. q is in the interval [0.5, 2.0)\n    //    3. the error in q is bounded away from 2^-53 (actually, we have a\n    //       couple of bits to spare, but this is all we need).\n\n    // We need a 64 x 64 multiply high to compute q, which isn't a basic\n    // operation in C, so we need to be a little bit fussy.\n    // let mut quotient: F::Int = ((((reciprocal as u64)\n    //     .wrapping_mul(CastInto::<u32>::cast(a_significand << 1) as u64))\n    //     >> 32) as u32)\n    //     .cast();\n\n    // We need a 64 x 64 multiply high to compute q, which isn't a basic\n    // operation in C, so we need to be a little bit fussy.\n    let (mut quotient, _) = <F::Int as WideInt>::wide_mul(a_significand << 2, reciprocal.cast());\n\n\n    // Two cases: quotient is in [0.5, 1.0) or quotient is in [1.0, 2.0).\n    // In either case, we are going to compute a residual of the form\n    //\n    //     r = a - q*b\n    //\n    // We know from the construction of q that r satisfies:\n    //\n    //     0 <= r < ulp(q)*b\n    //\n    // if r is greater than 1/2 ulp(q)*b, then q rounds up.  Otherwise, we\n    // already have the correct result.  The exact halfway case cannot occur.\n    // We also take this time to right shift quotient if it falls in the [1,2)\n    // range and adjust the exponent accordingly.\n    let residual = if quotient < (implicit_bit << 1) {\n        quotient_exponent = quotient_exponent.wrapping_sub(1);\n        (a_significand << (significand_bits + 1)).wrapping_sub(quotient.wrapping_mul(b_significand))\n    } else {\n        quotient >>= 1;\n        (a_significand << significand_bits).wrapping_sub(quotient.wrapping_mul(b_significand))\n    };\n\n    let written_exponent = quotient_exponent.wrapping_add(exponent_bias as i32);\n\n    if written_exponent >= max_exponent as i32 {\n        // If we have overflowed the exponent, return infinity.\n        return F::from_repr(inf_rep | quotient_sign);\n    } else if written_exponent < 1 {\n        // Flush denormals to zero.  In the future, it would be nice to add\n        // code to round them correctly.\n        return F::from_repr(quotient_sign);\n    } else {\n        let round = ((residual << 1) > b_significand) as u32;\n        // Clear the implicit bits\n        let mut abs_result = quotient & significand_mask;\n        // Insert the exponent\n        abs_result |= written_exponent.cast() << significand_bits;\n        // Round\n        abs_result = abs_result.wrapping_add(round.cast());\n        // Insert the sign and return\n        return F::from_repr(abs_result | quotient_sign);\n    }\n}\n\n\nintrinsics! {\n    #[arm_aeabi_alias = __aeabi_fdiv]\n    pub extern \"C\" fn __divsf3(a: f32, b: f32) -> f32 {\n        div32(a, b)\n    }\n\n    #[arm_aeabi_alias = __aeabi_ddiv]\n    pub extern \"C\" fn __divdf3(a: f64, b: f64) -> f64 {\n        div64(a, b)\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __divsf3vfp(a: f32, b: f32) -> f32 {\n        a / b\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn __divdf3vfp(a: f64, b: f64) -> f64 {\n        a / b\n    }\n}\n","use int::{CastInto, Int};\nuse float::Float;\n\n/// Generic conversion from a narrower to a wider IEEE-754 floating-point type\nfn extend<F: Float, R: Float>(a: F) -> R where\n    F::Int: CastInto<u64>,\n    u64: CastInto<F::Int>,\n    u32: CastInto<R::Int>,\n    R::Int: CastInto<u32>,\n    R::Int: CastInto<u64>,\n    u64: CastInto<R::Int>,\n    F::Int: CastInto<R::Int>,\n{\n    let src_zero = F::Int::ZERO;\n    let src_one = F::Int::ONE;\n    let src_bits = F::BITS;\n    let src_sign_bits = F::SIGNIFICAND_BITS;\n    let src_exp_bias = F::EXPONENT_BIAS;\n    let src_min_normal = F::IMPLICIT_BIT;\n    let src_infinity = F::EXPONENT_MASK;\n    let src_sign_mask = F::SIGN_MASK as F::Int;\n    let src_abs_mask = src_sign_mask - src_one;\n    let src_qnan = F::SIGNIFICAND_MASK;\n    let src_nan_code = src_qnan - src_one;\n\n    let dst_bits = R::BITS;\n    let dst_sign_bits = R::SIGNIFICAND_BITS;\n    let dst_inf_exp = R::EXPONENT_MAX;\n    let dst_exp_bias = R::EXPONENT_BIAS;\n    let dst_min_normal = R::IMPLICIT_BIT;\n\n    let sign_bits_delta = dst_sign_bits - src_sign_bits;\n    let exp_bias_delta = dst_exp_bias - src_exp_bias;\n    let a_abs = a.repr() & src_abs_mask;\n    let mut abs_result = R::Int::ZERO;\n\n    if a_abs.wrapping_sub(src_min_normal) < src_infinity.wrapping_sub(src_min_normal) {\n        // a is a normal number.\n        // Extend to the destination type by shifting the significand and\n        // exponent into the proper position and rebiasing the exponent.\n        let abs_dst: R::Int = a_abs.cast();\n        let bias_dst: R::Int = exp_bias_delta.cast();\n        abs_result = abs_dst.wrapping_shl(sign_bits_delta);\n        abs_result += bias_dst.wrapping_shl(dst_sign_bits);\n    } else if a_abs >= src_infinity {\n        // a is NaN or infinity.\n        // Conjure the result by beginning with infinity, then setting the qNaN\n        // bit (if needed) and right-aligning the rest of the trailing NaN\n        // payload field.\n        let qnan_dst: R::Int = (a_abs & src_qnan).cast();\n        let nan_code_dst: R::Int = (a_abs & src_nan_code).cast();\n        let inf_exp_dst: R::Int = dst_inf_exp.cast();\n        abs_result = inf_exp_dst.wrapping_shl(dst_sign_bits);\n        abs_result |= qnan_dst.wrapping_shl(sign_bits_delta);\n        abs_result |= nan_code_dst.wrapping_shl(sign_bits_delta);\n    } else if a_abs != src_zero {\n        // a is denormal.\n        // Renormalize the significand and clear the leading bit, then insert\n        // the correct adjusted exponent in the destination type.\n        let scale = a_abs.leading_zeros() - src_min_normal.leading_zeros();\n        let abs_dst: R::Int = a_abs.cast();\n        let bias_dst: R::Int = (exp_bias_delta - scale + 1).cast();\n        abs_result = abs_dst.wrapping_shl(sign_bits_delta + scale);\n        abs_result = (abs_result ^ dst_min_normal) | (bias_dst.wrapping_shl(dst_sign_bits));\n    }\n\n    let sign_result: R::Int = (a.repr() & src_sign_mask).cast();\n    R::from_repr(abs_result | (sign_result.wrapping_shl(dst_bits - src_bits)))\n}\n\nintrinsics! {\n    #[aapcs_on_arm]\n    #[arm_aeabi_alias = __aeabi_f2d]\n    pub extern \"C\" fn  __extendsfdf2(a: f32) -> f64 {\n        extend(a)\n    }\n\n    #[cfg(target_arch = \"arm\")]\n    pub extern \"C\" fn  __extendsfdf2vfp(a: f32) -> f64 {\n        a as f64 // LLVM generate 'fcvtds'\n    }\n}","use core::ops;\n\nmacro_rules! hty {\n    ($ty:ty) => {\n        <$ty as LargeInt>::HighHalf\n    }\n}\n\nmacro_rules! os_ty {\n    ($ty:ty) => {\n        <$ty as Int>::OtherSign\n    }\n}\n\npub mod addsub;\npub mod mul;\npub mod sdiv;\npub mod shift;\npub mod udiv;\n\n/// Trait for some basic operations on integers\npub trait Int:\n    Copy +\n    PartialEq +\n    PartialOrd +\n    ops::AddAssign +\n    ops::BitAndAssign +\n    ops::BitOrAssign +\n    ops::ShlAssign<i32> +\n    ops::ShrAssign<u32> +\n    ops::Add<Output = Self> +\n    ops::Sub<Output = Self> +\n    ops::Div<Output = Self> +\n    ops::Shl<u32, Output = Self> +\n    ops::Shr<u32, Output = Self> +\n    ops::BitOr<Output = Self> +\n    ops::BitXor<Output = Self> +\n    ops::BitAnd<Output = Self> +\n    ops::Not<Output = Self> +\n{\n    /// Type with the same width but other signedness\n    type OtherSign: Int;\n    /// Unsigned version of Self\n    type UnsignedInt: Int;\n\n    /// The bitwidth of the int type\n    const BITS: u32;\n\n    const ZERO: Self;\n    const ONE: Self;\n\n    /// Extracts the sign from self and returns a tuple.\n    ///\n    /// # Examples\n    ///\n    /// ```rust,ignore\n    /// let i = -25_i32;\n    /// let (sign, u) = i.extract_sign();\n    /// assert_eq!(sign, true);\n    /// assert_eq!(u, 25_u32);\n    /// ```\n    fn extract_sign(self) -> (bool, Self::UnsignedInt);\n\n    fn unsigned(self) -> Self::UnsignedInt;\n    fn from_unsigned(unsigned: Self::UnsignedInt) -> Self;\n\n    fn from_bool(b: bool) -> Self;\n\n    // copied from primitive integers, but put in a trait\n    fn max_value() -> Self;\n    fn min_value() -> Self;\n    fn wrapping_add(self, other: Self) -> Self;\n    fn wrapping_mul(self, other: Self) -> Self;\n    fn wrapping_sub(self, other: Self) -> Self;\n    fn wrapping_shl(self, other: u32) -> Self;\n    fn overflowing_add(self, other: Self) -> (Self, bool);\n    fn aborting_div(self, other: Self) -> Self;\n    fn aborting_rem(self, other: Self) -> Self;\n    fn leading_zeros(self) -> u32;\n}\n\nfn unwrap<T>(t: Option<T>) -> T {\n    match t {\n        Some(t) => t,\n        None => ::abort(),\n    }\n}\n\nmacro_rules! int_impl_common {\n    ($ty:ty, $bits:expr) => {\n            const BITS: u32 = $bits;\n\n            const ZERO: Self = 0;\n            const ONE: Self = 1;\n\n            fn from_bool(b: bool) -> Self {\n                b as $ty\n            }\n\n            fn max_value() -> Self {\n                <Self>::max_value()\n            }\n\n            fn min_value() -> Self {\n                <Self>::min_value()\n            }\n\n            fn wrapping_add(self, other: Self) -> Self {\n                <Self>::wrapping_add(self, other)\n            }\n\n            fn wrapping_mul(self, other: Self) -> Self {\n                <Self>::wrapping_mul(self, other)\n            }\n\n            fn wrapping_sub(self, other: Self) -> Self {\n                <Self>::wrapping_sub(self, other)\n            }\n\n            fn wrapping_shl(self, other: u32) -> Self {\n                <Self>::wrapping_shl(self, other)\n            }\n\n            fn overflowing_add(self, other: Self) -> (Self, bool) {\n                <Self>::overflowing_add(self, other)\n            }\n\n            fn aborting_div(self, other: Self) -> Self {\n                unwrap(<Self>::checked_div(self, other))\n            }\n\n            fn aborting_rem(self, other: Self) -> Self {\n                unwrap(<Self>::checked_rem(self, other))\n            }\n\n            fn leading_zeros(self) -> u32 {\n                <Self>::leading_zeros(self)\n            }\n    }\n}\n\nmacro_rules! int_impl {\n    ($ity:ty, $uty:ty, $bits:expr) => {\n        impl Int for $uty {\n            type OtherSign = $ity;\n            type UnsignedInt = $uty;\n\n            fn extract_sign(self) -> (bool, $uty) {\n                (false, self)\n            }\n\n            fn unsigned(self) -> $uty {\n                self\n            }\n\n            fn from_unsigned(me: $uty) -> Self {\n                me\n            }\n\n            int_impl_common!($uty, $bits);\n        }\n\n        impl Int for $ity {\n            type OtherSign = $uty;\n            type UnsignedInt = $uty;\n\n            fn extract_sign(self) -> (bool, $uty) {\n                if self < 0 {\n                    (true, (!(self as $uty)).wrapping_add(1))\n                } else {\n                    (false, self as $uty)\n                }\n            }\n\n            fn unsigned(self) -> $uty {\n                self as $uty\n            }\n\n            fn from_unsigned(me: $uty) -> Self {\n                me as $ity\n            }\n\n            int_impl_common!($ity, $bits);\n        }\n    }\n}\n\nint_impl!(i32, u32, 32);\nint_impl!(i64, u64, 64);\nint_impl!(i128, u128, 128);\n\n/// Trait to convert an integer to/from smaller parts\npub trait LargeInt: Int {\n    type LowHalf: Int;\n    type HighHalf: Int;\n\n    fn low(self) -> Self::LowHalf;\n    fn low_as_high(low: Self::LowHalf) -> Self::HighHalf;\n    fn high(self) -> Self::HighHalf;\n    fn high_as_low(low: Self::HighHalf) -> Self::LowHalf;\n    fn from_parts(low: Self::LowHalf, high: Self::HighHalf) -> Self;\n}\n\nmacro_rules! large_int {\n    ($ty:ty, $tylow:ty, $tyhigh:ty, $halfbits:expr) => {\n        impl LargeInt for $ty {\n            type LowHalf = $tylow;\n            type HighHalf = $tyhigh;\n\n            fn low(self) -> $tylow {\n                self as $tylow\n            }\n            fn low_as_high(low: $tylow) -> $tyhigh {\n                low as $tyhigh\n            }\n            fn high(self) -> $tyhigh {\n                (self >> $halfbits) as $tyhigh\n            }\n            fn high_as_low(high: $tyhigh) -> $tylow {\n                high as $tylow\n            }\n            fn from_parts(low: $tylow, high: $tyhigh) -> $ty {\n                low as $ty | ((high as $ty) << $halfbits)\n            }\n        }\n    }\n}\n\nlarge_int!(u64, u32, u32, 32);\nlarge_int!(i64, u32, i32, 32);\nlarge_int!(u128, u64, u64, 64);\nlarge_int!(i128, u64, i64, 64);\n\n/// Trait to express (possibly lossy) casting of integers\npub trait CastInto<T: Copy>: Copy {\n    fn cast(self) -> T;\n}\n\nmacro_rules! cast_into {\n    ($ty:ty) => {\n        cast_into!($ty; usize, isize, u32, i32, u64, i64, u128, i128);\n    };\n    ($ty:ty; $($into:ty),*) => {$(\n        impl CastInto<$into> for $ty {\n            fn cast(self) -> $into {\n                self as $into\n            }\n        }\n    )*};\n}\n\ncast_into!(u32);\ncast_into!(i32);\ncast_into!(u64);\ncast_into!(i64);\ncast_into!(u128);\ncast_into!(i128);\n\npub trait WideInt: Int {\n    type Output: Int;\n\n    fn wide_mul(self, other: Self) -> (Self, Self);\n    fn wide_shift_left(&mut self, low: &mut Self, count: i32);\n    fn wide_shift_right_with_sticky(&mut self, low: &mut Self, count: i32);\n}\n\nmacro_rules! impl_wide_int {\n    ($ty:ty, $tywide:ty, $bits:expr) => {\n        impl WideInt for $ty {\n            type Output = $ty;\n\n            fn wide_mul(self, other: Self) -> (Self, Self) {\n                let product = (self as $tywide).wrapping_mul(other as $tywide);\n                ((product >> ($bits as $ty)) as $ty, product as $ty)\n            }\n\n            fn wide_shift_left(&mut self, low: &mut Self, count: i32) {\n                *self = (*self << count) | (*low >> ($bits - count));\n                *low = *low << count;\n            }\n\n            fn wide_shift_right_with_sticky(&mut self, low: &mut Self, count: i32) {\n                if count < $bits {\n                    let sticky = *low << ($bits - count);\n                    *low = *self << ($bits - count) | *low >> count | sticky;\n                    *self = *self >> count;\n                } else if count < 2*$bits {\n                    let sticky = *self << (2*$bits - count) | *low;\n                    *low = *self >> (count - $bits ) | sticky;\n                    *self = 0;\n                } else {\n                    let sticky = *self | *low;\n                    *self = sticky;\n                    *self = 0;\n                }\n            }\n        }\n    }\n}\n\nimpl_wide_int!(u32, u64, 32);\nimpl_wide_int!(u64, u128, 64);\n","use int::LargeInt;\nuse int::Int;\n\ntrait UAddSub: LargeInt {\n    fn uadd(self, other: Self) -> Self {\n        let (low, carry) = self.low().overflowing_add(other.low());\n        let high = self.high().wrapping_add(other.high());\n        let carry = if carry { Self::HighHalf::ONE } else { Self::HighHalf::ZERO };\n        Self::from_parts(low, high.wrapping_add(carry))\n    }\n    fn uadd_one(self) -> Self {\n        let (low, carry) = self.low().overflowing_add(Self::LowHalf::ONE);\n        let carry = if carry { Self::HighHalf::ONE } else { Self::HighHalf::ZERO };\n        Self::from_parts(low, self.high().wrapping_add(carry))\n    }\n    fn usub(self, other: Self) -> Self {\n        let uneg = (!other).uadd_one();\n        self.uadd(uneg)\n    }\n}\n\nimpl UAddSub for u128 {}\n\ntrait AddSub: Int\n    where <Self as Int>::UnsignedInt: UAddSub\n{\n    fn add(self, other: Self) -> Self {\n        Self::from_unsigned(self.unsigned().uadd(other.unsigned()))\n    }\n    fn sub(self, other: Self) -> Self {\n        Self::from_unsigned(self.unsigned().usub(other.unsigned()))\n    }\n}\n\nimpl AddSub for u128 {}\nimpl AddSub for i128 {}\n\ntrait Addo: AddSub\n    where <Self as Int>::UnsignedInt: UAddSub\n{\n    fn addo(self, other: Self, overflow: &mut i32) -> Self {\n        *overflow = 0;\n        let result = AddSub::add(self, other);\n        if other >= Self::ZERO {\n            if result < self {\n                *overflow = 1;\n            }\n        } else {\n            if result >= self {\n                *overflow = 1;\n            }\n        }\n        result\n    }\n}\n\nimpl Addo for i128 {}\nimpl Addo for u128 {}\n\ntrait Subo: AddSub\n    where <Self as Int>::UnsignedInt: UAddSub\n{\n    fn subo(self, other: Self, overflow: &mut i32) -> Self {\n        *overflow = 0;\n        let result = AddSub::sub(self, other);\n        if other >= Self::ZERO {\n            if result > self {\n                *overflow = 1;\n            }\n        } else {\n            if result <= self {\n                *overflow = 1;\n            }\n        }\n        result\n    }\n}\n\nimpl Subo for i128 {}\nimpl Subo for u128 {}\n\nu128_lang_items! {\n    #[lang = \"i128_add\"]\n    pub fn rust_i128_add(a: i128, b: i128) -> i128 {\n        rust_u128_add(a as _, b as _) as _\n    }\n    #[lang = \"i128_addo\"]\n    pub fn rust_i128_addo(a: i128, b: i128) -> (i128, bool) {\n        let mut oflow = 0;\n        let r = a.addo(b, &mut oflow);\n        (r, oflow != 0)\n    }\n    #[lang = \"u128_add\"]\n    pub fn rust_u128_add(a: u128, b: u128) -> u128 {\n        a.add(b)\n    }\n    #[lang = \"u128_addo\"]\n    pub fn rust_u128_addo(a: u128, b: u128) -> (u128, bool) {\n        let mut oflow = 0;\n        let r = a.addo(b, &mut oflow);\n        (r, oflow != 0)\n    }\n\n    #[lang = \"i128_sub\"]\n    pub fn rust_i128_sub(a: i128, b: i128) -> i128 {\n        rust_u128_sub(a as _, b as _) as _\n    }\n    #[lang = \"i128_subo\"]\n    pub fn rust_i128_subo(a: i128, b: i128) -> (i128, bool) {\n        let mut oflow = 0;\n        let r = a.subo(b, &mut oflow);\n        (r, oflow != 0)\n    }\n    #[lang = \"u128_sub\"]\n    pub fn rust_u128_sub(a: u128, b: u128) -> u128 {\n        a.sub(b)\n    }\n    #[lang = \"u128_subo\"]\n    pub fn rust_u128_subo(a: u128, b: u128) -> (u128, bool) {\n        let mut oflow = 0;\n        let r = a.subo(b, &mut oflow);\n        (r, oflow != 0)\n    }\n}\n","//! Macros shared throughout the compiler-builtins implementation\n\n/// The \"main macro\" used for defining intrinsics.\n///\n/// The compiler-builtins library is super platform-specific with tons of crazy\n/// little tweaks for various platforms. As a result it *could* involve a lot of\n/// #[cfg] and macro soup, but the intention is that this macro alleviates a lot\n/// of that complexity. Ideally this macro has all the weird ABI things\n/// platforms need and elsewhere in this library it just looks like normal Rust\n/// code.\n///\n/// This macro is structured to be invoked with a bunch of functions that looks\n/// like:\n///\n///     intrinsics! {\n///         pub extern \"C\" fn foo(a: i32) -> u32 {\n///             // ...\n///         }\n///\n///         #[nonstandard_attribute]\n///         pub extern \"C\" fn bar(a: i32) -> u32 {\n///             // ...\n///         }\n///     }\n///\n/// Each function is defined in a manner that looks like a normal Rust function.\n/// The macro then accepts a few nonstandard attributes that can decorate\n/// various functions. Each of the attributes is documented below with what it\n/// can do, and each of them slightly tweaks how further expansion happens.\n///\n/// A quick overview of attributes supported right now are:\n///\n/// * `use_c_shim_if` - takes a #[cfg] directive and falls back to the\n///   C-compiled version if `use_c` is specified.\n/// * `aapcs_on_arm` - forces the ABI of the function to be `\"aapcs\"` on ARM and\n///   the specified ABI everywhere else.\n/// * `unadjusted_on_win64` - like `aapcs_on_arm` this switches to the\n///   `\"unadjusted\"` abi on Win64 and the specified abi elsewhere.\n/// * `win64_128bit_abi_hack` - this attribute is used for 128-bit integer\n///   intrinsics where the ABI is slightly tweaked on Windows platforms, but\n///   it's a normal ABI elsewhere for returning a 128 bit integer.\n/// * `arm_aeabi_alias` - handles the \"aliasing\" of various intrinsics on ARM\n///   their otherwise typical names to other prefixed ones.\n///\nmacro_rules! intrinsics {\n    () => ();\n\n    // Right now there's a bunch of architecture-optimized intrinsics in the\n    // stock compiler-rt implementation. Not all of these have been ported over\n    // to Rust yet so when the `c` feature of this crate is enabled we fall back\n    // to the architecture-specific versions which should be more optimized. The\n    // purpose of this macro is to easily allow specifying this.\n    //\n    // The argument to `use_c_shim_if` is a `#[cfg]` directive which, when true,\n    // will cause this crate's exported version of `$name` to just redirect to\n    // the C implementation. No symbol named `$name` will be in the object file\n    // for this crate itself.\n    //\n    // When the `#[cfg]` directive is false, or when the `c` feature is\n    // disabled, the provided implementation is used instead.\n    (\n        #[use_c_shim_if($($cfg_clause:tt)*)]\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n\n        #[cfg(all(use_c, $($cfg_clause)*))]\n        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n            extern $abi {\n                fn $name($($argname: $ty),*) -> $ret;\n            }\n            unsafe {\n                $name($($argname),*)\n            }\n        }\n\n        #[cfg(not(all(use_c, $($cfg_clause)*)))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        intrinsics!($($rest)*);\n    );\n\n    // We recognize the `#[aapcs_on_arm]` attribute here and generate the\n    // same intrinsic but force it to have the `\"aapcs\"` calling convention on\n    // ARM and `\"C\"` elsewhere.\n    (\n        #[aapcs_on_arm]\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n        #[cfg(target_arch = \"arm\")]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern \"aapcs\" fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        #[cfg(not(target_arch = \"arm\"))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        intrinsics!($($rest)*);\n    );\n\n    // Like aapcs above we recognize an attribute for the \"unadjusted\" abi on\n    // win64 for some methods.\n    (\n        #[unadjusted_on_win64]\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n        #[cfg(all(windows, target_pointer_width = \"64\"))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern \"unadjusted\" fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        #[cfg(not(all(windows, target_pointer_width = \"64\")))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        intrinsics!($($rest)*);\n    );\n\n    // Some intrinsics on win64 which return a 128-bit integer have an.. unusual\n    // calling convention. That's managed here with this \"abi hack\" which alters\n    // the generated symbol's ABI.\n    //\n    // This will still define a function in this crate with the given name and\n    // signature, but the actual symbol for the intrinsic may have a slightly\n    // different ABI on win64.\n    (\n        #[win64_128bit_abi_hack]\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n        #[cfg(all(windows, target_pointer_width = \"64\"))]\n        $(#[$($attr)*])*\n        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n            $($body)*\n        }\n\n        #[cfg(all(windows, target_pointer_width = \"64\"))]\n        pub mod $name {\n\n            intrinsics! {\n                pub extern $abi fn $name( $($argname: $ty),* )\n                    -> ::macros::win64_128bit_abi_hack::U64x2\n                {\n                    let e: $ret = super::$name($($argname),*);\n                    ::macros::win64_128bit_abi_hack::U64x2::from(e)\n                }\n            }\n        }\n\n        #[cfg(not(all(windows, target_pointer_width = \"64\")))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        intrinsics!($($rest)*);\n    );\n\n    // A bunch of intrinsics on ARM are aliased in the standard compiler-rt\n    // build under `__aeabi_*` aliases, and LLVM will call these instead of the\n    // original function. The aliasing here is used to generate these symbols in\n    // the object file.\n    (\n        #[arm_aeabi_alias = $alias:ident]\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n        #[cfg(target_arch = \"arm\")]\n        #[cfg_attr(not(feature = \"mangled-names\"), no_mangle)]\n        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n            $($body)*\n        }\n\n        #[cfg(target_arch = \"arm\")]\n        pub mod $name {\n            intrinsics! {\n                pub extern \"aapcs\" fn $alias( $($argname: $ty),* ) -> $ret {\n                    super::$name($($argname),*)\n                }\n            }\n        }\n\n        #[cfg(not(target_arch = \"arm\"))]\n        intrinsics! {\n            $(#[$($attr)*])*\n            pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n                $($body)*\n            }\n        }\n\n        intrinsics!($($rest)*);\n    );\n\n    // This is the final catch-all rule. At this point we just generate an\n    // intrinsic with a conditional `#[no_mangle]` directive to avoid\n    // interfereing with duplicate symbols and whatnot during testing.\n    //\n    // After the intrinsic is defined we just continue with the rest of the\n    // input we were given.\n    (\n        $(#[$($attr:tt)*])*\n        pub extern $abi:tt fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n\n        $($rest:tt)*\n    ) => (\n        $(#[$($attr)*])*\n        #[cfg_attr(not(feature = \"mangled-names\"), no_mangle)]\n        pub extern $abi fn $name( $($argname: $ty),* ) -> $ret {\n            $($body)*\n        }\n\n        intrinsics!($($rest)*);\n    );\n}\n\n// Hack for LLVM expectations for ABI on windows. This is used by the\n// `#[win64_128bit_abi_hack]` attribute recognized above\n#[cfg(all(windows, target_pointer_width=\"64\"))]\npub mod win64_128bit_abi_hack {\n    #[repr(simd)]\n    pub struct U64x2(u64, u64);\n\n    impl From<i128> for U64x2 {\n        fn from(i: i128) -> U64x2 {\n            use int::LargeInt;\n            let j = i as u128;\n            U64x2(j.low(), j.high())\n        }\n    }\n\n    impl From<u128> for U64x2 {\n        fn from(i: u128) -> U64x2 {\n            use int::LargeInt;\n            U64x2(i.low(), i.high())\n        }\n    }\n}\n\nmacro_rules! u128_lang_items {\n    ($(\n        #[lang = $lang:tt]\n        pub fn $name:ident( $($argname:ident:  $ty:ty),* ) -> $ret:ty {\n            $($body:tt)*\n        }\n    )*) => ($(\n        #[cfg_attr(not(any(stage0, feature = \"no-lang-items\")), lang = $lang)]\n        pub fn $name( $($argname:  $ty),* ) -> $ret {\n            $($body)*\n        }\n    )*)\n}\n","use core::ops;\n\nuse int::LargeInt;\nuse int::Int;\n\ntrait Mul: LargeInt {\n    fn mul(self, other: Self) -> Self {\n        let half_bits = Self::BITS / 4;\n        let lower_mask = !<<Self as LargeInt>::LowHalf>::ZERO >> half_bits;\n        let mut low = (self.low() & lower_mask).wrapping_mul(other.low() & lower_mask);\n        let mut t = low >> half_bits;\n        low &= lower_mask;\n        t += (self.low() >> half_bits).wrapping_mul(other.low() & lower_mask);\n        low += (t & lower_mask) << half_bits;\n        let mut high = Self::low_as_high(t >> half_bits);\n        t = low >> half_bits;\n        low &= lower_mask;\n        t += (other.low() >> half_bits).wrapping_mul(self.low() & lower_mask);\n        low += (t & lower_mask) << half_bits;\n        high += Self::low_as_high(t >> half_bits);\n        high += Self::low_as_high((self.low() >> half_bits).wrapping_mul(other.low() >> half_bits));\n        high = high.wrapping_add(self.high().wrapping_mul(Self::low_as_high(other.low())))\n                   .wrapping_add(Self::low_as_high(self.low()).wrapping_mul(other.high()));\n        Self::from_parts(low, high)\n    }\n}\n\nimpl Mul for u64 {}\nimpl Mul for i128 {}\n\ntrait Mulo: Int + ops::Neg<Output = Self> {\n    fn mulo(self, other: Self, overflow: &mut i32) -> Self {\n        *overflow = 0;\n        let result = self.wrapping_mul(other);\n        if self == Self::min_value() {\n            if other != Self::ZERO && other != Self::ONE {\n                *overflow = 1;\n            }\n            return result;\n        }\n        if other == Self::min_value() {\n            if self != Self::ZERO && self != Self::ONE {\n                *overflow = 1;\n            }\n            return result;\n        }\n\n        let sa = self >> (Self::BITS - 1);\n        let abs_a = (self ^ sa) - sa;\n        let sb = other >> (Self::BITS - 1);\n        let abs_b = (other ^ sb) - sb;\n        let two = Self::ONE + Self::ONE;\n        if abs_a < two || abs_b < two {\n            return result;\n        }\n        if sa == sb {\n            if abs_a > Self::max_value().aborting_div(abs_b) {\n                *overflow = 1;\n            }\n        } else {\n            if abs_a > Self::min_value().aborting_div(-abs_b) {\n                *overflow = 1;\n            }\n        }\n        result\n    }\n}\n\nimpl Mulo for i32 {}\nimpl Mulo for i64 {}\nimpl Mulo for i128 {}\n\ntrait UMulo : Int {\n    fn mulo(self, other: Self, overflow: &mut i32) -> Self {\n        *overflow = 0;\n        let result = self.wrapping_mul(other);\n        if self > Self::max_value().aborting_div(other) {\n            *overflow = 1;\n        }\n        result\n    }\n}\nimpl UMulo for u128 {}\n\nintrinsics! {\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    #[arm_aeabi_alias = __aeabi_lmul]\n    pub extern \"C\" fn __muldi3(a: u64, b: u64) -> u64 {\n        a.mul(b)\n    }\n\n    #[aapcs_on_arm]\n    pub extern \"C\" fn __multi3(a: i128, b: i128) -> i128 {\n        a.mul(b)\n    }\n\n    pub extern \"C\" fn __mulosi4(a: i32, b: i32, oflow: &mut i32) -> i32 {\n        a.mulo(b, oflow)\n    }\n\n    pub extern \"C\" fn __mulodi4(a: i64, b: i64, oflow: &mut i32) -> i64 {\n        a.mulo(b, oflow)\n    }\n\n    #[unadjusted_on_win64]\n    pub extern \"C\" fn __muloti4(a: i128, b: i128, oflow: &mut i32) -> i128 {\n        a.mulo(b, oflow)\n    }\n}\n\nu128_lang_items! {\n    #[lang = \"i128_mul\"]\n    pub fn rust_i128_mul(a: i128, b: i128) -> i128 {\n        __multi3(a, b)\n    }\n    #[lang = \"i128_mulo\"]\n    pub fn rust_i128_mulo(a: i128, b: i128) -> (i128, bool) {\n        let mut oflow = 0;\n        let r = __muloti4(a, b, &mut oflow);\n        (r, oflow != 0)\n    }\n    #[lang = \"u128_mul\"]\n    pub fn rust_u128_mul(a: u128, b: u128) -> u128 {\n        __multi3(a as _, b as _) as _\n    }\n    #[lang = \"u128_mulo\"]\n    pub fn rust_u128_mulo(a: u128, b: u128) -> (u128, bool) {\n        let mut oflow = 0;\n        let r = a.mulo(b, &mut oflow);\n        (r, oflow != 0)\n    }\n}\n","use int::Int;\n\ntrait Div: Int {\n    /// Returns `a / b`\n    fn div(self, other: Self) -> Self {\n        let s_a = self >> (Self::BITS - 1);\n        let s_b = other >> (Self::BITS - 1);\n        // NOTE it's OK to overflow here because of the `.unsigned()` below.\n        // This whole operation is computing the absolute value of the inputs\n        // So some overflow will happen when dealing with e.g. `i64::MIN`\n        // where the absolute value is `(-i64::MIN) as u64`\n        let a = (self ^ s_a).wrapping_sub(s_a);\n        let b = (other ^ s_b).wrapping_sub(s_b);\n        let s = s_a ^ s_b;\n\n        let r = a.unsigned().aborting_div(b.unsigned());\n        (Self::from_unsigned(r) ^ s) - s\n    }\n}\n\nimpl Div for i32 {}\nimpl Div for i64 {}\nimpl Div for i128 {}\n\ntrait Mod: Int {\n    /// Returns `a % b`\n    fn mod_(self, other: Self) -> Self {\n        let s = other >> (Self::BITS - 1);\n        // NOTE(wrapping_sub) see comment in the `div`\n        let b = (other ^ s).wrapping_sub(s);\n        let s = self >> (Self::BITS - 1);\n        let a = (self ^ s).wrapping_sub(s);\n\n        let r = a.unsigned().aborting_rem(b.unsigned());\n        (Self::from_unsigned(r) ^ s) - s\n    }\n}\n\nimpl Mod for i32 {}\nimpl Mod for i64 {}\nimpl Mod for i128 {}\n\ntrait Divmod: Int {\n    /// Returns `a / b` and sets `*rem = n % d`\n    fn divmod<F>(self, other: Self, rem: &mut Self, div: F) -> Self\n        where F: Fn(Self, Self) -> Self,\n    {\n        let r = div(self, other);\n        // NOTE won't overflow because it's using the result from the\n        // previous division\n        *rem = self - r.wrapping_mul(other);\n        r\n    }\n}\n\nimpl Divmod for i32 {}\nimpl Divmod for i64 {}\n\nintrinsics! {\n    #[arm_aeabi_alias = __aeabi_idiv]\n    pub extern \"C\" fn __divsi3(a: i32, b: i32) -> i32 {\n        a.div(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    pub extern \"C\" fn __divdi3(a: i64, b: i64) -> i64 {\n        a.div(b)\n    }\n\n    #[win64_128bit_abi_hack]\n    pub extern \"C\" fn __divti3(a: i128, b: i128) -> i128 {\n        a.div(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"arm\",\n                    not(target_os = \"ios\"),\n                    not(target_env = \"msvc\")),\n                    not(thumbv6m))]\n    pub extern \"C\" fn __modsi3(a: i32, b: i32) -> i32 {\n        a.mod_(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    pub extern \"C\" fn __moddi3(a: i64, b: i64) -> i64 {\n        a.mod_(b)\n    }\n\n    #[win64_128bit_abi_hack]\n    pub extern \"C\" fn __modti3(a: i128, b: i128) -> i128 {\n        a.mod_(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"arm\", not(target_env = \"msvc\"),\n                    not(target_os = \"ios\"), not(thumbv6m)))]\n    pub extern \"C\" fn __divmodsi4(a: i32, b: i32, rem: &mut i32) -> i32 {\n        a.divmod(b, rem, |a, b| __divsi3(a, b))\n    }\n\n    #[aapcs_on_arm]\n    pub extern \"C\" fn __divmoddi4(a: i64, b: i64, rem: &mut i64) -> i64 {\n        a.divmod(b, rem, |a, b| __divdi3(a, b))\n    }\n}\n\nu128_lang_items! {\n    #[lang = \"i128_div\"]\n    pub fn rust_i128_div(a: i128, b: i128) -> i128 {\n        __divti3(a, b)\n    }\n    #[lang = \"i128_rem\"]\n    pub fn rust_i128_rem(a: i128, b: i128) -> i128 {\n        __modti3(a, b)\n    }\n}\n","use int::{Int, LargeInt};\n\ntrait Ashl: Int + LargeInt {\n    /// Returns `a << b`, requires `b < Self::BITS`\n    fn ashl(self, offset: u32) -> Self\n        where Self: LargeInt<HighHalf = <Self as LargeInt>::LowHalf>,\n    {\n        let half_bits = Self::BITS / 2;\n        if offset & half_bits != 0 {\n            Self::from_parts(Int::ZERO, self.low() << (offset - half_bits))\n        } else if offset == 0 {\n            self\n        } else {\n            Self::from_parts(self.low() << offset,\n                             (self.high() << offset) |\n                                (self.low() >> (half_bits - offset)))\n        }\n    }\n}\n\nimpl Ashl for u64 {}\nimpl Ashl for u128 {}\n\ntrait Ashr: Int + LargeInt {\n    /// Returns arithmetic `a >> b`, requires `b < Self::BITS`\n    fn ashr(self, offset: u32) -> Self\n        where Self: LargeInt<LowHalf = <<Self as LargeInt>::HighHalf as Int>::UnsignedInt>,\n    {\n        let half_bits = Self::BITS / 2;\n        if offset & half_bits != 0 {\n            Self::from_parts((self.high() >> (offset - half_bits)).unsigned(),\n                              self.high() >> (half_bits - 1))\n        } else if offset == 0 {\n            self\n        } else {\n            let high_unsigned = self.high().unsigned();\n            Self::from_parts((high_unsigned << (half_bits - offset)) | (self.low() >> offset),\n                              self.high() >> offset)\n        }\n    }\n}\n\nimpl Ashr for i64 {}\nimpl Ashr for i128 {}\n\ntrait Lshr: Int + LargeInt {\n    /// Returns logical `a >> b`, requires `b < Self::BITS`\n    fn lshr(self, offset: u32) -> Self\n        where Self: LargeInt<HighHalf = <Self as LargeInt>::LowHalf>,\n    {\n        let half_bits = Self::BITS / 2;\n        if offset & half_bits != 0 {\n            Self::from_parts(self.high() >> (offset - half_bits), Int::ZERO)\n        } else if offset == 0 {\n            self\n        } else {\n            Self::from_parts((self.high() << (half_bits - offset)) |\n                                (self.low() >> offset),\n                             self.high() >> offset)\n        }\n    }\n}\n\nimpl Lshr for u64 {}\nimpl Lshr for u128 {}\n\nintrinsics! {\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    #[arm_aeabi_alias = __aeabi_llsl]\n    pub extern \"C\" fn __ashldi3(a: u64, b: u32) -> u64 {\n        a.ashl(b)\n    }\n\n    pub extern \"C\" fn __ashlti3(a: u128, b: u32) -> u128 {\n        a.ashl(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    #[arm_aeabi_alias = __aeabi_lasr]\n    pub extern \"C\" fn __ashrdi3(a: i64, b: u32) -> i64 {\n        a.ashr(b)\n    }\n\n    pub extern \"C\" fn __ashrti3(a: i128, b: u32) -> i128 {\n        a.ashr(b)\n    }\n\n    #[use_c_shim_if(all(target_arch = \"x86\", not(target_env = \"msvc\")))]\n    #[arm_aeabi_alias = __aeabi_llsr]\n    pub extern \"C\" fn __lshrdi3(a: u64, b: u32) -> u64 {\n        a.lshr(b)\n    }\n\n    pub extern \"C\" fn __lshrti3(a: u128, b: u32) -> u128 {\n        a.lshr(b)\n    }\n}\n\nu128_lang_items! {\n    #[lang = \"i128_shl\"]\n    pub fn rust_i128_shl(a: i128, b: u32) -> i128 {\n        __ashlti3(a as _, b) as _\n    }\n    #[lang = \"i128_shlo\"]\n    pub fn rust_i128_shlo(a: i128, b: u128) -> (i128, bool) {\n        (rust_i128_shl(a, b as _), b >= 128)\n    }\n    #[lang = \"u128_shl\"]\n    pub fn rust_u128_shl(a: u128, b: u32) -> u128 {\n        __ashlti3(a, b)\n    }\n    #[lang = \"u128_shlo\"]\n    pub fn rust_u128_shlo(a: u128, b: u128) -> (u128, bool) {\n        (rust_u128_shl(a, b as _), b >= 128)\n    }\n\n    #[lang = \"i128_shr\"]\n    pub fn rust_i128_shr(a: i128, b: u32) -> i128 {\n        __ashrti3(a, b)\n    }\n    #[lang = \"i128_shro\"]\n    pub fn rust_i128_shro(a: i128, b: u128) -> (i128, bool) {\n        (rust_i128_shr(a, b as _), b >= 128)\n    }\n    #[lang = \"u128_shr\"]\n    pub fn rust_u128_shr(a: u128, b: u32) -> u128 {\n        __lshrti3(a, b)\n    }\n    #[lang = \"u128_shro\"]\n    pub fn rust_u128_shro(a: u128, b: u128) -> (u128, bool) {\n        (rust_u128_shr(a, b as _), b >= 128)\n    }\n}\n","#![cfg_attr(not(stage0), deny(warnings))]\n#![cfg_attr(not(test), no_std)]\n#![cfg_attr(feature = \"compiler-builtins\", compiler_builtins)]\n#![crate_name = \"compiler_builtins\"]\n#![crate_type = \"rlib\"]\n#![doc(html_logo_url = \"https://www.rust-lang.org/logos/rust-logo-128x128-blk.png\",\n       html_favicon_url = \"https://doc.rust-lang.org/favicon.ico\",\n       html_root_url = \"https://doc.rust-lang.org/nightly/\",\n       html_playground_url = \"https://play.rust-lang.org/\",\n       test(attr(deny(warnings))))]\n#![feature(asm)]\n#![feature(compiler_builtins)]\n#![feature(core_intrinsics)]\n#![feature(naked_functions)]\n#![feature(repr_simd)]\n#![feature(abi_unadjusted)]\n#![feature(linkage)]\n#![feature(lang_items)]\n#![allow(unused_features)]\n#![no_builtins]\n#![cfg_attr(feature = \"compiler-builtins\", feature(staged_api))]\n#![cfg_attr(feature = \"compiler-builtins\",\n            unstable(feature = \"compiler_builtins_lib\",\n                     reason = \"Compiler builtins. Will never become stable.\",\n                     issue = \"0\"))]\n\n// We disable #[no_mangle] for tests so that we can verify the test results\n// against the native compiler-rt implementations of the builtins.\n\n// NOTE cfg(all(feature = \"c\", ..)) indicate that compiler-rt provides an arch optimized\n// implementation of that intrinsic and we'll prefer to use that\n\n// NOTE(aapcs, aeabi, arm) ARM targets use intrinsics named __aeabi_* instead of the intrinsics\n// that follow \"x86 naming convention\" (e.g. addsf3). Those aeabi intrinsics must adhere to the\n// AAPCS calling convention (`extern \"aapcs\"`) because that's how LLVM will call them.\n\n#[cfg(test)]\nextern crate core;\n\nfn abort() -> ! {\n    unsafe { core::intrinsics::abort() }\n}\n\n#[macro_use]\nmod macros;\n\npub mod int;\npub mod float;\n\n#[cfg(any(all(target_arch = \"wasm32\", target_os = \"unknown\"),\n          all(target_arch = \"arm\", target_os = \"none\")))]\npub mod math;\npub mod mem;\n\n#[cfg(target_arch = \"arm\")]\npub mod arm;\n\n#[cfg(all(kernel_user_helpers, target_os = \"linux\", target_arch = \"arm\"))]\npub mod arm_linux;\n\n#[cfg(any(target_arch = \"riscv32\"))]\npub mod riscv32;\n\n#[cfg(target_arch = \"x86\")]\npub mod x86;\n\n#[cfg(target_arch = \"x86_64\")]\npub mod x86_64;\n\npub mod probestack;\n","// Copyright 2012 The Rust Project Developers. See the COPYRIGHT\n// file at the top-level directory of this distribution and at\n// http://rust-lang.org/COPYRIGHT.\n//\n// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or\n// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license\n// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your\n// option. This file may not be copied, modified, or distributed\n// except according to those terms.\n\n/// The unary logical negation operator `!`.\n///\n/// # Examples\n///\n/// An implementation of `Not` for `Answer`, which enables the use of `!` to\n/// invert its value.\n///\n/// ```\n/// use std::ops::Not;\n///\n/// #[derive(Debug, PartialEq)]\n/// enum Answer {\n///     Yes,\n///     No,\n/// }\n///\n/// impl Not for Answer {\n///     type Output = Answer;\n///\n///     fn not(self) -> Answer {\n///         match self {\n///             Answer::Yes => Answer::No,\n///             Answer::No => Answer::Yes\n///         }\n///     }\n/// }\n///\n/// assert_eq!(!Answer::Yes, Answer::No);\n/// assert_eq!(!Answer::No, Answer::Yes);\n/// ```\n#[lang = \"not\"]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\npub trait Not {\n    /// The resulting type after applying the `!` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the unary `!` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn not(self) -> Self::Output;\n}\n\nmacro_rules! not_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Not for $t {\n            type Output = $t;\n\n            #[inline]\n            fn not(self) -> $t { !self }\n        }\n\n        forward_ref_unop! { impl Not, not for $t }\n    )*)\n}\n\nnot_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The bitwise AND operator `&`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// An implementation of `BitAnd` for a wrapper around `bool`.\n///\n/// ```\n/// use std::ops::BitAnd;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(bool);\n///\n/// impl BitAnd for Scalar {\n///     type Output = Self;\n///\n///     // rhs is the \"right-hand side\" of the expression `a & b`\n///     fn bitand(self, rhs: Self) -> Self {\n///         Scalar(self.0 & rhs.0)\n///     }\n/// }\n///\n/// assert_eq!(Scalar(true) & Scalar(true), Scalar(true));\n/// assert_eq!(Scalar(true) & Scalar(false), Scalar(false));\n/// assert_eq!(Scalar(false) & Scalar(true), Scalar(false));\n/// assert_eq!(Scalar(false) & Scalar(false), Scalar(false));\n/// ```\n///\n/// An implementation of `BitAnd` for a wrapper around `Vec<bool>`.\n///\n/// ```\n/// use std::ops::BitAnd;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct BooleanVector(Vec<bool>);\n///\n/// impl BitAnd for BooleanVector {\n///     type Output = Self;\n///\n///     fn bitand(self, BooleanVector(rhs): Self) -> Self {\n///         let BooleanVector(lhs) = self;\n///         assert_eq!(lhs.len(), rhs.len());\n///         BooleanVector(lhs.iter().zip(rhs.iter()).map(|(x, y)| *x && *y).collect())\n///     }\n/// }\n///\n/// let bv1 = BooleanVector(vec![true, true, false, false]);\n/// let bv2 = BooleanVector(vec![true, false, true, false]);\n/// let expected = BooleanVector(vec![true, false, false, false]);\n/// assert_eq!(bv1 & bv2, expected);\n/// ```\n#[lang = \"bitand\"]\n#[doc(alias = \"&\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} & {RHS}`\",\n                         label=\"no implementation for `{Self} & {RHS}`\")]\npub trait BitAnd<RHS=Self> {\n    /// The resulting type after applying the `&` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `&` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn bitand(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! bitand_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl BitAnd for $t {\n            type Output = $t;\n\n            #[inline]\n            fn bitand(self, rhs: $t) -> $t { self & rhs }\n        }\n\n        forward_ref_binop! { impl BitAnd, bitand for $t, $t }\n    )*)\n}\n\nbitand_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The bitwise OR operator `|`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// An implementation of `BitOr` for a wrapper around `bool`.\n///\n/// ```\n/// use std::ops::BitOr;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(bool);\n///\n/// impl BitOr for Scalar {\n///     type Output = Self;\n///\n///     // rhs is the \"right-hand side\" of the expression `a | b`\n///     fn bitor(self, rhs: Self) -> Self {\n///         Scalar(self.0 | rhs.0)\n///     }\n/// }\n///\n/// assert_eq!(Scalar(true) | Scalar(true), Scalar(true));\n/// assert_eq!(Scalar(true) | Scalar(false), Scalar(true));\n/// assert_eq!(Scalar(false) | Scalar(true), Scalar(true));\n/// assert_eq!(Scalar(false) | Scalar(false), Scalar(false));\n/// ```\n///\n/// An implementation of `BitOr` for a wrapper around `Vec<bool>`.\n///\n/// ```\n/// use std::ops::BitOr;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct BooleanVector(Vec<bool>);\n///\n/// impl BitOr for BooleanVector {\n///     type Output = Self;\n///\n///     fn bitor(self, BooleanVector(rhs): Self) -> Self {\n///         let BooleanVector(lhs) = self;\n///         assert_eq!(lhs.len(), rhs.len());\n///         BooleanVector(lhs.iter().zip(rhs.iter()).map(|(x, y)| *x || *y).collect())\n///     }\n/// }\n///\n/// let bv1 = BooleanVector(vec![true, true, false, false]);\n/// let bv2 = BooleanVector(vec![true, false, true, false]);\n/// let expected = BooleanVector(vec![true, true, true, false]);\n/// assert_eq!(bv1 | bv2, expected);\n/// ```\n#[lang = \"bitor\"]\n#[doc(alias = \"|\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} | {RHS}`\",\n                         label=\"no implementation for `{Self} | {RHS}`\")]\npub trait BitOr<RHS=Self> {\n    /// The resulting type after applying the `|` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `|` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn bitor(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! bitor_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl BitOr for $t {\n            type Output = $t;\n\n            #[inline]\n            fn bitor(self, rhs: $t) -> $t { self | rhs }\n        }\n\n        forward_ref_binop! { impl BitOr, bitor for $t, $t }\n    )*)\n}\n\nbitor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The bitwise XOR operator `^`.\n///\n/// Note that `RHS` is `Self` by default, but this is not mandatory.\n///\n/// # Examples\n///\n/// An implementation of `BitXor` that lifts `^` to a wrapper around `bool`.\n///\n/// ```\n/// use std::ops::BitXor;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(bool);\n///\n/// impl BitXor for Scalar {\n///     type Output = Self;\n///\n///     // rhs is the \"right-hand side\" of the expression `a ^ b`\n///     fn bitxor(self, rhs: Self) -> Self {\n///         Scalar(self.0 ^ rhs.0)\n///     }\n/// }\n///\n/// assert_eq!(Scalar(true) ^ Scalar(true), Scalar(false));\n/// assert_eq!(Scalar(true) ^ Scalar(false), Scalar(true));\n/// assert_eq!(Scalar(false) ^ Scalar(true), Scalar(true));\n/// assert_eq!(Scalar(false) ^ Scalar(false), Scalar(false));\n/// ```\n///\n/// An implementation of `BitXor` trait for a wrapper around `Vec<bool>`.\n///\n/// ```\n/// use std::ops::BitXor;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct BooleanVector(Vec<bool>);\n///\n/// impl BitXor for BooleanVector {\n///     type Output = Self;\n///\n///     fn bitxor(self, BooleanVector(rhs): Self) -> Self {\n///         let BooleanVector(lhs) = self;\n///         assert_eq!(lhs.len(), rhs.len());\n///         BooleanVector(lhs.iter()\n///                          .zip(rhs.iter())\n///                          .map(|(x, y)| (*x || *y) && !(*x && *y))\n///                          .collect())\n///     }\n/// }\n///\n/// let bv1 = BooleanVector(vec![true, true, false, false]);\n/// let bv2 = BooleanVector(vec![true, false, true, false]);\n/// let expected = BooleanVector(vec![false, true, true, false]);\n/// assert_eq!(bv1 ^ bv2, expected);\n/// ```\n#[lang = \"bitxor\"]\n#[doc(alias = \"^\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} ^ {RHS}`\",\n                         label=\"no implementation for `{Self} ^ {RHS}`\")]\npub trait BitXor<RHS=Self> {\n    /// The resulting type after applying the `^` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `^` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn bitxor(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! bitxor_impl {\n    ($($t:ty)*) => ($(\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl BitXor for $t {\n            type Output = $t;\n\n            #[inline]\n            fn bitxor(self, other: $t) -> $t { self ^ other }\n        }\n\n        forward_ref_binop! { impl BitXor, bitxor for $t, $t }\n    )*)\n}\n\nbitxor_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The left shift operator `<<`. Note that because this trait is implemented\n/// for all integer types with multiple right-hand-side types, Rust's type\n/// checker has special handling for `_ << _`, setting the result type for\n/// integer operations to the type of the left-hand-side operand. This means\n/// that though `a << b` and `a.shl(b)` are one and the same from an evaluation\n/// standpoint, they are different when it comes to type inference.\n///\n/// # Examples\n///\n/// An implementation of `Shl` that lifts the `<<` operation on integers to a\n/// wrapper around `usize`.\n///\n/// ```\n/// use std::ops::Shl;\n///\n/// #[derive(PartialEq, Debug)]\n/// struct Scalar(usize);\n///\n/// impl Shl<Scalar> for Scalar {\n///     type Output = Self;\n///\n///     fn shl(self, Scalar(rhs): Self) -> Scalar {\n///         let Scalar(lhs) = self;\n///         Scalar(lhs << rhs)\n///     }\n/// }\n///\n/// assert_eq!(Scalar(4) << Scalar(2), Scalar(16));\n/// ```\n///\n/// An implementation of `Shl` that spins a vector leftward by a given amount.\n///\n/// ```\n/// use std::ops::Shl;\n///\n/// #[derive(PartialEq, Debug)]\n/// struct SpinVector<T: Clone> {\n///     vec: Vec<T>,\n/// }\n///\n/// impl<T: Clone> Shl<usize> for SpinVector<T> {\n///     type Output = Self;\n///\n///     fn shl(self, rhs: usize) -> SpinVector<T> {\n///         // Rotate the vector by `rhs` places.\n///         let (a, b) = self.vec.split_at(rhs);\n///         let mut spun_vector: Vec<T> = vec![];\n///         spun_vector.extend_from_slice(b);\n///         spun_vector.extend_from_slice(a);\n///         SpinVector { vec: spun_vector }\n///     }\n/// }\n///\n/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } << 2,\n///            SpinVector { vec: vec![2, 3, 4, 0, 1] });\n/// ```\n#[lang = \"shl\"]\n#[doc(alias = \"<<\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} << {RHS}`\",\n                         label=\"no implementation for `{Self} << {RHS}`\")]\npub trait Shl<RHS=Self> {\n    /// The resulting type after applying the `<<` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `<<` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn shl(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! shl_impl {\n    ($t:ty, $f:ty) => (\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Shl<$f> for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn shl(self, other: $f) -> $t {\n                self << other\n            }\n        }\n\n        forward_ref_binop! { impl Shl, shl for $t, $f }\n    )\n}\n\nmacro_rules! shl_impl_all {\n    ($($t:ty)*) => ($(\n        shl_impl! { $t, u8 }\n        shl_impl! { $t, u16 }\n        shl_impl! { $t, u32 }\n        shl_impl! { $t, u64 }\n        shl_impl! { $t, u128 }\n        shl_impl! { $t, usize }\n\n        shl_impl! { $t, i8 }\n        shl_impl! { $t, i16 }\n        shl_impl! { $t, i32 }\n        shl_impl! { $t, i64 }\n        shl_impl! { $t, i128 }\n        shl_impl! { $t, isize }\n    )*)\n}\n\nshl_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 isize i128 }\n\n/// The right shift operator `>>`. Note that because this trait is implemented\n/// for all integer types with multiple right-hand-side types, Rust's type\n/// checker has special handling for `_ >> _`, setting the result type for\n/// integer operations to the type of the left-hand-side operand. This means\n/// that though `a >> b` and `a.shr(b)` are one and the same from an evaluation\n/// standpoint, they are different when it comes to type inference.\n///\n/// # Examples\n///\n/// An implementation of `Shr` that lifts the `>>` operation on integers to a\n/// wrapper around `usize`.\n///\n/// ```\n/// use std::ops::Shr;\n///\n/// #[derive(PartialEq, Debug)]\n/// struct Scalar(usize);\n///\n/// impl Shr<Scalar> for Scalar {\n///     type Output = Self;\n///\n///     fn shr(self, Scalar(rhs): Self) -> Scalar {\n///         let Scalar(lhs) = self;\n///         Scalar(lhs >> rhs)\n///     }\n/// }\n///\n/// assert_eq!(Scalar(16) >> Scalar(2), Scalar(4));\n/// ```\n///\n/// An implementation of `Shr` that spins a vector rightward by a given amount.\n///\n/// ```\n/// use std::ops::Shr;\n///\n/// #[derive(PartialEq, Debug)]\n/// struct SpinVector<T: Clone> {\n///     vec: Vec<T>,\n/// }\n///\n/// impl<T: Clone> Shr<usize> for SpinVector<T> {\n///     type Output = Self;\n///\n///     fn shr(self, rhs: usize) -> SpinVector<T> {\n///         // Rotate the vector by `rhs` places.\n///         let (a, b) = self.vec.split_at(self.vec.len() - rhs);\n///         let mut spun_vector: Vec<T> = vec![];\n///         spun_vector.extend_from_slice(b);\n///         spun_vector.extend_from_slice(a);\n///         SpinVector { vec: spun_vector }\n///     }\n/// }\n///\n/// assert_eq!(SpinVector { vec: vec![0, 1, 2, 3, 4] } >> 2,\n///            SpinVector { vec: vec![3, 4, 0, 1, 2] });\n/// ```\n#[lang = \"shr\"]\n#[doc(alias = \">>\")]\n#[stable(feature = \"rust1\", since = \"1.0.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} >> {RHS}`\",\n                         label=\"no implementation for `{Self} >> {RHS}`\")]\npub trait Shr<RHS=Self> {\n    /// The resulting type after applying the `>>` operator.\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    type Output;\n\n    /// Performs the `>>` operation.\n    #[must_use]\n    #[stable(feature = \"rust1\", since = \"1.0.0\")]\n    fn shr(self, rhs: RHS) -> Self::Output;\n}\n\nmacro_rules! shr_impl {\n    ($t:ty, $f:ty) => (\n        #[stable(feature = \"rust1\", since = \"1.0.0\")]\n        impl Shr<$f> for $t {\n            type Output = $t;\n\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn shr(self, other: $f) -> $t {\n                self >> other\n            }\n        }\n\n        forward_ref_binop! { impl Shr, shr for $t, $f }\n    )\n}\n\nmacro_rules! shr_impl_all {\n    ($($t:ty)*) => ($(\n        shr_impl! { $t, u8 }\n        shr_impl! { $t, u16 }\n        shr_impl! { $t, u32 }\n        shr_impl! { $t, u64 }\n        shr_impl! { $t, u128 }\n        shr_impl! { $t, usize }\n\n        shr_impl! { $t, i8 }\n        shr_impl! { $t, i16 }\n        shr_impl! { $t, i32 }\n        shr_impl! { $t, i64 }\n        shr_impl! { $t, i128 }\n        shr_impl! { $t, isize }\n    )*)\n}\n\nshr_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }\n\n/// The bitwise AND assignment operator `&=`.\n///\n/// # Examples\n///\n/// An implementation of `BitAndAssign` that lifts the `&=` operator to a\n/// wrapper around `bool`.\n///\n/// ```\n/// use std::ops::BitAndAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(bool);\n///\n/// impl BitAndAssign for Scalar {\n///     // rhs is the \"right-hand side\" of the expression `a &= b`\n///     fn bitand_assign(&mut self, rhs: Self) {\n///         *self = Scalar(self.0 & rhs.0)\n///     }\n/// }\n///\n/// let mut scalar = Scalar(true);\n/// scalar &= Scalar(true);\n/// assert_eq!(scalar, Scalar(true));\n///\n/// let mut scalar = Scalar(true);\n/// scalar &= Scalar(false);\n/// assert_eq!(scalar, Scalar(false));\n///\n/// let mut scalar = Scalar(false);\n/// scalar &= Scalar(true);\n/// assert_eq!(scalar, Scalar(false));\n///\n/// let mut scalar = Scalar(false);\n/// scalar &= Scalar(false);\n/// assert_eq!(scalar, Scalar(false));\n/// ```\n///\n/// Here, the `BitAndAssign` trait is implemented for a wrapper around\n/// `Vec<bool>`.\n///\n/// ```\n/// use std::ops::BitAndAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct BooleanVector(Vec<bool>);\n///\n/// impl BitAndAssign for BooleanVector {\n///     // `rhs` is the \"right-hand side\" of the expression `a &= b`.\n///     fn bitand_assign(&mut self, rhs: Self) {\n///         assert_eq!(self.0.len(), rhs.0.len());\n///         *self = BooleanVector(self.0\n///                                   .iter()\n///                                   .zip(rhs.0.iter())\n///                                   .map(|(x, y)| *x && *y)\n///                                   .collect());\n///     }\n/// }\n///\n/// let mut bv = BooleanVector(vec![true, true, false, false]);\n/// bv &= BooleanVector(vec![true, false, true, false]);\n/// let expected = BooleanVector(vec![true, false, false, false]);\n/// assert_eq!(bv, expected);\n/// ```\n#[lang = \"bitand_assign\"]\n#[doc(alias = \"&=\")]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} &= {Rhs}`\",\n                         label=\"no implementation for `{Self} &= {Rhs}`\")]\npub trait BitAndAssign<Rhs=Self> {\n    /// Performs the `&=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn bitand_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! bitand_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl BitAndAssign for $t {\n            #[inline]\n            fn bitand_assign(&mut self, other: $t) { *self &= other }\n        }\n\n        forward_ref_op_assign! { impl BitAndAssign, bitand_assign for $t, $t }\n    )+)\n}\n\nbitand_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The bitwise OR assignment operator `|=`.\n///\n/// # Examples\n///\n/// ```\n/// use std::ops::BitOrAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct PersonalPreferences {\n///     likes_cats: bool,\n///     likes_dogs: bool,\n/// }\n///\n/// impl BitOrAssign for PersonalPreferences {\n///     fn bitor_assign(&mut self, rhs: Self) {\n///         self.likes_cats |= rhs.likes_cats;\n///         self.likes_dogs |= rhs.likes_dogs;\n///     }\n/// }\n///\n/// let mut prefs = PersonalPreferences { likes_cats: true, likes_dogs: false };\n/// prefs |= PersonalPreferences { likes_cats: false, likes_dogs: true };\n/// assert_eq!(prefs, PersonalPreferences { likes_cats: true, likes_dogs: true });\n/// ```\n#[lang = \"bitor_assign\"]\n#[doc(alias = \"|=\")]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} |= {Rhs}`\",\n                         label=\"no implementation for `{Self} |= {Rhs}`\")]\npub trait BitOrAssign<Rhs=Self> {\n    /// Performs the `|=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn bitor_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! bitor_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl BitOrAssign for $t {\n            #[inline]\n            fn bitor_assign(&mut self, other: $t) { *self |= other }\n        }\n\n        forward_ref_op_assign! { impl BitOrAssign, bitor_assign for $t, $t }\n    )+)\n}\n\nbitor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The bitwise XOR assignment operator `^=`.\n///\n/// # Examples\n///\n/// ```\n/// use std::ops::BitXorAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Personality {\n///     has_soul: bool,\n///     likes_knitting: bool,\n/// }\n///\n/// impl BitXorAssign for Personality {\n///     fn bitxor_assign(&mut self, rhs: Self) {\n///         self.has_soul ^= rhs.has_soul;\n///         self.likes_knitting ^= rhs.likes_knitting;\n///     }\n/// }\n///\n/// let mut personality = Personality { has_soul: false, likes_knitting: true };\n/// personality ^= Personality { has_soul: true, likes_knitting: true };\n/// assert_eq!(personality, Personality { has_soul: true, likes_knitting: false});\n/// ```\n#[lang = \"bitxor_assign\"]\n#[doc(alias = \"^=\")]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} ^= {Rhs}`\",\n                         label=\"no implementation for `{Self} ^= {Rhs}`\")]\npub trait BitXorAssign<Rhs=Self> {\n    /// Performs the `^=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn bitxor_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! bitxor_assign_impl {\n    ($($t:ty)+) => ($(\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl BitXorAssign for $t {\n            #[inline]\n            fn bitxor_assign(&mut self, other: $t) { *self ^= other }\n        }\n\n        forward_ref_op_assign! { impl BitXorAssign, bitxor_assign for $t, $t }\n    )+)\n}\n\nbitxor_assign_impl! { bool usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }\n\n/// The left shift assignment operator `<<=`.\n///\n/// # Examples\n///\n/// An implementation of `ShlAssign` for a wrapper around `usize`.\n///\n/// ```\n/// use std::ops::ShlAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(usize);\n///\n/// impl ShlAssign<usize> for Scalar {\n///     fn shl_assign(&mut self, rhs: usize) {\n///         self.0 <<= rhs;\n///     }\n/// }\n///\n/// let mut scalar = Scalar(4);\n/// scalar <<= 2;\n/// assert_eq!(scalar, Scalar(16));\n/// ```\n#[lang = \"shl_assign\"]\n#[doc(alias = \"<<=\")]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} <<= {Rhs}`\",\n                         label=\"no implementation for `{Self} <<= {Rhs}`\")]\npub trait ShlAssign<Rhs=Self> {\n    /// Performs the `<<=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn shl_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! shl_assign_impl {\n    ($t:ty, $f:ty) => (\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl ShlAssign<$f> for $t {\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn shl_assign(&mut self, other: $f) {\n                *self <<= other\n            }\n        }\n\n        forward_ref_op_assign! { impl ShlAssign, shl_assign for $t, $f }\n    )\n}\n\nmacro_rules! shl_assign_impl_all {\n    ($($t:ty)*) => ($(\n        shl_assign_impl! { $t, u8 }\n        shl_assign_impl! { $t, u16 }\n        shl_assign_impl! { $t, u32 }\n        shl_assign_impl! { $t, u64 }\n        shl_assign_impl! { $t, u128 }\n        shl_assign_impl! { $t, usize }\n\n        shl_assign_impl! { $t, i8 }\n        shl_assign_impl! { $t, i16 }\n        shl_assign_impl! { $t, i32 }\n        shl_assign_impl! { $t, i64 }\n        shl_assign_impl! { $t, i128 }\n        shl_assign_impl! { $t, isize }\n    )*)\n}\n\nshl_assign_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }\n\n/// The right shift assignment operator `>>=`.\n///\n/// # Examples\n///\n/// An implementation of `ShrAssign` for a wrapper around `usize`.\n///\n/// ```\n/// use std::ops::ShrAssign;\n///\n/// #[derive(Debug, PartialEq)]\n/// struct Scalar(usize);\n///\n/// impl ShrAssign<usize> for Scalar {\n///     fn shr_assign(&mut self, rhs: usize) {\n///         self.0 >>= rhs;\n///     }\n/// }\n///\n/// let mut scalar = Scalar(16);\n/// scalar >>= 2;\n/// assert_eq!(scalar, Scalar(4));\n/// ```\n#[lang = \"shr_assign\"]\n#[doc(alias = \">>=\")]\n#[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n#[rustc_on_unimplemented(message=\"no implementation for `{Self} >>= {Rhs}`\",\n                         label=\"no implementation for `{Self} >>= {Rhs}`\")]\npub trait ShrAssign<Rhs=Self> {\n    /// Performs the `>>=` operation.\n    #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n    fn shr_assign(&mut self, rhs: Rhs);\n}\n\nmacro_rules! shr_assign_impl {\n    ($t:ty, $f:ty) => (\n        #[stable(feature = \"op_assign_traits\", since = \"1.8.0\")]\n        impl ShrAssign<$f> for $t {\n            #[inline]\n            #[rustc_inherit_overflow_checks]\n            fn shr_assign(&mut self, other: $f) {\n                *self >>= other\n            }\n        }\n\n        forward_ref_op_assign! { impl ShrAssign, shr_assign for $t, $f }\n    )\n}\n\nmacro_rules! shr_assign_impl_all {\n    ($($t:ty)*) => ($(\n        shr_assign_impl! { $t, u8 }\n        shr_assign_impl! { $t, u16 }\n        shr_assign_impl! { $t, u32 }\n        shr_assign_impl! { $t, u64 }\n        shr_assign_impl! { $t, u128 }\n        shr_assign_impl! { $t, usize }\n\n        shr_assign_impl! { $t, i8 }\n        shr_assign_impl! { $t, i16 }\n        shr_assign_impl! { $t, i32 }\n        shr_assign_impl! { $t, i64 }\n        shr_assign_impl! { $t, i128 }\n        shr_assign_impl! { $t, isize }\n    )*)\n}\n\nshr_assign_impl_all! { u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize }\n"],"mappings":"kkBAm8FA,6BAC0B,OAAnB,OACH,UAAA,EA9LJ,6BACyB,OAAlB,OACH,UAAA,EA9EJ,6BACiC,OAAR,OAAlB,cACH,UAAA,EAYJ,6BACO,OACH,GAAA,EA8HJ,6BACkC,OAAR,OAAnB,cACH,UAAA,GAKJ,qCACW,iBAAD,WAAH,oBACoC,OAAR,OAAnB,cAAL,cADJ,OAGI,QAEP,6BAAA,EA/xCJ,qCAGQ,OAAoB,QAArB,eACH,0BAAA,EA6zCJ,qCAEkC,iBAAvB,UAEP,sBAAA,EAjCJ,6BACO,OACH,GAAA,EApCJ,8BAEqB,eACa,OAAvB,UAEP,sBAAA,EA5pCJ,oCAC0B,OAAM,OAAzB,qBACH,GAAA,EAj8CJ,OAAmD,GAAA,ECmOnD,qCACe,OAAR,UACH,sBAAA,GC7XJ,6CACW,iBAAD,WAAH,wBACW,OAAP,OAiBD,OAAqB,OAAD,WAAb,OAAP,eAAH,eACW,OAAP,GAIqC,OAAM,OAAxC,qCAAH,eAEP,iDAAA,GAUJ,4CACuB,OAA0C,OAA5B,UAA9B,cACH,gDAAA,EAKJ,6BAAiC,cAAY,GAAA,EAK7C,qCAAkC,wBAAmB,sBAAA,ECmSrD,oCACM,cACN,eAAA,EAw0DA,oCACO,OACH,GAAA,EC73DJ,qCAEsC,OAAtB,4BADT,qBAIH,oBAAA,GA0DJ,mDAEuC,OAAK,OAA5B,qCACA,OAFT,qBAIH,oBAAA,EA8tBJ,6BACO,cACH,GAAA,EA66BJ,qCAGmC,wCAG/B,oBAAA,GAlcJ,qCACiC,OAAD,mCAAzB,0BACH,kCAAA,GAOJ,qCAEmB,wBACA,gBACc,OAAG,cAAzB,0BAEP,kCAAA,GAKJ,qCAEqB,wBACF,gBACkB,OAAK,cAA/B,0BAEP,kCAAA,GCnpDJ,yCACgC,QAA0B,OAA1B,8CAAnB,UAEO,oFACI,OAAnB,OAAF,OACY,8CAAZ,QACO,OAAS,QAAT,YAEV,mCAPgC,SAAA,GAUhC,qCAEW,OAAW,gBAAF,oCAAA,OAAT,sCACK,OAAF,cACS,OAAM,OAA1B,6BAAA,QAEH,iCAJoB,SAAA,GAOpB,6CAEyB,OAAM,OAA5B,oDADa,uFAGJ,qBAAA,oHAAA,cAAA,oDAAA,UACI,kDAEP,0CAAmB,UAAzB,0BAEH,QAAA,qBAAA,GC4tBA,yCAEW,qFAAA,WAGP,MAHU,OADP,OAEQ,gCAAM,OAAG,OAAH,6CAElB,6BAAA,oBAAA,sFAAA,UAAA,2BAAA,QAAC,oBAAA,GA6BJ,4CAEW,4BAAA,WAGP,UAHU,4BAAM,cAGjB,wCAFkB,aAEjB,kCAAA,GAsMJ,2EACU,cDh/BV,4BCg/BsB,OCv9Bc,6CDu9BT,OCv9BS,wGDu9B1B,4BCv9B0B,+CAA7B,WAAA,GD2wBP,kCAEW,wBAAA,WAGP,EAHU,4BAAM,cAGjB,6DAFY,yBAAmE,cAA7D,eAEjB,kCAAA,GAsMJ,4DACU,cDh/BV,4BCg/BsB,OCv9Bc,6CDu9BT,OCv9BS,4FDu9B1B,4BCv9B0B,+CAA7B,WAAA,EC8CP,6BAC+B,OAAR,OAAU,cACjB,UAAA,EAgBhB,6BACmB,OACH,GAAA,GA66EhB,4CAC4B,OAAqB,OAArB,0BAAR,OAAG,kBACL,OAAH,wBAAM,OAAN,OAAuB,OAAL,eACrB,gDAAA,GA0oBZ,wCAE6C,OACA,OAD9B,wFADC,WAAG,cAIP,OAAW,OAAZ,cACH,6BAAA,EAxUR,oCAE+C,OAAM,OAAlC,qBAEP,GAAA,GAuoBZ,yCACgB,OAAD,YAAyB,OAAzB,qBAAwC,OAAD,eAAD,WAAtC,oBAAA,cAAA,QACH,wCAAA,ECt6BZ,oCACO,cACH,eAAA,GC1oDJ,kCACsB,8CAAf,8CACH,CAAA,GAvyBJ,qDACqB,8CAAlB,UACH,oBAAA,EAiJA,0BACG,cACH,GAAA,EAFA,0BACG,cACH,GAAA,EA0FA,0BACG,cACH,GAAA,EV7LA,qCAAA,mCAAA,EAAA,qCAAA,mCAAA,EAAA,qCAAA,kDAAA,ESg/IA,oCAIwB,OAAM,OAAf,cAAZ,0CACH,eAAA,EAgBA,oCAIwB,OAAM,OAAf,cAAZ,0CACH,eAAA,EA5yIA,oCACO,OACH,GAAA,GAo3DJ,4CACuB,cAAhB,qCACH,kCAAA,EEv7BJ,qCACO,iBACH,sBAAA,EAnmBJ,qCACO,+BACH,kCAAA,GAwvCJ,qCACyC,0CAAzB,qCACZ,kCAAA,EC/0DJ,mDACiC,cAAb,YAAb,oBACH,sBAAA,GA7BJ,2DACuB,yBAAe,UAAnC,YACH,sBAAA,EAKA,mDAC0B,cAAN,YAAb,oBACH,sBAAA,GA9EJ,2DACgB,yBAAe,UAA5B,YACH,sBAAA,EA+EA,0DACe,iBAAc,cAAtB,YACH,oBAAA,GAjEJ,kEACkB,OAAK,yBAAe,UAAnC,YACH,oBAAA,ECoDA,qCAC2B,WAApB,qCACH,kCAAA,GA7DJ,iDAE2B,eAEC,OAAgB,OAAhB,wDACL,OAAZ,kBAGa,OAAH,QACN,kBAEY,eACyB,OAAY,OAApC,6EACG,OAAH,uCACM,cAAf,uCAEQ,cAAR,wBAHS,IAMT,sBAAA,aAC6B,cAAnB,YAUzB,EAXkB,cAAQ,yBAMV,iBACL,OAFJ,cAMP,iDAAA,GAiEJ,4CAEsC,OAAtB,UACL,OAFJ,cAKH,gDAAA,GA0iBJ,qCACM,YAAA,sCAA+B,sBAA/B,aAAA,cAAA,QAAH,+BACQ,OAAJ,yBADJ,OAGI,QAEP,6BAAA,EAjpBA,8BAAyE,OAAA,EACzE,yCAAsD,OAAA,GA0ItD,qCACU,cAAH,YACI,OADJ,GAMoB,eACD,QAAsB,cAAtB,cAC4B,OAAM,OAAxC,0BAAL,eAGX,gDAAA,GAudJ,qCACuB,eACb,OAAH,OAC0B,qDAAf,0CAAK,4BACR,OAA6B,cAAd,oBAAgC,cAA/C,gBAGX,oBAAA,EApgBJ,qCACO,wBACH,sBAAA,EAugBJ,qCACgB,eACZ,oBAAA,GCjVJ,gDAEW,0DAAA,kBACQ,yBAEf,MAHY,qBAAM,cADf,IAIJ,6BAAA,YAAA,8DAAA,WAAC,6BAAA,GAoGJ,iCAEW,+DAAA,sBACY,OAAJ,OAFZ,GAIH,MAHY,qBAAS,OAAH,QAGnB,6BAAA,gBAAA,0FAAA,WAAC,UAAA,ECm4CJ,4CAAiE,qBAAS,OAAC,cAAG,iCAAA,EAtkD9E,oCAIyC,OAAf,cACW,OAAf,cAFX,cAKP,6BAAA,EARJ,oCAIyC,OAAf,cACW,OAAf,cAFX,cAKP,6BAAA,EARJ,oCAIyC,OAAf,cACW,OAAf,cAFX,cAKP,6BAAA,GA8CJ,gEAIW,cACU,cAAL,cACL,cAHJ,wDAKH,CAAA,mFXmGJ,GS1PW,OT2Pa,OIg4EL,GKjsEL,GAAH,gBAjOe,EAEF,KGogB0B,IAAA,UH1RvC,GAGI,SAEiC,KDnjB7C,YCyjBa,QD7lBb,UC6lBa,KAA8B,YApLV,QAwLzB,OACA,WTzNP,EapWJ,WAAwD,EAAxD,YAAwD,EH6OxD,CAEW,OAGP,IPjVG,aAAA,EO4UP,CAEW,OAGP,IPjVG,aAAA,EP8KP,CAAA,EAAA,GawCU,OAqeQ,KAC0B,KDhnBzC,WZkGH,EAAA,GAAA,YawCU,QAqeQ,KD/mBf,aZkGH,GeuBA,oBACe,OGiJL,UAAH,Ed2nBG,OS3wBC,OT2wBD,CAAH,EACI,UAorB+B,WS38CnC,Kbo9CA,GAj8BiC,KIyQ7B,qBOkEoD,OOjsB9C,UAAH,EAkFC,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,Sdy5CR,UArkCA,EAoXA,KAotBiB,KAxkCjB,GJu4BA,Eap9CA,Kbo9CA,CSqQI,eM9sDC,aAAA,EAEZ,oBAKkB,EAJH,KAIG,GAAe,gDAA1B,wBAHK,aAAA,EAVZ,GACe,KX4oDR,UArkCA,EAoXA,KAotBiB,KAxkCjB,GJu4BA,Eap9CA,Kbo9CA,CSqQI,aMltDC,EIhGZ,CAEA,EAMA,GAOG,ICg3Dc,SDr3DS,WAKvB,OE8CQ,EAAA,EF7BX,CG3GmB,cAAT,GAAH,EAAY,MAGR,UH2GP,EG9Ge,MACR,QH6GP,EAGJ,CG9FO,cHkGH,GAGJ,CG5FuB,oBAAb,GAAH,EAAgB,MA5BJ,MAAT,GAAH,EAGI,gBA6BA,QAJY,MACZ,UHiGP,EG7HO,cA+BA,OH8FP,EG5FW,QN02BmC,MM12BnC,QAfR,cH2GH,EAAA,EAGJ,CGjImB,kBAAT,GAAH,EAAY,MAGR,UAOD,OAVS,MACR,QASD,MAAkB,cAAlB,GACC,cHyHP,EAAA,EIoJJ,CACG,SAAA,GAuBH,wBAuCa,gBACA,gBACW,oBAAY,UAAY,UAAzB,qBAjCZ,cAkCR,WAEI,QAFJ,YAAA,GAuDH,yBAGoB,OAAN,OAAN,cC1IO,0BCnDA,SFlBG,CvB2HX,SuB6FD,KAAH,KCnJY,QxBsDR,QuBsGI,mBGpZJ,uDChCG,cAAH,EAAG,EACC,cADD,IJ2bC,YAKa,WACQ,mBG3ZzB,EH2ZyB,KG3ZzB,GH4ZQ,mBAFS,EIvZjB,UAAA,cJ+ZD,KAAH,MAUA,WAAA,GA5HH,oBTocW,WS9cY,OZuBhB,cI/JW,UAAe,kDAA1B,uBQ4IQ,2BvB5Kf,UawCU,QAqeQ,KD/mBf,aEwtBgB,uBdpPhB,QAxNI,OAwNJ,sBAxNI,aY9RJ,MA+GI,KgBjFI,qBL2QH,EvBu+EJ,MuBv+EI,2BXvLG,OAAA,GWyLX,oBAdW,OT6cA,SS9cY,OZuBhB,cI/JW,UAAe,kDAA1B,uBQ4IQ,oBvB5Kf,YawCU,QAqeQ,KD/mBf,aEwtBgB,wBS7bX,6BAAA,EA+IR,kCAGO,YFzVI,EAAA,EQ9HX,CAaO,EAAA,ECgDP,GAEI,EAmGJ,CAm6CO,cAj6CH,GAEJ,KAIU,gFAAH,EAGoB,SA1IxB,QAgHO,KAAH,KAtCA,KAgEoB,QAIb,CAAH,G9B67CJ,E8B17Ce,QAAP,O9B07CR,M8Bv7CgB,QAysBN,U9B8uBV,K8B1uBG,GAAH,EAGI,OACA,iBAtqBM,KAAH,EA/LX,YAoMW,KAAH,SA0oBI,OACR,SAEU,QAAH,EAIU,ItBqyCA,GsBryCQ,KAAR,IAAD,GADJ,KACP,CAAD,W9BsvBJ,Y8B/0BY,GACZ,SAGuB,MAhvBa,KAApC,GAgvBuB,CAnvBxB,KAmvBwB,QAswBvB,YAjwBW,YAAA,eAGC,MAIK,UAET,EAAoB,EAFX,EACL,OAAW,CADN,GACL,IACgB,GAApB,QASA,OANA,KAWL,YA/nBI,EAAK,MAAL,CAAH,EAGI,K9B26CR,E8B16C2B,OA7J/B,OAAW,GAAX,CA6J+B,KAzJ3B,GAAJ,CtBu/DgC,KRpb5B,M8Bt6CoB,IAwrBV,O9B8uBV,K8B1uBG,GAAH,EAGI,OACA,aA4FJ,MAAiB,GAAjB,KA2mBA,EA99CA,SA89CA,I9B+BA,K8B7BA,aAxzCH,IAhEqB,KAAH,K9Bq5Cf,E8BnkDJ,IAAI,GAAJ,CtBu/DgC,GRpb5B,M8Bl3BY,GA6yBZ,QA3yBgB,SA43BL,KACX,uBA5zBG,WAC0B,KAzxBjC,KAAW,GAAX,CAyxBuB,GACf,K9B6yBJ,E8BnkDJ,IAAI,GAAJ,CtBu/DgC,GRpb5B,M8B1yBY,GAKZ,MAguBA,UA9tBO,KAAiB,UAAjB,GA+yBI,WAEP,iCAnzBJ,WAUmB,aAAD,OAAA,IAhmBT,cAAN,OAsBK,MAAL,KAAH,EACI,gBAGA,EADQ,M9Bk2CZ,K8Bj2CI,MAEA,UAs0CJ,U9ByBA,K8Br1CH,EApCe,QADI,SAET,GASC,WADA,WAi1CR,U9B+BA,S8B7BA,oBA9iDJ,WChFY,CACD,MACR,CAAH,EAIC,KDwUG,KAIA,eAAA,SACA,EAA8B,Md8lBa,IAAA,Mc9lB3C,IAEG,MAAH,KAeiB,UA42CjB,OAAmB,O9BrDnB,G8BtzC2B,GAAjB,EACG,KADH,QAhEF,WADA,M9Bu3CR,K8Bv3CQ,KAk2CR,U9BqBA,K8BVA,KAfA,sB9ByBA,K8Br1CH,EAikBG,UACG,OAovBH,EAnvBoC,SAmvBpC,I9B+BA,K8B7BA,gBA7mBA,MAAiB,GAAjB,YAinBA,U9ByBA,O8B7/CA,KA2FwB,SA64CxB,I9BqBA,K8BVA,KAvtBU,WAEV,K9B+tBA,E8BjgDA,S9BigDA,O8B9tBa,WA4Eb,SAAgB,MAAhB,GAxDA,GAGQ,UA8qBR,iBAIA,Q9BqBA,K8BVA,KA/+CA,MAmyBA,E9BstBA,E8BjgDA,S9BigDA,O8BlpBA,SAAgB,MAAhB,GAxDA,GAGQ,iBAyDR,eAtDA,UACA,OAEA,OADA,QAxBA,WADA,OA1nBH,IAgBU,uBACC,YAEJ,QAGA,SAFA,eACA,WA8UA,WACA,CADA,KACA,KADA,UdoQuC,WgBxtB3C,GF2cA,MAlUgB,KAkUhB,KADA,WAEA,U9B0/BA,O8Bz/BA,GACA,cA6hCA,KAx1CO,MAgmBH,eAowBmB,KAAvB,SA/1CQ,aACU,iBA9RtB,Q9B2kDI,C8B5/BA,KAhTmB,kB9B4yCnB,K8B9/BW,IAGX,KACA,U9B0/BA,O8Bz/BA,GACA,cA0WA,UAtDA,YAAA,OACA,OAEA,OADA,Q9BksBA,sE8BrEA,QApyBe,GACR,EAAH,EAAG,KAAH,gBAo3BO,KACX,WACI,QA13BA,WAaJ,UACG,KAAH,SA+zBA,EA9zBoC,SA8zBpC,I9B+BA,K8B7BA,gBAIA,iBAIA,Q9BqBA,K8BVA,KAvtBU,WAEV,Y9B+tBA,E8BjgDA,S9BigDA,O8B9tBa,WA4Eb,SAAgB,MAAhB,GAxDA,UAGQ,UAyDR,qBAtDA,UACA,OAEA,OADA,cAxBA,WADA,c9B2tBA,K8Br1CH,kDAs4CG,EA11CQ,EAAkC,M9BsuEP,IAAA,M8BtuE3B,eAEuB,sBACd,aA20CjB,KAz0CW,QAuaJ,kB9B63BP,E8BqDmB,K9BrDnB,C8B73B4B,KAArB,GAGE,SAHF,EA9HP,MAqFW,KArFX,KADA,WAEA,U9B0/BA,O8Bz/BA,GACA,WAsEU,EAzpBd,U9B2kDI,G8Bl7Ba,E9Bk7Bb,K8Bl7Ba,CAAH,KAy5BV,GAv4BA,8BAEA,WADA,WAEA,WACA,M9B45BA,K8B55BA,GAGA,OAEI,SAEG,UAAH,GASD,KAAH,EA21BA,aA4BA,EAr3BgB,SAq3BhB,IAWA,OA/+CA,QAmyBA,E9BstBA,E8BjgDA,S9BigDA,O8BlpBA,SAAgB,MAAhB,GAxDA,GAGQ,UAZJ,eA5kBQ,OACA,aAqwCZ,U9ByBA,O8Bv+BY,KAEI,KASD,WAAZ,GAAH,EAMsB,MAAZ,GAAH,EAy6BP,aAn6BI,EA24BJ,UAp7CA,CA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAtCJ,eAtDA,UACA,OAEA,OADA,QAplBU,WAAP,KAAH,EACI,YAEQ,a9BmxCZ,K8BlxCI,KAEA,UAuvCJ,U9ByBA,K8Br1CH,EAAA,IA4XO,OAFA,qBAGA,aAKA,WAFA,qBAg8BJ,U9BqBA,K8BVA,QA7mBI,aAnBJ,SAv3BA,KAu3BiB,CAAjB,KAlUQ,O9B48BR,Q8BjDA,aA4BA,U9BqBA,K8BVA,KA/+CA,YAmyBA,E9BstBA,E8BjgDA,S9BigDA,O8BlpBA,SAAgB,MAAhB,GAxDA,GAGQ,iBAZJ,eAqEJ,UAtDA,YAAA,OACA,OAEA,OADA,Q9BksBA,K8Br1CH,GAivBJ,GACgB,OA4nBT,aA1nBG,KAAH,EA8nBA,KA3nBI,OACA,OAuBJ,OAjBQ,QAJS,KACV,KAAH,GAGI,IACJ,yBAEqB,SACV,KAAH,KAGA,OAFS,OAEN,KAAH,MAMJ,OAIR,WAAA,M9BskBA,M8BlkBwB,O9BkkBxB,M8BjkBY,KAAT,GAAH,QAMO,QAAH,OAOJ,OAZI,OACA,MAYA,OACS,OACT,KACI,OACA,QAEK,QACT,KACI,UACA,QAGX,EAvFG,SAgE2B,QAhEX,CAAhB,IAuFH,GAvJJ,GA/De,SACR,SAEU,QAAH,EAIU,ItBqyCA,GsBryCQ,KAAR,IAAD,GADJ,KACP,CAAD,WA2DJ,OACA,O9B0rBA,c8BtoBA,mBAAe,MAAf,GAjDA,GAOgB,KA2mBhB,QAxmBW,GAAH,SA2CR,aAnDI,OACA,UAKY,MA54BoB,KAApC,GA44BgB,CA/4BjB,KA+4BiB,IAGI,WAAgB,CAAhB,IAEJ,KAAJ,KADA,WAsmBZ,QAxmBW,GAAH,IAcY,KACR,OACA,OAEA,OADA,OAEA,OAKf,EAlBmB,OACA,sBAiBnB,GA/mBJ,OACU,QAAH,IAxUJ,QAgHO,KAAH,GAs5CA,iBA4BA,yBAjsCA,eAEU,KAAH,EASW,MAAR,GAAH,EAYW,MAAR,GAAH,EA0pCP,UAroCO,EAynCP,KAvnCO,UAAH,EAGY,OAhUhB,MA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAj5BJ,MAsVA,EAKG,EAAW,KAAX,kBAzEa,SACT,CAAH,EAisCJ,IAAa,KAAb,O9BqCA,O8BrCA,QAEA,aA/rCQ,eAIS,MAAV,QAAH,EAyrCJ,IAAa,KAAb,O9BqCA,K8B1tCqB,WAGjB,IAEA,WADA,cAIU,MACP,QAAH,GAxCM,eAGN,MAirCJ,cA4BA,KA16CA,CA4Na,Cd2gB8B,Qc1gBvC,QACA,YAGP,EAoCmB,aACT,CAAH,EAwqCJ,EAAa,KAAb,S9BqCA,K8BnCA,wBAFA,IAAa,KAAb,O9BqCA,O8BrBA,Q9BqBA,K8BVA,OAvCA,uCAtkBI,aAnBJ,SAv3BA,KAu3BiB,CAAjB,KA7iBO,OAAH,EAkpCJ,IAAc,OAAD,CAAb,O9BqCA,K8BnCA,gBAFA,IAAc,OAAD,CAAb,O9BqCA,O8BrCA,Q9BqCA,K8BnCA,aA7oCQ,kBAlEX,EAAA,GAyLJ,G9ByjCO,O8BrDA,0BAlgCA,EA8gCA,KA5gCI,QAQA,OAEQ,Y9B2iCZ,K8B3iCO,GAAH,EA9cJ,MA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAjcU,WAAH,EACH,QAu/BR,kBA4BA,UAWA,OAz/BH,EA4YO,aAnBJ,SAv3BA,KAu3BiB,CAAjB,KAilBA,cAz+BA,EACe,MAAR,GAAH,EAUkB,MAAR,GAAH,EAk9BX,KA18BQ,OA1eR,MA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAujBJ,aA4BA,U9BqBA,K8BVA,QAphCQ,WAFA,iBAGA,UACG,EAAK,MAAL,CAAH,GAyBX,EAjBW,WAFA,iBAigCR,U9BqBA,K8BVA,KAz/BH,EA4YO,aAnaQ,QADA,WAwBf,EAyXG,SAv3BA,KAu3BiB,CAAjB,KAqnBA,U9BqBA,K8BVA,KAlgCW,EAAK,SAAL,CAAH,EACI,QAQf,EAtfG,YAmyBA,E9BstBA,E8BjgDA,S9BigDA,O8BlpBA,SAAgB,MAAhB,GAxDA,GAGQ,UAZJ,YAhTP,EAqXG,eAtDA,UACA,OAEA,OADA,OAjUH,GA8dJ,G9BqiBO,O8BrEA,a9BqEA,K8BrDA,SA1eA,EAsfA,KAnfI,QASA,OAEQ,Y9BihBZ,K8BjhBO,GAAH,EAx+BJ,MA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAyFU,WAAH,EACH,QA6dR,kBA4BA,U9BqBA,K8BVA,KAhdH,EA7JO,aAnBJ,SAv3BA,KAu3BiB,CAAjB,KAilBA,4BA9cA,EACe,MAAR,GAAH,EAakB,MAAR,GAAH,EAobX,KA5aQ,OAxgCR,MA+3BA,EASQ,KADA,OAML,GAAH,EAGI,OACA,UAujBJ,aA4BA,U9BqBA,K8BVA,QAzfQ,WAFA,iBAGA,UACG,IAAK,MAAL,CAAH,EAEI,QADA,YAyCL,MAAP,KAtCQ,EA2CwB,SAA7B,KAEI,gBAAH,EA/aS,QAEN,gB9B63BP,E8BqDmB,K9BrDnB,C8B73B4B,GAArB,GAGE,KAJT,MAmea,SACb,SAII,cAJJ,KAqCsB,KAAG,MAAH,MAjId,WAFA,iBAmeR,U9BqBA,K8BVA,KAhdH,EA7JO,aAnBJ,SAv3BA,KAu3BiB,CAAjB,KAqnBA,U9BqBA,K8BVA,KApeW,EAAK,SAAL,CAAH,EACI,QAmBf,QAqGG,QA9DwB,KAApB,EACI,WAxCX,EA/hCG,gBAohCA,E9BqeA,E8BjgDA,S9BigDA,O8BlpBA,SAAgB,MAAhB,GAxDA,GAGQ,iBAsOJ,YAEA,iBACA,IAmES,SACb,SAII,cAJJ,KAqCsB,KAAG,MAAH,MAzRtB,UAtDA,YAAA,OACA,OAEA,OADA,OAwOH,QAqGG,YArGH,GAjqBJ,WAGO,UAGY,GAAT,GAAH,EAKU,EADA,IA1dd,QAgHO,KAAH,CA0WU,MACA,MACV,K9B+mCA,O8B3mCkB,WAAf,KAAH,GAsiCA,eAhiC8B,OAAiC,GAAlC,G9BqmC7B,CAAA,O8BpmCiB,QAAH,CAMK,KACD,KAojClB,KAjjCI,GAqjCJ,IAAc,OAAD,CAAb,O9BqCA,K8BnCA,aAFA,IAAc,OAAD,CAAb,OAEA,aAhjCQ,sBANoB,OACpB,OADA,WAgjCR,YApiCA,GAwgCA,OAtgCc,KAAP,CAAH,EAsiCJ,OAAa,KAAb,O9BqCA,K8B1kC6B,WAqiC7B,I9BqCA,K8BnCA,aAniCQ,a9BskCR,Q8B7jCH,EAAA,EfmxCJ,CAAiE,UAAU,QAAG,EfxrD9E,CAAA,GM8yBA,uCACU,iBSpoBH,uBTooBG,WSpoBH,6BTooBG,oBSpoBH,URnVA,kBAAA,EQ+LP,CACe,KJwhER,UIvhEK,GJg1BZ,oBOhsBU,UAAH,Ed2nBG,OS3wBC,OT2wBD,CAAH,EACI,UAorB+B,WS38CnC,Kbo9CA,GAj8BiC,KIyQ7B,qBOkEoD,OOjsB9C,UAAH,EAkFC,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,Sdy5CR,UArkCA,EAoXA,KAotBiB,KAxkCjB,GJu4BA,Eap9CA,Kbo9CA,CSqQI,eEz3BP,WAAA,EIn1BJ,oBAKkB,EAJH,KAIG,GAAe,gDAA1B,wBAHK,aAAA,EAVZ,GACe,KX4oDR,UArkCA,EAoXA,KAotBiB,KAxkCjB,GJu4BA,Eap9CA,Kbo9CA,CSqQI,aMltDC,GX8PZ,GS1PW,OT2Pa,OIg4EL,GKjsEL,GAAH,gBAjOe,EAEF,KGogB0B,IAAA,UH1RvC,GAGI,SAEiC,KDnjB7C,YCyjBa,QD7lBb,UC6lBa,KAA8B,YApLV,QAwLzB,OACA,WTzNP,EQvPJ,CAMY,WAAA,ECvIZ,CAAsD,OAAA,EAqpBtD,CACG,aAAA,GoB/LH,oBlB1LkC,oBf4rB3B,CSytDY,KTztDZ,We3rBa,OmB/QuB,KzB+kFrB,YAoFH,aMl5ET,kBAAH,GAEU,KAAwB,SAAxB,OAAA,IPuxFF,qByBhmFR,e3B6MI,O2B7MJ,crB1eJ,UC+BgB,IACU,qBF8TtB,qBI1MW,UAAe,gDAA1B,wBTgmBI,E2BtQR,0BACH,a3BsQqB,QSlcJ,kBTqYI,OAAA,ENpkBrB,CAAA,GmCzIA,kCAEa,iBpBkTN,uBoBlTM,WpBkTN,6BoBlTM,iBpBkTN,UoBlTJ,cAAA,G1BkuEH,kCACG,iBMj7DI,uBNi7DJ,WMj7DI,6BNi7DJ,iBMj7DI,UNi7DJ,kBAAA,E0BlvEH,sBAOoB,OAAN,OAAN,OpBuSD,UoBtS8B,OpBsS9B,4BoBtS6C,cAAjD,cAAA,G1B+uEH,kCACG,iBMv7DI,uBNu7DJ,WMv7DI,6BNu7DJ,iBMv7DI,UNu7DJ,kBAAA,E0BpuEH,sBAQQ,OTVD,KSUO,KTVP,uCSeK,SAAA,GpBwpCZ,2BDliCW,4BCoiCD,EAKY,OALZ,kBAKiB,UfpLpB,eAAA,SGhkBI,mBACL,CAAH,aMosEmB,SAoFH,ENpyEN,OADV,GH4kBI,4BGrjBD,kBAAH,EM0rEmB,KAoFH,ENpyEN,OADV,GH4kBI,kCGrlB0C,UAsCvC,QAAH,EMorEe,KAoFH,ETztDZ,OG3kBM,OADV,qBiCtKW,KAAH,gBjC6JsC,KA0CjC,WA1CiC,CA0CtC,UAkJA,GiCzVG,KAAH,MjC6VyB,KAArB,SM0hEO,KAoFH,IM1iDT,EACQ,oCAwBP,OAhBO,mBZ+5BR,WMgOA,OTvzCH,KG2lCU,KAAM,SW1xDZ,4CXgNA,IADC,QAhG4B,KAiG7B,GH+eJ,OSqoDe,WNlnEf,aYwrBwC,QAArB,4BZ1rBf,IADC,QAhG4B,KAiG7B,GH+eJ,OSqoDe,WMn7CW,YActB,qBAKA,cAzBI,2CA4BuC,UAAb,QAGnB,OACJ,cG12BJ,GACC,cAEM,UAEN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,aF6emC,kBgBxtB3C,EjBykCI,sCiBzkCJ,EjB6iCY,kCA+BZ,MCpX2C,cDuXvC,8CA7CQ,8BAef,aAAA,GZuxBJ,2CAZM,QAAH,IMqVO,qBN9NC,EAEM,WAAM,CAtHhB,GACI,WAiHD,2BAlHH,WAWY,cAC+B,MAAhC,GAAgC,KAAhC,kBAGZ,4BAMK,KAAR,EA6FO,gBMgOA,KN9NC,EHzlCJ,KG2lCU,KAAM,CA7FR,eAyFL,YMgOA,kBN9NC,EAEM,aAAM,CA1FpB,GACI,OAqFG,yBAtFP,qBAXI,oCYjsDA,0BZisDA,WYjsDA,6BZisDA,8BYjsDA,WZisDA,wBHt/BA,QSqoDe,ETroDf,KSqoDe,GAoFH,UNzxER,aACL,CAAH,EAokDS,QAAA,GACL,0BM+nBe,GAoFH,ETztDZ,OG3kBM,UADV,WAuBG,gBAAH,UM0rEmB,OAoFH,ETztDZ,OG3kBM,OADV,IAT8C,UAsCvC,UAAH,MMorEe,OAoFH,ENpyEN,OADV,IAT8C,KA0CjC,WA1CiC,CA0CtC,UW3KA,8BX2tDC,WACL,OentDG,MAAH,MAEU,MAAH,MAEG,OAAH,If+sDM,SAAc,KAAd,GACjB,kEYltDI,0BZktDJ,kBYltDI,6BZktDJ,wCYltDI,WZktDJ,mBAbA,mDYrsDI,0BZqsDJ,WYrsDI,6BZqsDJ,wCYrsDI,WZqsDJ,mBW/sDgB,aAAA,GuB1JnB,wBAhKiC,eAiLR,CAAN,MAOI,iBALA,oBAES,YrC01BzB,CqCv1BgB,MACA,gBAHS,OrCy1BzB,CqCt1BgB,MAFA,OANE,cAAN,aAgBD,UAAH,ErC07CR,KqCv7CY,KrCu7CZ,2BqCz7CqB,IrC60BrB,OqC10BY,cAID,SAAH,ErCk7CR,KqCj7CY,KrCi7CZ,KqCh7CY,WrCg7CZ,KqC76CY,KrC66CZ,KqC96CqB,KrCk0BrB,OqCh0BY,OAQR,gBAFoD,GAEpD,QACH,aAAA,GtB6vBR,qBACuB,mBAOV,QAPU,iBAOV,SfkDN,QezDgB,sDAWH,cf8Cb,Ee9Ca,Of8Cb,Ie9Ca,KAGb,gCAUwB,OAHnB,UAGmB,oDN0vDZ,OApFG,KAoFH,EMzvDJ,OAAwB,kBAAxB,iBA0CR,EAAa,KAAb,GADA,EAAY,KAAZ,GAEA,EAAa,KAAb,OAgBI,oCN0rDgB,KAEI,OAlFT,CAoFH,EA7CA,ET5qDZ,KS4qDY,GM95ET,YAAH,EACoB,KAAF,WA8wBO,KACjB,iBAhxBL,kBAAH,EACoB,KAAF,QA4wBI,aAftB,qBAeI,oCN0rDgB,KAEI,OAlFT,CAoFH,EA7CA,ET5qDZ,KS4qDY,GM95ET,YAAH,EACoB,KAAF,WA8wBO,QACjB,iBAhxBL,kBAAH,EACoB,KAAF,QA4wBI,gBAdtB,cAII,cACqB,QAAM,4BNmsDX,KAEI,OAlFT,CAoFH,EA7CA,ET5qDZ,KS4qDY,WM3sDJ,0BAqDR,UAAA,OArDQ,IAAA,CN2sDI,oCMptDJ,OAAwB,aAAxB,wBACA,cAAgB,OAAhB,YAFgB,EAEhB,iBAAA,CNmtDI,oBA6CA,eApFG,KAoFH,EA7CA,ET5qDZ,KS4qDY,GMpsDZ,QAAwB,UAAxB,kCAIP,gBAsCsC,kBDvuBnB,cCmvBJ,kBAAA,iBAAA,GuBz/Bf,oBACO,qCAAsC,KAAtC,GvBm1CM,iBAAU,8DAAhB,iBuBl1CH,aAAA,GD2DJ,qBtB0gDuC,oBsBzgDxB,EtB2gDwB,KsBzgDjB,EAGH,eAjBW,WHsTa,WG9ZZ,SA8Fc,CACA,MADZ,MA1DlB,GAEA,OHwX4B,KGxX5B,K5Bm3EL,YAAH,E4Bh2EA,uB5BslJJ,G4BtlJI,WA+CuB,WHsTa,WG9ZZ,SAgGc,CACA,KADZ,MA5DlB,GAEA,OHwX4B,KGxX5B,K5Bm3EL,YAAH,E4Bh2EA,uB5BslJJ,G4BtlJI,SAkEK,gB5B+xED,aAAA,YAAA,EQ90EX,YAAwD,EShBxD,CACO,KACH,EA2BJ,CAGO,KACH,EXsvDJ,CAiEO,EAjE0D,UAiE1D,MAjEuE,EW7rD9E,CACO,4BACH,EAoBJ,CAEI,EADG,KACH,GAAA,EAoBJ,CACO,KACH,EAoBJ,CACO,KACH,GanJJ,uCACqB,SjCwhBV,IiCvhBa,YAAG,KAAH,QAGT,MAHS,GAGT,KAqCR,OxB++C8B,QwBjhD1B,EASI,6BxBkzCF,UwBlzCE,oBxBkzCF,OAAU,+DAAhB,ewBlzCQ,EACA,EAAU,KAAV,iBA1GJ,SxBshCU,KwBthCV,GxByhCO,OALX,QAQW,QARX,WASe,QATf,KAOW,KAPX,YAQW,KARX,KASe,KATf,GAcU,UNu9DuC,UMr+DjD,WAcU,ONu9DwB,OMr+DlC,sDAgXA,gBwBjyCQ,ExBiyCR,oBwBhyCQ,ExBgyCR,MwB/xCyB,UxB+xCzB,MwB/xCQ,ExB+xCR,oBwB9xCQ,EACA,6BAOR,UArBA,UAuBH,cAAA,GCrFJ,OxCyzEe,SwC5yEZ,UAAA,KxC0/BI,MgBhI2C,MhBgI3C,yBQ8xDY,aCjBM,CAAN,EAmCA,E+BxyF8C,U/BwyF9C,G+BxyF8C,K/BswFlC,EAkCZ,E+BxyF8C,a/BwyF9C,G+BxyF8C,K/BuwFlC,EAiCZ,E+BxyF8C,a/BwyF9C,G+BxyF8C,K/BwwFlC,EAgCZ,E+BxyF8C,a/BwyF9C,GA/BY,c+BzwFkC,K/BywFlC,IAJZ,4BAOY,c+B5wFkC,aAAA,W/B4yF1B,uB+B/zFpC,QA2BG,SAAH,EACU,EAAU,KAAV,GAAN,YAEgB,aACA,IAIoB,QhCswFxB,QgCrzFhB,CA0CoB,KAIoB,QhCuwFxB,QgCrzFhB,CAAA,OAgDe,CAAH,EAIJ,KAZE,KAAN,EAQQ,E/B+2EL,KAAH,GTx4CA,OAAA,OS6wDY,WDiBA,eCjBM,CAAN,EAmCA,E+B9wFqB,U/B8wFrB,G+B9wFqB,K/B4uFT,EAkCZ,E+B9wFqB,a/B8wFrB,G+B9wFqB,K/B6uFT,EAiCZ,E+B9wFqB,a/B8wFrB,G+B9wFqB,K/B8uFT,EAgCZ,E+B9wFqB,a/B8wFrB,GA/BY,c+B/uFS,K/B+uFT,IAJZ,4BAOY,c+BlvFS,aAAA,W/BkxFD,oB+BlxFoB,cAAA,a/Bu2EhD,Y+Bt2EX,cAAA,GC/CA,GAEU,oBAAH,EACuB,aAAQ,CAAR,MACb,SAAH,EACiB,aAAR,GACO,SADP,cACO,sBAEC,aAAR,iBACO,CAA2B,OAAD,CAA1B,GAAR,cACQ,SADR,cACQ,sCAE1B,EAPmB,mBACO,kBAEP,mBACD,kBACQ,iBAAA,GCJ9B,CAGM,SAAH,EACI,kCA2BP,EA1Ba,SAAH,EACH,kCAyBP,EARU,cAfH,YAAA,YAAA,eAAA,YAAA,YAAA,GAkBG,YAAH,IAKP,EvCkQA,sBACG,eG65BI,kBH75BJ,UACA,2BGs6BI,eHt6BJ,OACH,WAAA,GAkkCA,GAQG,oDAoBgB,kCACT,CAAH,EHq7BQ,KGv3BJ,GAkBI,KArGN,UAsBU,iBAoBJ,gBAAQ,iCA0CF,OAAN,EAImC,WACA,IADA,KAExB,QAAH,EAIJ,KAVE,KAAN,EAMQ,EAOF,SAAe,eACjB,KADE,SAjGZ,UA0DwB,sBACT,uBAAA,IAAe,cACf,aAAA,aAAA,IACe,MAAf,mBAAA,IAGF,4BAAH,EAGG,iCArBW,sBACT,uBAAA,IAAe,cACf,eAAA,aAAA,IACe,QAAf,mBAAA,IACA,0BAAA,IAGF,4BAAH,GAoBR,KAzEF,SA0GN,OACH,EApCoB,eAoCpB,EAjEuB,cAiEvB,EAjDiC,cAiDjC,EA7DiC,cA6DjC,EAhEmB,eAgEnB,EA3CsB,cA2CtB,EAtDsB,cAsDtB,EA1CuB,eA0CvB,EArDuB,eAqDvB,EAxCsB,cAwCtB,EAvCuB,eAuCvB,EA7C4B,eA6C5B,EAxD4B,eAwD5B,GYsbA,WA7FO,2BA8FA,MACS,6BG7vDL,4DAAA,SyB6eJ,czBzeS,GAvBM,KVgiEE,GU7hEE,IACnB,uBAsBS,mBA1BM,KVgiEE,GU7hEE,IACnB,oC0BqFI,8CA9GA,gCAuBI,2CAVgB,EAAqB,OAAD,GAApB,SCuJf,CAEA,MAHN,KAAH,GDpJQ,KAGI,2BATJ,2BAJA,2BAJA,4BAeI,sB7BsrDZ,iCAAA,sBAgGI,MAGP,EAAA,EAAA,GwBv6DJ,oBACO,yDACO,SAAH,GACI,+BOqZR,sDA7HyB,kCAAd,UAkBH,IAAe,EAAf,KAAe,GAAf,MACG,MAAe,KAAf,GAAH,EA3B6B,UA6BJ,KrCglEL,KqChlET,ErCknET,KAAH,eAq3EJ,KAAH,EAKI,YqC3+IY,IA7B2C,KrC4mExD,KqC7mEoB,SAQE,Y9C6vBzB,C8C7vByB,GARY,K9CqwBrC,GS83C+C,KqC3nEtB,oBAAd,KA6BH,EAAc,KAAd,IP5SI,cAJA,OACA,U9B05ER,Y8Bn5EA,cpC+lED,KAAc,KAAd,KMgOA,KN9NC,EHzlCJ,KG2lCU,MAAM,CAxRZ,GoC30DA,oBpC+lED,SHvlCH,USuzCG,KN9NC,EHzlCJ,KG2lCU,QAAM,CA3OZ,OAiBU,KoCx5Dd,kBAoBH,epCi2DyC,gBA+CA,eAAA,GoCtvD7C,6BACqB,OjCubV,EiCtbsB,YAAG,QAAH,KAyC1B,OxB64C8B,QwBh7C1B,MxBmsCJ,2BwB5rCQ,EACA,KxB2rCR,2CwB3rCQ,EACA,EAAU,KAAV,iBA1MJ,SxBshCU,KwBthCV,GxByhCO,OALX,QAQW,QARX,WASe,QATf,KAOW,KAPX,YAQW,KARX,KASe,KATf,GAcU,UNu9DuC,UMr+DjD,UAcU,ONu9DwB,OMr+DlC,0DAgXA,ewBhsCQ,ExBgsCR,qBwB9rCQ,sBAZR,UAoBA,kBAEH,cAAA,GxBnDJ,oBACyC,OGsQ3B,YACC,cAEM,UAEN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,SHrRR,iBACH,aAAA,EAuBJ,oBAsBkB,OAAe,gDAA1B,wBACH,aAAA,EAdJ,CACe,eACH,EAEZ,CACe,aACH,EAEZ,oBAKkB,EAJH,KAIG,GAAe,gDAA1B,wBAHK,aAAA,EA8EZ,CACO,UACH,GA81BJ,kCAOsB,UACf,WA+b8B,UA7bvB,SADH,OAAkB,OAifQ,UA/e1B,OAAkB,YAGH,OA4eW,OA3e9B,GACI,ONonDQ,eNxsER,IADC,QAhG4B,KAiG7B,GH+eJ,OSqoDe,KAoFH,MNtsEZ,KYklBqB,MAgBjB,OAZe,2BAYf,uCAKK,KAAiB,GAAT,OA6ejB,KAxeiB,EAUS,SAuFtB,gBAKA,mBA/GI,eAAqB,gCAKrB,eAAqB,gCAMrB,OADA,OAEA,eACkB,SA6FtB,mBAKA,mBAG2C,UAAb,mBAGnB,OACJ,YG12BJ,GACC,cAEM,UAEN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,SAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WH81BuC,UAAb,mBAGnB,OACJ,eG12BJ,GACC,cAEM,QAEN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WASA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,aF6emC,cgBxtB3C,EjBykCI,sCiBzkCJ,EjBo+BY,eAAkB,kCAwG9B,MCpX2C,cDuXvC,gCGh3BU,EAIA,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,aF6emC,cgBxtB3C,EjBykCI,sCiBzkCJ,EjB89BY,kCA8GZ,MCpX2C,cDuXvC,4CAvGP,aAAA,GArCJ,oBACkB,sBACH,iBAAmC,OGzuBpC,YACC,cAEM,UAEN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,WAGM,WAGN,EAA4B,QAA5B,IADA,EAA6B,OAAD,IAA5B,IADA,EAA6B,OAAD,IAA5B,WAKA,EAA6B,QAA7B,IAGA,EAA4B,QAA5B,IAFA,EAA6B,OAAD,IAA5B,IACA,EAA6B,OAAD,IAA5B,aH0tBA,wBAED,UAAH,GAAc,KAAgB,eAAhB,4BAEjB,aAAA,EAmxBR,CACO,YACH,G2B96DJ,OjCmwFmB,mDTztDZ,S0CriCe,EADN,KACM,KADb,SAEC,KAAH,EjC46EG,KAAH,EAEU,KAAH,ET14CP,OSytDY,OiC3vFJ,OADC,O1CmiCT,K0CniCkB,EACP,KAAH,IAFR,EAMU,eAAH,kBjCmqFQ,KAoFH,IAAA,YiCjvFJ,a1CwhCR,S+Cj5BgB,qBLnIH,GAHA,OjC4pFE,OiCxpFX,SKkIY,QLlIZ,G1CmhCJ,Q0C/gCA,SACG,CAAH,EAGA,OjCgpFe,KAoFH,IiC3vFJ,OA0Bf,O5BmTmB,cL8lER,YAEA,WAAA,GNxvEX,oBoCvGG,ExBszCI,+BwBtzCJ,iBpC0GA,OAHiC,4BAIjC,EAAA,KAAA,GAJiC,mCoChE1B,OAAH,GACkB,YjC2fd,MiC/eJ,UAXQ,YxB0/CsB,QwB1/CtB,wBADJ,QpC+D8B,WoCvDlC,SpCuDkC,EYnGzC,CAkzCO,+BAlzCmB,EAkxD1B,CAAiE,KAAU,QAAG,GAA9E,oBAAiE,SD5tDZ,UyBsClD,ExBstCI,+BwBttCJ,wBzB9BmD,EAAA,KAAA,GARD,2ByB6E3C,OAAH,KACkB,YjC2Zd,MiC7YJ,OxB64C8B,QwB15CtB,OxB6qCR,+BwB5qCY,EAED,QAAA,qBAAA,OACC,KxByqCZ,+BwBzqCY,GAEJ,KxBuqCR,kCwB9qCI,WAUJ,cxBoqCA,kCAgeuE,aAAA,GAA9E,qBAAiE,OAtN1B,4BsBzgDxB,StB2gDwB,KsBzgDjB,EA6EJ,MAAH,EAII,oBAHS,IrC60BrB,OqC10BY,aA/FW,WH2Ya,oBGrZE,CACA,MADZ,MA1DlB,GAEA,OH6c4B,OArFA,CGxX5B,K5Bm3EL,YAAH,E4Bh2EA,uB5BslJJ,G4BtlJI,eH0boC,oBGnZE,CACA,KADZ,MA5DlB,GAEA,OH6c4B,OArFA,CGxX5B,K5Bm3EL,YAAH,E4Bh2EA,uB5BslJJ,G4BtlJI,eAkJW,KAAH,crCk7CR,GqCh7CY,UAFJ,QAMI,EAFS,KrCk0BrB,OqCh0BY,MrC46CZ,YqCp6CI,yBtB0nDmE,gBNukBnE,aAAA,YAAA,EMvkBX,CAiMO,gBAjMuE,GbpjD9E,oBqClOG,ExBszCI,+BwBtzCJ,iBrCoOA,OAF2B,mCqC3LpB,OAAH,GACkB,YjC2fd,MiC/eJ,UAXQ,YxB0/CsB,QwB1/CtB,wBADJ,QrC0LwB,WqClL5B,SrCkL4B,E8CzRnC,GAEG,WACI,SADE,YAAN,MAKH,EAAA,EA3CA,GAKG,WACI,IAA2B,KAA3B,GADE,mBAAN,MAKH,EAAA,EAoCA,GAEG,aACY,UACA,UACL,GAAH,OAHE,KAAN,KASH,IAAA,EALkB,KAKlB","x-scopes":{"debug_info":[{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":0,"GNU_pubnames":true,"low_pc":0,"ranges":[[6,60],[61,115],[116,184],[185,225],[226,294],[296,468],[564,651],[652,692],[693,778],[779,854],[469,563],[855,866],[867,944]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":6,"high_pc":60,"linkage_name":"_ZN101_$LT$core..ptr..NonNull$LT$T$GT$$u20$as$u20$core..convert..From$LT$core..ptr..Unique$LT$T$GT$$GT$$GT$4from17hef500e08d50dc9feE","name":"from<u8>","decl_file":0,"decl_line":3012,"type":"NonNull<u8>","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"unique","decl_file":5,"decl_line":1,"type":"Unique<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":61,"high_pc":115,"linkage_name":"_ZN101_$LT$core..ptr..Unique$LT$T$GT$$u20$as$u20$core..convert..From$LT$core..ptr..NonNull$LT$T$GT$$GT$$GT$4from17hea627011f69a222bE","name":"from<u8>","decl_file":0,"decl_line":2824,"type":"Unique<u8>","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"p","decl_file":5,"decl_line":1,"type":"NonNull<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":779,"high_pc":854,"linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h760d3f1d67f6109bE","name":"offset<u8>","decl_file":0,"decl_line":1699,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"self","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"count","decl_file":5,"decl_line":1,"type":"isize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":469,"high_pc":563,"linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$7is_null17h20cfba3b19f2019bE","name":"is_null<u8>","decl_file":0,"decl_line":1592,"type":"bool","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","low_pc":116,"high_pc":184,"linkage_name":"_ZN35_$LT$core..ptr..Unique$LT$T$GT$$GT$13new_unchecked17h85cd3ebcf62e7591E","name":"new_unchecked<u8>","decl_file":0,"decl_line":2748,"type":"Unique<u8>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":185,"high_pc":225,"linkage_name":"_ZN35_$LT$core..ptr..Unique$LT$T$GT$$GT$6as_ptr17h9fb36a9b81e6a2e4E","name":"as_ptr<u8>","decl_file":0,"decl_line":2762,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"Unique<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"structure_type","name":"NonNull<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","low_pc":226,"high_pc":294,"linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$13new_unchecked17h8eb2e45269aae918E","name":"new_unchecked<u8>","decl_file":0,"decl_line":2890,"type":"NonNull<u8>","children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":296,"high_pc":468,"linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$3new17h62147e060d66ce77E","name":"new<u8>","decl_file":0,"decl_line":2897,"type":"Option<core::ptr::NonNull<u8>>","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":564,"high_pc":651,"linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$4cast17h2d23dcb9cd6df114E","name":"cast<u8,u8>","decl_file":0,"decl_line":2937,"type":"NonNull<u8>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"NonNull<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"u8","name":"U"}]},{"tag":"subprogram","low_pc":652,"high_pc":692,"linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ptr17h5f4f7f2fd558a669E","name":"as_ptr<u8>","decl_file":0,"decl_line":2908,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"NonNull<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":693,"high_pc":778,"linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$8dangling17h449c72a79dca3d40E","name":"dangling<u8>","decl_file":0,"decl_line":2874,"type":"NonNull<u8>","children":[{"tag":"lexical_block","low_pc":738,"high_pc":755,"children":[{"tag":"variable","location":"230C // DW_OP_plus_uconst 0xc","name":"ptr","decl_file":0,"decl_line":2876,"type":"*mut u8"}]},{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"subprogram","low_pc":855,"high_pc":866,"linkage_name":"_ZN4core3ptr8null_mut17h67f5bdc586747129E","name":"null_mut<u8>","decl_file":0,"decl_line":228,"type":"*mut u8","children":[{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"convert","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":867,"high_pc":944,"linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..Into$LT$U$GT$$GT$4into17h63b1b1f9e942460eE","name":"into<core::ptr::NonNull<u8>,core::ptr::Unique<u8>>","decl_file":1,"decl_line":455,"type":"Unique<u8>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"NonNull<u8>"},{"tag":"template_type_parameter","type":"NonNull<u8>","name":"T"},{"tag":"template_type_parameter","type":"Unique<u8>","name":"U"}]}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<core::ptr::NonNull<u8>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":823,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<u8>","alignment":4,"data_member_location":0}]}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"base_type","name":"isize","encoding":"signed","byte_size":4}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":549,"GNU_pubnames":true,"low_pc":0,"ranges":[[946,1245],[1247,1378],[1379,1426],[1427,1511]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Layout","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size_","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"align_","type":"NonZeroUsize","alignment":4,"data_member_location":4},{"tag":"subprogram","low_pc":946,"high_pc":1245,"linkage_name":"_ZN4core5alloc6Layout15from_size_align17h03956bbe9b651b7bE","name":"from_size_align","decl_file":2,"decl_line":76,"type":"Result<core::alloc::Layout, core::alloc::LayoutErr>","children":[{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"size","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"2314 // DW_OP_plus_uconst 0x14","name":"align","decl_file":5,"decl_line":1,"type":"usize"}]},{"tag":"subprogram","low_pc":1247,"high_pc":1378,"linkage_name":"_ZN4core5alloc6Layout25from_size_align_unchecked17h48772d89ff9743f5E","name":"from_size_align_unchecked","decl_file":2,"decl_line":112,"type":"Layout","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"size","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"align","decl_file":5,"decl_line":1,"type":"usize"}]},{"tag":"subprogram","low_pc":1379,"high_pc":1426,"linkage_name":"_ZN4core5alloc6Layout4size17h24210dce211dac1dE","name":"size","decl_file":2,"decl_line":119,"type":"usize","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&core::alloc::Layout"}]},{"tag":"subprogram","low_pc":1427,"high_pc":1511,"linkage_name":"_ZN4core5alloc6Layout5align17hf3e6ebce66d82a31E","name":"align","decl_file":2,"decl_line":124,"type":"usize","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&core::alloc::Layout"}]}]},{"tag":"structure_type","name":"LayoutErr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"private","type":"()","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"num","children":[{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<core::alloc::Layout, core::alloc::LayoutErr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":1279,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Layout","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"LayoutErr","alignment":1,"data_member_location":0}]}]}]}]},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"pointer_type","type":"Layout","name":"&core::alloc::Layout"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":871,"GNU_pubnames":true,"low_pc":0,"ranges":[[1512,1578],[1579,1626]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"str","children":[{"tag":"subprogram","low_pc":1512,"high_pc":1578,"linkage_name":"_ZN4core3str19from_utf8_unchecked17hdf232e15f1ac46ccE","name":"from_utf8_unchecked","decl_file":3,"decl_line":415,"type":"&str","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"v","decl_file":5,"decl_line":1,"type":"&[u8]"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":1579,"high_pc":1626,"linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$6as_ptr17h8075ea15f765ffdfE","name":"as_ptr","decl_file":3,"decl_line":2281,"type":"*const u8","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&str"}]}]}]}]},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&[u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":1035,"GNU_pubnames":true,"low_pc":0,"ranges":[[1627,1741],[1743,1894],[1895,1942],[1943,2041],[2185,2344],[2346,2505],[2043,2183]],"children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","low_pc":1627,"high_pc":1741,"linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13with_capacity17h8d095a0c7c8a67f7E","name":"with_capacity<u8>","decl_file":4,"decl_line":366,"type":"Vec<u8>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"capacity","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":1743,"high_pc":1894,"linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$14from_raw_parts17h6f44fe445cd8bbbdE","name":"from_raw_parts<u8>","decl_file":4,"decl_line":429,"type":"Vec<u8>","children":[{"tag":"formal_parameter","location":"2314 // DW_OP_plus_uconst 0x14","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"formal_parameter","location":"2318 // DW_OP_plus_uconst 0x18","name":"length","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"231C // DW_OP_plus_uconst 0x1c","name":"capacity","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":1895,"high_pc":1942,"linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h0bf8df54cb714b13E","name":"len<u8>","decl_file":4,"decl_line":1168,"type":"usize","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::vec::Vec<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":1943,"high_pc":2041,"linkage_name":"_ZN66_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h305dd3a467448a94E","name":"drop<u8>","decl_file":4,"decl_line":2111,"children":[{"tag":"formal_parameter","location":"2314 // DW_OP_plus_uconst 0x14","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::vec::Vec<u8>"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":2185,"high_pc":2344,"linkage_name":"_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h1f969e3184370356E","name":"deref<u8>","decl_file":4,"decl_line":1676,"type":"&[u8]","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::vec::Vec<u8>"},{"tag":"lexical_block","low_pc":2246,"high_pc":2309,"children":[{"tag":"variable","location":"230C // DW_OP_plus_uconst 0xc","name":"p","decl_file":4,"decl_line":1678,"type":"*mut u8"}]},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":2346,"high_pc":2505,"linkage_name":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h5ba80122650b884aE","name":"deref_mut<u8>","decl_file":4,"decl_line":1687,"type":"&mut [u8]","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::vec::Vec<u8>"},{"tag":"lexical_block","low_pc":2407,"high_pc":2470,"children":[{"tag":"variable","location":"230C // DW_OP_plus_uconst 0xc","name":"ptr","decl_file":4,"decl_line":1689,"type":"*mut u8"}]},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":2043,"high_pc":2183,"linkage_name":"_ZN80_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..index..IndexMut$LT$I$GT$$GT$9index_mut17h6521b653b6edc872E","name":"index_mut<u8,core::ops::range::RangeFull>","decl_file":4,"decl_line":1667,"type":"&mut [u8]","children":[{"tag":"formal_parameter","location":"2314 // DW_OP_plus_uconst 0x14","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::vec::Vec<u8>"},{"tag":"formal_parameter","location":"2318 // DW_OP_plus_uconst 0x18","name":"index","decl_file":5,"decl_line":1,"type":"RangeFull"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"RangeFull","name":"I"}]}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]}]},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"range","children":[{"tag":"structure_type","name":"RangeFull","byte_size":0,"alignment":1}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&[u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"&mut [u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"Vec<u8>","name":"&alloc::vec::Vec<u8>"},{"tag":"pointer_type","type":"Vec<u8>","name":"&mut alloc::vec::Vec<u8>"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":1395,"GNU_pubnames":true,"low_pc":0,"ranges":[[2507,2850],[2852,3108],[3110,3679]],"children":[{"tag":"namespace","name":"hey","children":[{"tag":"subprogram","low_pc":2507,"high_pc":2850,"linkage_name":"alloc_mem","name":"alloc_mem","decl_file":5,"decl_line":10,"type":"*mut u8","external":true,"children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"size","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"lexical_block","low_pc":2619,"high_pc":2805,"children":[{"tag":"variable","location":"2310 // DW_OP_plus_uconst 0x10","name":"m","decl_file":5,"decl_line":11,"type":"Vec<u8>"},{"tag":"lexical_block","low_pc":2703,"high_pc":2805,"children":[{"tag":"variable","location":"231C // DW_OP_plus_uconst 0x1c","name":"p","decl_file":5,"decl_line":13,"type":"*mut u8"}]}]}]},{"tag":"subprogram","low_pc":2852,"high_pc":3108,"linkage_name":"free_mem","name":"free_mem","decl_file":5,"decl_line":21,"external":true,"children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"p","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"lexical_block","low_pc":2993,"high_pc":3065,"children":[{"tag":"variable","location":"2308 // DW_OP_plus_uconst 0x8","name":"v","decl_file":5,"decl_line":23,"type":"*mut u8"},{"tag":"lexical_block","low_pc":3014,"high_pc":3065,"children":[{"tag":"variable","location":"230C // DW_OP_plus_uconst 0xc","name":"size","decl_file":5,"decl_line":24,"type":"usize"}]}]}]},{"tag":"subprogram","low_pc":3110,"high_pc":3679,"linkage_name":"hello","name":"hello","decl_file":5,"decl_line":30,"external":true,"children":[{"tag":"formal_parameter","location":"2320 // DW_OP_plus_uconst 0x20","name":"name","decl_file":5,"decl_line":1,"type":"*const u8"},{"tag":"formal_parameter","location":"2324 // DW_OP_plus_uconst 0x24","name":"name_len","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"lexical_block","low_pc":3308,"high_pc":3657,"children":[{"tag":"variable","location":"2328 // DW_OP_plus_uconst 0x28","name":"name_str","decl_file":5,"decl_line":31,"type":"&str"},{"tag":"lexical_block","low_pc":3329,"high_pc":3459,"children":[{"tag":"variable","location":"2374 // DW_OP_plus_uconst 0x74","name":"arg0","decl_file":5,"decl_line":34,"type":"&&str"}]},{"tag":"lexical_block","low_pc":3521,"high_pc":3633,"children":[{"tag":"variable","location":"2340 // DW_OP_plus_uconst 0x40","name":"text","decl_file":5,"decl_line":34,"type":"String"},{"tag":"lexical_block","low_pc":3571,"high_pc":3633,"children":[{"tag":"variable","location":"2378 // DW_OP_plus_uconst 0x78","name":"text_str","decl_file":5,"decl_line":35,"type":"&str"}]}]}]}]}]},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"string","children":[{"tag":"structure_type","name":"String","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"vec","type":"Vec<u8>","alignment":4,"data_member_location":0}]}]}]},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"&str","name":"&&str"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":1730,"GNU_pubnames":true,"low_pc":0,"ranges":[[3681,4130],[4132,4355],[4726,4989],[4357,4724],[4991,5331]],"children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"collections","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"CollectionAllocErr","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"CapacityOverflow","const_value":0},{"tag":"enumerator","name":"AllocErr","const_value":1}]}]}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<(), alloc::collections::CollectionAllocErr>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":3131,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"CollectionAllocErr","alignment":1,"data_member_location":0}]},{"tag":"subprogram","low_pc":3681,"high_pc":4130,"linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17hfca458db4027dd55E","name":"unwrap_or_else<(),alloc::collections::CollectionAllocErr,closure>","decl_file":6,"decl_line":771,"children":[{"tag":"formal_parameter","location":"2307 // DW_OP_plus_uconst 0x7","name":"self","decl_file":5,"decl_line":1,"type":"Result<(), alloc::collections::CollectionAllocErr>"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"op","decl_file":5,"decl_line":1,"type":"closure"},{"tag":"lexical_block","low_pc":3870,"high_pc":3928,"children":[{"tag":"variable","location":"231B // DW_OP_plus_uconst 0x1b","name":"e","decl_file":6,"decl_line":774,"type":"CollectionAllocErr"}]},{"tag":"template_type_parameter","type":"()","name":"T"},{"tag":"template_type_parameter","type":"CollectionAllocErr","name":"E"},{"tag":"template_type_parameter","type":"closure","name":"F"}]}]},{"tag":"structure_type","name":"Result<core::alloc::Layout, core::alloc::LayoutErr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":3318,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Layout","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"LayoutErr","alignment":1,"data_member_location":0}]},{"tag":"subprogram","low_pc":4132,"high_pc":4355,"linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6unwrap17h429916f7e5291523E","name":"unwrap<core::alloc::Layout,core::alloc::LayoutErr>","decl_file":6,"decl_line":805,"type":"Layout","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"Result<core::alloc::Layout, core::alloc::LayoutErr>"},{"tag":"lexical_block","low_pc":4253,"high_pc":4267,"children":[{"tag":"variable","location":"2310 // DW_OP_plus_uconst 0x10","name":"t","decl_file":6,"decl_line":807,"type":"Layout"}]},{"tag":"lexical_block","low_pc":4307,"high_pc":4318,"children":[{"tag":"variable","location":"2318 // DW_OP_plus_uconst 0x18","name":"e","decl_file":6,"decl_line":808,"type":"LayoutErr"}]},{"tag":"template_type_parameter","type":"Layout","name":"T"},{"tag":"template_type_parameter","type":"LayoutErr","name":"E"}]}]},{"tag":"structure_type","name":"Result<&str, core::str::Utf8Error>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":3511,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Utf8Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","low_pc":4726,"high_pc":4989,"linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6unwrap17h942923b8590098f1E","name":"unwrap<&str,core::str::Utf8Error>","decl_file":6,"decl_line":805,"type":"&str","children":[{"tag":"formal_parameter","name":"self","decl_file":5,"decl_line":1,"type":"Result<&str, core::str::Utf8Error>"},{"tag":"lexical_block","low_pc":4825,"high_pc":4839,"children":[{"tag":"variable","location":"2308 // DW_OP_plus_uconst 0x8","name":"t","decl_file":6,"decl_line":807,"type":"&str"}]},{"tag":"lexical_block","low_pc":4925,"high_pc":4952,"children":[{"tag":"variable","location":"2310 // DW_OP_plus_uconst 0x10","name":"e","decl_file":6,"decl_line":808,"type":"Utf8Error"}]},{"tag":"template_type_parameter","type":"&str","name":"T"},{"tag":"template_type_parameter","type":"Utf8Error","name":"E"}]}]},{"tag":"subprogram","low_pc":4357,"high_pc":4724,"linkage_name":"_ZN4core6result13unwrap_failed17h03fcd1762b47334eE","name":"unwrap_failed<core::alloc::LayoutErr>","decl_file":6,"decl_line":1008,"type":"!","noreturn":true,"children":[{"tag":"formal_parameter","location":"2318 // DW_OP_plus_uconst 0x18","name":"msg","decl_file":5,"decl_line":1,"type":"&str"},{"tag":"formal_parameter","location":"2320 // DW_OP_plus_uconst 0x20","name":"error","decl_file":5,"decl_line":1,"type":"LayoutErr"},{"tag":"lexical_block","low_pc":4474,"high_pc":4665,"children":[{"tag":"variable","location":"2358 // DW_OP_plus_uconst 0x58","name":"arg0","decl_file":5,"decl_line":1,"type":"&&str"},{"tag":"variable","location":"235C // DW_OP_plus_uconst 0x5c","name":"arg1","decl_file":5,"decl_line":1,"type":"&core::alloc::LayoutErr"}]},{"tag":"template_type_parameter","type":"LayoutErr","name":"E"}]},{"tag":"subprogram","low_pc":4991,"high_pc":5331,"linkage_name":"_ZN4core6result13unwrap_failed17h573e3234c2110d33E","name":"unwrap_failed<core::str::Utf8Error>","decl_file":6,"decl_line":1008,"type":"!","noreturn":true,"children":[{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"msg","decl_file":5,"decl_line":1,"type":"&str"},{"tag":"formal_parameter","name":"error","decl_file":5,"decl_line":1,"type":"Utf8Error"},{"tag":"lexical_block","low_pc":5093,"high_pc":5272,"children":[{"tag":"variable","location":"2348 // DW_OP_plus_uconst 0x48","name":"arg0","decl_file":5,"decl_line":1,"type":"&&str"},{"tag":"variable","location":"234C // DW_OP_plus_uconst 0x4c","name":"arg1","decl_file":5,"decl_line":1,"type":"&core::str::Utf8Error"}]},{"tag":"template_type_parameter","type":"Utf8Error","name":"E"}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Layout","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size_","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"align_","type":"NonZeroUsize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"LayoutErr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"private","type":"()","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"num","children":[{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"str","children":[{"tag":"structure_type","name":"Utf8Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"valid_up_to","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"error_len","type":"Option<u8>","alignment":1,"data_member_location":4}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<u8>","byte_size":2,"alignment":1,"children":[{"tag":"variant_part","discr":4046,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":2,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]}]}]}]},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"base_type","name":"!","encoding":"unsigned","byte_size":0},{"tag":"pointer_type","type":"&str","name":"&&str"},{"tag":"pointer_type","type":"LayoutErr","name":"&core::alloc::LayoutErr"},{"tag":"pointer_type","type":"Utf8Error","name":"&core::str::Utf8Error"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":2376,"GNU_pubnames":true,"low_pc":0,"ranges":[[5332,5400],[5401,5441],[5443,5668],[5896,5971],[5973,6177],[5670,5895]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"num","children":[{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0},{"tag":"subprogram","low_pc":5332,"high_pc":5400,"linkage_name":"_ZN4core3num12NonZeroUsize13new_unchecked17had30d0185fa19a46E","name":"new_unchecked","decl_file":8,"decl_line":72,"type":"NonZeroUsize","children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"n","decl_file":5,"decl_line":1,"type":"usize"}]},{"tag":"subprogram","low_pc":5401,"high_pc":5441,"linkage_name":"_ZN4core3num12NonZeroUsize3get17h14f38ccd5b01abebE","name":"get","decl_file":8,"decl_line":90,"type":"usize","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"NonZeroUsize"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":5443,"high_pc":5668,"linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_mul17h744d0935f5838898E","name":"checked_mul","decl_file":8,"decl_line":2569,"type":"Option<usize>","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"rhs","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"lexical_block","low_pc":5552,"high_pc":5618,"children":[{"tag":"variable","location":"2318 // DW_OP_plus_uconst 0x18","name":"a","decl_file":8,"decl_line":2570,"type":"usize"},{"tag":"variable","location":"231F // DW_OP_plus_uconst 0x1f","name":"b","decl_file":8,"decl_line":2570,"type":"bool"}]}]},{"tag":"subprogram","low_pc":5896,"high_pc":5971,"linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h9d682ba1cfcbc3a3E","name":"wrapping_sub","decl_file":8,"decl_line":2900,"type":"usize","children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"self","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"rhs","decl_file":5,"decl_line":1,"type":"usize"}]},{"tag":"subprogram","low_pc":5973,"high_pc":6177,"linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15is_power_of_two17he56f00427ade38e3E","name":"is_power_of_two","decl_file":8,"decl_line":3551,"type":"bool","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"usize"}]},{"tag":"subprogram","low_pc":5670,"high_pc":5895,"linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_mul17h3f474108ffb1b244E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"type":"(usize, bool)","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"self","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"rhs","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"lexical_block","low_pc":5837,"high_pc":5865,"children":[{"tag":"variable","location":"2310 // DW_OP_plus_uconst 0x10","name":"a","decl_file":8,"decl_line":3223,"type":"u32"},{"tag":"variable","location":"2317 // DW_OP_plus_uconst 0x17","name":"b","decl_file":8,"decl_line":3223,"type":"bool"}]}]}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":4683,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]}]}]},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"structure_type","name":"(usize, bool)","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"bool","alignment":1,"data_member_location":4}]}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":2792,"GNU_pubnames":true,"low_pc":6178,"high_pc":6244,"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":6178,"high_pc":6244,"linkage_name":"_ZN90_$LT$core..ops..range..RangeFull$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h3a287ded69dcfda3E","name":"index_mut<u8>","decl_file":9,"decl_line":2619,"type":"&mut [u8]","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"self","decl_file":5,"decl_line":1,"type":"RangeFull"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"slice","decl_file":5,"decl_line":1,"type":"&mut [u8]"},{"tag":"template_type_parameter","type":"u8","name":"T"}]}]}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"range","children":[{"tag":"structure_type","name":"RangeFull","byte_size":0,"alignment":1}]}]}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"structure_type","name":"&mut [u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":2933,"GNU_pubnames":true,"low_pc":0,"ranges":[[6246,6374],[6376,6506],[6507,6551],[6552,6596],[6597,6641]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"mem","children":[{"tag":"structure_type","name":"ManuallyDrop<alloc::vec::Vec<u8>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"value","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","low_pc":6246,"high_pc":6374,"linkage_name":"_ZN41_$LT$core..mem..ManuallyDrop$LT$T$GT$$GT$3new17h394fd6bc44ef1dcdE","name":"new<alloc::vec::Vec<u8>>","decl_file":10,"decl_line":947,"type":"ManuallyDrop<alloc::vec::Vec<u8>>","children":[{"tag":"formal_parameter","name":"value","decl_file":5,"decl_line":1,"type":"Vec<u8>"},{"tag":"template_type_parameter","type":"Vec<u8>","name":"T"}]}]},{"tag":"subprogram","low_pc":6376,"high_pc":6506,"linkage_name":"_ZN4core3mem6forget17h354783d989ea9a4cE","name":"forget<alloc::vec::Vec<u8>>","decl_file":10,"decl_line":142,"children":[{"tag":"formal_parameter","name":"t","decl_file":5,"decl_line":1,"type":"Vec<u8>"},{"tag":"template_type_parameter","type":"Vec<u8>","name":"T"}]},{"tag":"subprogram","low_pc":6507,"high_pc":6551,"linkage_name":"_ZN4core3mem7size_of17h71d6d2e819d9b247E","name":"size_of<u8>","decl_file":10,"decl_line":289,"type":"usize","children":[{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":6552,"high_pc":6596,"linkage_name":"_ZN4core3mem7size_of17hd70c79c80757e34aE","name":"size_of<usize>","decl_file":10,"decl_line":289,"type":"usize","children":[{"tag":"template_type_parameter","type":"usize","name":"T"}]},{"tag":"subprogram","low_pc":6597,"high_pc":6641,"linkage_name":"_ZN4core3mem8align_of17h680b0317d17ad423E","name":"align_of<u8>","decl_file":10,"decl_line":381,"type":"usize","children":[{"tag":"template_type_parameter","type":"u8","name":"T"}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":3181,"GNU_pubnames":true,"low_pc":0,"ranges":[[6642,6715],[6716,6789],[6790,6878]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"subprogram","low_pc":6642,"high_pc":6715,"linkage_name":"_ZN4core3ptr13drop_in_place17h055fd9c1dd44b22bE","name":"drop_in_place<alloc::raw_vec::RawVec<u8, alloc::alloc::Global>>","decl_file":0,"decl_line":194,"children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","decl_file":5,"decl_line":1,"type":"*mut alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"template_type_parameter","type":"RawVec<u8, alloc::alloc::Global>","name":"T"}]},{"tag":"subprogram","low_pc":6716,"high_pc":6789,"linkage_name":"_ZN4core3ptr13drop_in_place17h615c68804c2e6de2E","name":"drop_in_place<alloc::string::String>","decl_file":0,"decl_line":194,"children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","decl_file":5,"decl_line":1,"type":"*mut alloc::string::String"},{"tag":"template_type_parameter","type":"String","name":"T"}]},{"tag":"subprogram","low_pc":6790,"high_pc":6878,"linkage_name":"_ZN4core3ptr13drop_in_place17h9008d5e224912a80E","name":"drop_in_place<alloc::vec::Vec<u8>>","decl_file":0,"decl_line":194,"children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","decl_file":5,"decl_line":1,"type":"*mut alloc::vec::Vec<u8>"},{"tag":"template_type_parameter","type":"Vec<u8>","name":"T"}]},{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"string","children":[{"tag":"structure_type","name":"String","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"vec","type":"Vec<u8>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"pointer_type","type":"RawVec<u8, alloc::alloc::Global>","name":"*mut alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"pointer_type","type":"String","name":"*mut alloc::string::String"},{"tag":"pointer_type","type":"Vec<u8>","name":"*mut alloc::vec::Vec<u8>"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":3351,"GNU_pubnames":true,"low_pc":0,"ranges":[[6879,7001],[7002,7124],[7125,7172],[7174,7304]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"slice","children":[{"tag":"subprogram","low_pc":6879,"high_pc":7001,"linkage_name":"_ZN4core5slice14from_raw_parts17h052afbf5bc44e936E","name":"from_raw_parts<u8>","decl_file":9,"decl_line":4786,"type":"&[u8]","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"data","decl_file":5,"decl_line":1,"type":"*const u8"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"len","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":7002,"high_pc":7124,"linkage_name":"_ZN4core5slice18from_raw_parts_mut17h29014fb5795b1c6cE","name":"from_raw_parts_mut<u8>","decl_file":9,"decl_line":4807,"type":"&mut [u8]","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"data","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"len","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":7125,"high_pc":7172,"linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$10as_mut_ptr17hc951b9aee4cf6568E","name":"as_mut_ptr<u8>","decl_file":9,"decl_line":416,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&mut [u8]"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":7174,"high_pc":7304,"linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17he8389858a3db2a9dE","name":"index_mut<u8,core::ops::range::RangeFull>","decl_file":9,"decl_line":2326,"type":"&mut [u8]","children":[{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"self","decl_file":5,"decl_line":1,"type":"&mut [u8]"},{"tag":"formal_parameter","location":"2318 // DW_OP_plus_uconst 0x18","name":"index","decl_file":5,"decl_line":1,"type":"RangeFull"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"RangeFull","name":"I"}]}]}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"range","children":[{"tag":"structure_type","name":"RangeFull","byte_size":0,"alignment":1}]}]}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"structure_type","name":"&[u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&mut [u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*mut u8"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":3600,"GNU_pubnames":true,"low_pc":0,"ranges":[[7305,7382],[7383,7486],[7488,7639]],"children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"string","children":[{"tag":"structure_type","name":"String","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"vec","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","low_pc":7305,"high_pc":7382,"linkage_name":"_ZN5alloc6string6String3len17h53d364abea28ec0aE","name":"len","decl_file":11,"decl_line":1377,"type":"usize","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::string::String"}]},{"tag":"subprogram","low_pc":7383,"high_pc":7486,"linkage_name":"_ZN5alloc6string6String6as_str17h0daf485aa1e9532dE","name":"as_str","decl_file":11,"decl_line":768,"type":"&str","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::string::String"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":7488,"high_pc":7639,"linkage_name":"_ZN65_$LT$alloc..string..String$u20$as$u20$core..ops..deref..Deref$GT$5deref17hab1b79581a8ed550E","name":"deref","decl_file":11,"decl_line":2042,"type":"&str","children":[{"tag":"formal_parameter","location":"231C // DW_OP_plus_uconst 0x1c","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::string::String"}]}]}]},{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]}]},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"String","name":"&alloc::string::String"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":3800,"GNU_pubnames":true,"low_pc":0,"ranges":[[7640,7760],[7892,8012],[8144,8266],[7762,7891],[8014,8143],[8268,8409]],"children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":7640,"high_pc":7760,"linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$12alloc_zeroed17h70ef23748aa83430E","name":"alloc_zeroed","decl_file":12,"decl_line":173,"type":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::alloc::Global"},{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]},{"tag":"subprogram","low_pc":7892,"high_pc":8012,"linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17hdae0cc68db2642efE","name":"alloc","decl_file":12,"decl_line":153,"type":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::alloc::Global"},{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]},{"tag":"subprogram","low_pc":8144,"high_pc":8266,"linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hf89751a30a4f1bfcE","name":"dealloc","decl_file":12,"decl_line":158,"children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::alloc::Global"},{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"ptr","decl_file":5,"decl_line":1,"type":"NonNull<u8>"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]}]},{"tag":"subprogram","low_pc":7762,"high_pc":7891,"linkage_name":"_ZN5alloc5alloc12alloc_zeroed17hae0624b9d95c53d1E","name":"alloc_zeroed","decl_file":12,"decl_line":146,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]},{"tag":"subprogram","low_pc":8014,"high_pc":8143,"linkage_name":"_ZN5alloc5alloc5alloc17hfce1f45e064faeeeE","name":"alloc","decl_file":12,"decl_line":77,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]},{"tag":"subprogram","low_pc":8268,"high_pc":8409,"linkage_name":"_ZN5alloc5alloc7dealloc17h232bdaa99f1308b2E","name":"dealloc","decl_file":12,"decl_line":95,"children":[{"tag":"formal_parameter","location":"2304 // DW_OP_plus_uconst 0x4","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"layout","decl_file":5,"decl_line":1,"type":"Layout"}]},{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]}]},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":7077,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<u8>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AllocErr","alignment":1,"data_member_location":0}]}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"NonNull<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"AllocErr","byte_size":0,"alignment":1},{"tag":"structure_type","name":"Layout","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size_","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"align_","type":"NonZeroUsize","alignment":4,"data_member_location":4}]}]},{"tag":"namespace","name":"num","children":[{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]}]}]},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"Global","name":"&mut alloc::alloc::Global"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":4138,"GNU_pubnames":true,"low_pc":0,"ranges":[[8410,8530],[9163,9294],[8532,9161],[9549,9587],[9588,9637],[9639,9867],[9869,10150],[10151,10235],[9296,9548],[10236,10309]],"children":[{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"collections","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"CollectionAllocErr","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"CapacityOverflow","const_value":0},{"tag":"enumerator","name":"AllocErr","const_value":1}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0},{"tag":"subprogram","low_pc":8410,"high_pc":8530,"linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$13with_capacity17h5e5701d6bd75530eE","name":"with_capacity<u8>","decl_file":13,"decl_line":149,"type":"RawVec<u8, alloc::alloc::Global>","children":[{"tag":"formal_parameter","location":"2314 // DW_OP_plus_uconst 0x14","name":"cap","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":9163,"high_pc":9294,"linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$14from_raw_parts17hf2f18c1886c36e5cE","name":"from_raw_parts<u8>","decl_file":13,"decl_line":185,"type":"RawVec<u8, alloc::alloc::Global>","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"ptr","decl_file":5,"decl_line":1,"type":"*mut u8"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"cap","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"template_type_parameter","type":"u8","name":"T"}]},{"tag":"subprogram","low_pc":8532,"high_pc":9161,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in17h16236f13a54307faE","name":"allocate_in<u8,alloc::alloc::Global>","decl_file":13,"decl_line":90,"type":"RawVec<u8, alloc::alloc::Global>","children":[{"tag":"formal_parameter","location":"2318 // DW_OP_plus_uconst 0x18","name":"cap","decl_file":5,"decl_line":1,"type":"usize"},{"tag":"formal_parameter","location":"231F // DW_OP_plus_uconst 0x1f","name":"zeroed","decl_file":5,"decl_line":1,"type":"bool"},{"tag":"formal_parameter","location":"2320 // DW_OP_plus_uconst 0x20","name":"a","decl_file":5,"decl_line":1,"type":"Global"},{"tag":"lexical_block","ranges":[[8596,9031],[9034,9111]],"children":[{"tag":"variable","location":"2330 // DW_OP_plus_uconst 0x30","name":"elem_size","decl_file":13,"decl_line":92,"type":"usize"},{"tag":"lexical_block","ranges":[[8666,9031],[9034,9111]],"children":[{"tag":"variable","location":"2334 // DW_OP_plus_uconst 0x34","name":"alloc_size","decl_file":13,"decl_line":94,"type":"usize"},{"tag":"lexical_block","ranges":[[8739,9031],[9034,9072]],"children":[{"tag":"variable","location":"234C // DW_OP_plus_uconst 0x4c","name":"align","decl_file":13,"decl_line":101,"type":"usize"},{"tag":"lexical_block","ranges":[[8830,9031],[9034,9072]],"children":[{"tag":"variable","location":"2350 // DW_OP_plus_uconst 0x50","name":"layout","decl_file":13,"decl_line":102,"type":"Layout"},{"tag":"lexical_block","ranges":[[8971,9031],[9034,9072]],"children":[{"tag":"variable","location":"2358 // DW_OP_plus_uconst 0x58","name":"result","decl_file":13,"decl_line":103,"type":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>"},{"tag":"lexical_block","low_pc":9048,"high_pc":9072,"children":[{"tag":"variable","location":"235C // DW_OP_plus_uconst 0x5c","name":"ptr","decl_file":13,"decl_line":109,"type":"NonNull<u8>"}]}]}]}]},{"tag":"lexical_block","low_pc":9073,"high_pc":9111,"children":[{"tag":"variable","location":"2348 // DW_OP_plus_uconst 0x48","name":"ptr","decl_file":13,"decl_line":98,"type":"NonNull<u8>"}]}]}]},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]},{"tag":"subprogram","low_pc":9639,"high_pc":9867,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17hced6583b3e751febE","name":"current_layout<u8,alloc::alloc::Global>","decl_file":13,"decl_line":233,"type":"Option<core::alloc::Layout>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"lexical_block","low_pc":9727,"high_pc":9817,"children":[{"tag":"variable","location":"2318 // DW_OP_plus_uconst 0x18","name":"align","decl_file":13,"decl_line":240,"type":"usize"},{"tag":"lexical_block","low_pc":9763,"high_pc":9817,"children":[{"tag":"variable","location":"231C // DW_OP_plus_uconst 0x1c","name":"size","decl_file":13,"decl_line":241,"type":"usize"}]}]},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]},{"tag":"subprogram","low_pc":9869,"high_pc":10150,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17h50a3c3d94602ae09E","name":"dealloc_buffer<u8,alloc::alloc::Global>","decl_file":13,"decl_line":716,"children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"lexical_block","low_pc":9921,"high_pc":10127,"children":[{"tag":"variable","location":"230C // DW_OP_plus_uconst 0xc","name":"elem_size","decl_file":13,"decl_line":717,"type":"usize"},{"tag":"lexical_block","low_pc":10058,"high_pc":10127,"children":[{"tag":"variable","location":"2318 // DW_OP_plus_uconst 0x18","name":"layout","decl_file":13,"decl_line":719,"type":"Layout"}]}]},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]},{"tag":"subprogram","low_pc":10151,"high_pc":10235,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hf93ab7c79327c207E","name":"ptr<u8,alloc::alloc::Global>","decl_file":13,"decl_line":207,"type":"*mut u8","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"allocate_in","children":[{"tag":"subprogram","low_pc":9549,"high_pc":9587,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in28_$u7b$$u7b$closure$u7d$$u7d$17h15930e5a1fbab95fE","name":"{{closure}}<u8,alloc::alloc::Global>","decl_file":13,"decl_line":94,"type":"usize","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","decl_file":5,"decl_line":1,"type":"closure"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]},{"tag":"subprogram","low_pc":9588,"high_pc":9637,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in28_$u7b$$u7b$closure$u7d$$u7d$17hba5a2c4be332f514E","name":"{{closure}}<u8,alloc::alloc::Global>","decl_file":13,"decl_line":95,"children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","decl_file":5,"decl_line":1,"type":"closure"},{"tag":"formal_parameter","location":"230F // DW_OP_plus_uconst 0xf","decl_file":5,"decl_line":1,"type":"CollectionAllocErr"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]}]},{"tag":"subprogram","low_pc":10236,"high_pc":10309,"linkage_name":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hbc7e48591b7c3f52E","name":"drop<u8,alloc::alloc::Global>","decl_file":13,"decl_line":728,"children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"&mut alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"template_type_parameter","type":"u8","name":"T"},{"tag":"template_type_parameter","type":"Global","name":"A"}]}]},{"tag":"subprogram","low_pc":9296,"high_pc":9548,"linkage_name":"_ZN5alloc7raw_vec11alloc_guard17h9dac90e3a31b1fffE","name":"alloc_guard","decl_file":13,"decl_line":745,"type":"Result<(), alloc::collections::CollectionAllocErr>","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"alloc_size","decl_file":5,"decl_line":1,"type":"usize"}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1}]}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<core::alloc::Layout>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":8431,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Layout","alignment":4,"data_member_location":0}]}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Layout","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size_","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"align_","type":"NonZeroUsize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"AllocErr","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"num","children":[{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<(), alloc::collections::CollectionAllocErr>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":8579,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"CollectionAllocErr","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":8665,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<u8>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AllocErr","alignment":1,"data_member_location":0}]}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"pointer_type","type":"RawVec<u8, alloc::alloc::Global>","name":"&alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"},{"tag":"pointer_type","type":"RawVec<u8, alloc::alloc::Global>","name":"&mut alloc::raw_vec::RawVec<u8, alloc::alloc::Global>"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":4912,"GNU_pubnames":true,"low_pc":0,"ranges":[[10311,10649],[10651,10985]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":8880,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"subprogram","low_pc":10311,"high_pc":10649,"linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17ha5dc6a7ad421e174E","name":"unwrap_or_else<usize,closure>","decl_file":14,"decl_line":393,"type":"usize","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"self","decl_file":5,"decl_line":1,"type":"Option<usize>"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"f","decl_file":5,"decl_line":1,"type":"closure"},{"tag":"lexical_block","low_pc":10487,"high_pc":10501,"children":[{"tag":"variable","location":"2314 // DW_OP_plus_uconst 0x14","name":"x","decl_file":14,"decl_line":395,"type":"usize"}]},{"tag":"template_type_parameter","type":"usize","name":"T"},{"tag":"template_type_parameter","type":"closure","name":"F"}]}]},{"tag":"structure_type","name":"Option<core::ptr::NonNull<u8>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":9051,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<u8>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","low_pc":10651,"high_pc":10985,"linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$5ok_or17h71ed850ba067f9d4E","name":"ok_or<core::ptr::NonNull<u8>,core::alloc::AllocErr>","decl_file":14,"decl_line":498,"type":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","children":[{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"self","decl_file":5,"decl_line":1,"type":"Option<core::ptr::NonNull<u8>>"},{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"err","decl_file":5,"decl_line":1,"type":"AllocErr"},{"tag":"lexical_block","low_pc":10813,"high_pc":10827,"children":[{"tag":"variable","location":"2318 // DW_OP_plus_uconst 0x18","name":"v","decl_file":14,"decl_line":500,"type":"NonNull<u8>"}]},{"tag":"template_type_parameter","type":"NonNull<u8>","name":"T"},{"tag":"template_type_parameter","type":"AllocErr","name":"E"}]}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"NonNull<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"AllocErr","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<core::ptr::NonNull<u8>, core::alloc::AllocErr>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":9290,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<u8>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AllocErr","alignment":1,"data_member_location":0}]}]}]}]},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"hey.rs","stmt_list":5285,"GNU_pubnames":true,"low_pc":0,"ranges":[[10986,11106],[11107,11229],[11230,11352],[11353,11475],[11477,11655]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"result","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Result","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Ok","const_value":0},{"tag":"enumerator","name":"Err","const_value":1}]}]},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"rt","children":[{"tag":"namespace","name":"v1","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Alignment","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Left","const_value":0},{"tag":"enumerator","name":"Right","const_value":1},{"tag":"enumerator","name":"Center","const_value":2},{"tag":"enumerator","name":"Unknown","const_value":3}]},{"tag":"structure_type","name":"Argument","byte_size":36,"alignment":4,"children":[{"tag":"member","name":"position","type":"Position","alignment":4,"data_member_location":0},{"tag":"member","name":"format","type":"FormatSpec","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Position","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":9570,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Next","type":"Next","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"At","type":"At","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Next","byte_size":8,"alignment":4},{"tag":"structure_type","name":"At","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"FormatSpec","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":24},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"precision","type":"Count","alignment":4,"data_member_location":8},{"tag":"member","name":"width","type":"Count","alignment":4,"data_member_location":16}]},{"tag":"structure_type","name":"Count","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":9708,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Is","type":"Is","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Param","type":"Param","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"NextParam","type":"NextParam","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Implied","type":"Implied","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Is","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Param","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NextParam","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Implied","byte_size":8,"alignment":4}]}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":10986,"high_pc":11106,"linkage_name":"_ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Display$GT$3fmt17hcf066c709eda24b1E","name":"fmt<str>","decl_file":15,"decl_line":1914,"type":"Result","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"self","decl_file":5,"decl_line":1,"type":"&&str"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"f","decl_file":5,"decl_line":1,"type":"&mut core::fmt::Formatter"},{"tag":"template_type_parameter","type":"i8[]","name":"T"}]}]},{"tag":"structure_type","name":"ArgumentV1","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&core::fmt::Void","alignment":4,"data_member_location":0},{"tag":"member","name":"formatter","type":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>","alignment":4,"data_member_location":4},{"tag":"subprogram","low_pc":11107,"high_pc":11229,"linkage_name":"_ZN4core3fmt10ArgumentV13new17h085daee7e0355b67E","name":"new<&str>","decl_file":15,"decl_line":308,"type":"ArgumentV1","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"x","decl_file":5,"decl_line":1,"type":"&&str"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"f","decl_file":5,"decl_line":1,"type":"fn(&&str, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"template_type_parameter","type":"&str","name":"T"}]},{"tag":"subprogram","low_pc":11230,"high_pc":11352,"linkage_name":"_ZN4core3fmt10ArgumentV13new17h228c7a9133db937eE","name":"new<core::str::Utf8Error>","decl_file":15,"decl_line":308,"type":"ArgumentV1","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"x","decl_file":5,"decl_line":1,"type":"&core::str::Utf8Error"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"f","decl_file":5,"decl_line":1,"type":"fn(&core::str::Utf8Error, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"template_type_parameter","type":"Utf8Error","name":"T"}]},{"tag":"subprogram","low_pc":11353,"high_pc":11475,"linkage_name":"_ZN4core3fmt10ArgumentV13new17hdc125fd4f0ef3bf8E","name":"new<core::alloc::LayoutErr>","decl_file":15,"decl_line":308,"type":"ArgumentV1","children":[{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"x","decl_file":5,"decl_line":1,"type":"&core::alloc::LayoutErr"},{"tag":"formal_parameter","location":"230C // DW_OP_plus_uconst 0xc","name":"f","decl_file":5,"decl_line":1,"type":"fn(&core::alloc::LayoutErr, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"template_type_parameter","type":"LayoutErr","name":"T"}]}]},{"tag":"structure_type","name":"Void","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_priv","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"_oibit_remover","type":"PhantomData<*mut Fn<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Formatter","byte_size":52,"alignment":4,"children":[{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":48},{"tag":"member","name":"width","type":"Option<usize>","alignment":4,"data_member_location":8},{"tag":"member","name":"precision","type":"Option<usize>","alignment":4,"data_member_location":16},{"tag":"member","name":"buf","type":"&mut Write","alignment":4,"data_member_location":24},{"tag":"member","name":"curarg","type":"Iter<core::fmt::ArgumentV1>","alignment":4,"data_member_location":32},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":40}]},{"tag":"structure_type","name":"&mut Write","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"structure_type","name":"Arguments","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"pieces","type":"&[&str]","alignment":4,"data_member_location":0},{"tag":"member","name":"fmt","type":"Option<&[core::fmt::rt::v1::Argument]>","alignment":4,"data_member_location":8},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":16},{"tag":"subprogram","low_pc":11477,"high_pc":11655,"linkage_name":"_ZN4core3fmt9Arguments16new_v1_formatted17hef9d375d211204d8E","name":"new_v1_formatted","decl_file":15,"decl_line":362,"type":"Arguments","children":[{"tag":"formal_parameter","location":"2300 // DW_OP_plus_uconst 0x0","name":"pieces","decl_file":5,"decl_line":1,"type":"&[&str]"},{"tag":"formal_parameter","location":"2308 // DW_OP_plus_uconst 0x8","name":"args","decl_file":5,"decl_line":1,"type":"&[core::fmt::ArgumentV1]"},{"tag":"formal_parameter","location":"2310 // DW_OP_plus_uconst 0x10","name":"fmt","decl_file":5,"decl_line":1,"type":"&[core::fmt::rt::v1::Argument]"}]}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<*mut Fn<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&core::fmt::ArgumentV1>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":10413,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"Option<&[core::fmt::rt::v1::Argument]>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":10488,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[core::fmt::rt::v1::Argument]","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<u8>","byte_size":2,"alignment":1,"children":[{"tag":"variant_part","discr":10562,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":2,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"structure_type","name":"Iter<core::fmt::ArgumentV1>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&core::fmt::ArgumentV1>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"str","children":[{"tag":"structure_type","name":"Utf8Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"valid_up_to","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"error_len","type":"Option<u8>","alignment":1,"data_member_location":4}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"LayoutErr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"private","type":"()","alignment":1,"data_member_location":0}]}]}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"pointer_type","type":"Void","name":"&core::fmt::Void"},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::fmt::Void"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"pointer_type","type":"Formatter","name":"&mut core::fmt::Formatter"},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"char","encoding":"unsigned_char","byte_size":4},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"usize[]","name":"&[usize; 3]"},{"tag":"array_type","type":"usize","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":3}]},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"pointer_type","type":"ArgumentV1","name":"*const core::fmt::ArgumentV1"},{"tag":"structure_type","name":"&[core::fmt::ArgumentV1]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"&[&str]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"&str","name":"*const &str"},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"structure_type","name":"&[core::fmt::rt::v1::Argument]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::rt::v1::Argument","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"Argument","name":"*const core::fmt::rt::v1::Argument"},{"tag":"array_type","type":"i8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0}]},{"tag":"base_type","name":"i8","encoding":"signed","byte_size":1},{"tag":"pointer_type","type":"&str","name":"&&str"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&&str, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&&str"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"pointer_type","type":"Utf8Error","name":"&core::str::Utf8Error"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::str::Utf8Error, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::str::Utf8Error"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"pointer_type","type":"LayoutErr","name":"&core::alloc::LayoutErr"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::alloc::LayoutErr, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::alloc::LayoutErr"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"libstd/lib.rs","stmt_list":5596,"GNU_pubnames":true,"low_pc":0,"ranges":[[11737,11888],[11889,11901],[11902,11915],[11916,11942],[11943,11969],[11970,11972],[11973,12005],[12006,12048],[12050,12413],[12414,12530],[12531,12586],[12587,12589],[12590,12627],[12628,12681],[12682,12698],[12700,12847],[12848,12949],[12950,12961],[12963,13126],[13484,13830],[13832,14084],[13128,13482],[14085,14134]],"children":[{"tag":"variable","name":"vtable","type":"vtable","location":"03D0131000 // DW_OP_addr 0x1013d0"},{"tag":"structure_type","containing_type":11213,"name":"vtable","byte_size":0,"alignment":4},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"Write","children":[{"tag":"namespace","name":"write_fmt","children":[{"tag":"structure_type","name":"Adapter<alloc::string::String>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut alloc::string::String","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Adapter<std::io::Write::write_fmt::Adaptor<std::sys::wasm::stdio::Stderr>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut std::io::Write::write_fmt::Adaptor<std::sys::wasm::stdio::Stderr>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Adapter<std::io::Write::write_fmt::Adaptor<std::io::stdio::StdoutLock>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut std::io::Write::write_fmt::Adaptor<std::io::stdio::StdoutLock>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Adapter<std::io::Write::write_fmt::Adaptor<std::io::stdio::StderrLock>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut std::io::Write::write_fmt::Adaptor<std::io::stdio::StderrLock>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":12050,"high_pc":12413,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h1f79fa176a4da4f9E","name":"write_char<alloc::string::String>","decl_file":15,"decl_line":217,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$10write_char17h5ae3f38b5c88c7ebE","low_pc":12077,"high_pc":12398,"call_file":15,"call_line":218,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String4push17h282a1665f9952b5fE","low_pc":12077,"high_pc":12398,"call_file":11,"call_line":2290,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","ranges":[[12077,12089],[12168,12180]],"call_file":11,"call_line":1068},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$4push17h685aa171ecd1dd2aE","low_pc":12089,"high_pc":12160,"call_file":11,"call_line":1069,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17hc5fd2ec542addbc2E","low_pc":12096,"high_pc":12103,"call_file":4,"call_line":998},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h38e1111107f5ff14E","low_pc":12116,"high_pc":12132,"call_file":4,"call_line":1002,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17h97c1a7f9c2a1bef2E","low_pc":12127,"high_pc":12132,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17he74a77de5c7f44c2E","low_pc":12132,"high_pc":12135,"call_file":4,"call_line":1002,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hd883fde0849ad06cE","low_pc":12132,"high_pc":12135,"call_file":0,"call_line":1938}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr5write17hdfafc58547be0720E","low_pc":12135,"high_pc":12140,"call_file":4,"call_line":1003}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","low_pc":12180,"high_pc":12350,"call_file":11,"call_line":1070},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17h1c30330c056f186dE","low_pc":12351,"high_pc":12398,"call_file":11,"call_line":1070,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h5123a2c6f35f1db1E","low_pc":12351,"high_pc":12398,"call_file":4,"call_line":1329,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17h25c1f8dae33ebda8E","ranges":[[12361,12363],[12373,12376]],"call_file":4,"call_line":1893},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h82c854383ee416d4E","ranges":[[12376,12378],[12383,12384]],"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h1a64b20495db2ce0E","ranges":[[12376,12378],[12383,12384]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hce3ad0ef1c396649E","ranges":[[12376,12378],[12383,12384]],"call_file":9,"call_line":2575,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17he74a77de5c7f44c2E","ranges":[[12376,12378],[12383,12384]],"call_file":9,"call_line":2491,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hd883fde0849ad06cE","ranges":[[12376,12378],[12383,12384]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h38e1111107f5ff14E","low_pc":12378,"high_pc":12383,"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17h97c1a7f9c2a1bef2E","low_pc":12378,"high_pc":12383,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17h59b33e4d5a2eda96E","low_pc":12384,"high_pc":12398,"call_file":4,"call_line":1894},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h36fdd8d064e94d91E","low_pc":12363,"high_pc":12368,"call_file":4,"call_line":1892}]}]}]}]}]},{"tag":"subprogram","low_pc":12414,"high_pc":12530,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_fmt17heebb64bd456fe439E","name":"write_fmt<alloc::string::String>","decl_file":15,"decl_line":221,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17h32e4478ccf3b83d4E","ranges":[[12434,12436],[12441,12516]],"call_file":15,"call_line":222}]},{"tag":"subprogram","low_pc":12531,"high_pc":12586,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h4e193309ec76cbf1E","name":"write_str<alloc::string::String>","decl_file":15,"decl_line":213,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$9write_str17h5482869985281e48E","low_pc":12539,"high_pc":12585,"call_file":15,"call_line":214,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String8push_str17h524abcd6952f7a86E","low_pc":12539,"high_pc":12585,"call_file":11,"call_line":2284,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17h1c30330c056f186dE","low_pc":12539,"high_pc":12585,"call_file":11,"call_line":808,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h5123a2c6f35f1db1E","low_pc":12539,"high_pc":12585,"call_file":4,"call_line":1329,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17h25c1f8dae33ebda8E","ranges":[[12549,12551],[12561,12564]],"call_file":4,"call_line":1893},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h82c854383ee416d4E","ranges":[[12564,12566],[12571,12572]],"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h1a64b20495db2ce0E","ranges":[[12564,12566],[12571,12572]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hce3ad0ef1c396649E","ranges":[[12564,12566],[12571,12572]],"call_file":9,"call_line":2575,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17he74a77de5c7f44c2E","ranges":[[12564,12566],[12571,12572]],"call_file":9,"call_line":2491,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hd883fde0849ad06cE","ranges":[[12564,12566],[12571,12572]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h38e1111107f5ff14E","low_pc":12566,"high_pc":12571,"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17h97c1a7f9c2a1bef2E","low_pc":12566,"high_pc":12571,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17h59b33e4d5a2eda96E","low_pc":12572,"high_pc":12585,"call_file":4,"call_line":1894},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h36fdd8d064e94d91E","low_pc":12551,"high_pc":12556,"call_file":4,"call_line":1892}]}]}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write10write_char17h3c0cf192dc77a97eE","name":"write_char<std::io::Write::write_fmt::Adaptor<std::io::stdio::StderrLock>>","decl_file":15,"decl_line":179,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17h8cf49d156fb0ea5fE","name":"write_fmt<std::io::Write::write_fmt::Adaptor<std::sys::wasm::stdio::Stderr>>","decl_file":15,"decl_line":204,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17he0bbe997cdab58e0E","name":"write_fmt<std::io::Write::write_fmt::Adaptor<std::io::stdio::StderrLock>>","decl_file":15,"decl_line":204,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17hc37d217214db7ac0E","name":"write_fmt<std::io::Write::write_fmt::Adaptor<std::io::stdio::StdoutLock>>","decl_file":15,"decl_line":204,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17h32e4478ccf3b83d4E","name":"write_fmt<alloc::string::String>","decl_file":15,"decl_line":204,"inline":"inlined"}]},{"tag":"structure_type","name":"Arguments","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"pieces","type":"&[&str]","alignment":4,"data_member_location":0},{"tag":"member","name":"fmt","type":"Option<&[core::fmt::rt::v1::Argument]>","alignment":4,"data_member_location":8},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":16},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","name":"new_v1_formatted","decl_file":15,"decl_line":362,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments6new_v117h030d4cea03f336acE","name":"new_v1","decl_file":15,"decl_line":344,"inline":"inlined"}]},{"tag":"namespace","name":"rt","children":[{"tag":"namespace","name":"v1","children":[{"tag":"structure_type","name":"Argument","byte_size":36,"alignment":4,"children":[{"tag":"member","name":"position","type":"Position","alignment":4,"data_member_location":0},{"tag":"member","name":"format","type":"FormatSpec","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Position","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":13563,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Next","type":"Next","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"At","type":"At","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Next","byte_size":8,"alignment":4},{"tag":"structure_type","name":"At","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"FormatSpec","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":24},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"precision","type":"Count","alignment":4,"data_member_location":8},{"tag":"member","name":"width","type":"Count","alignment":4,"data_member_location":16}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Alignment","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Left","const_value":0},{"tag":"enumerator","name":"Right","const_value":1},{"tag":"enumerator","name":"Center","const_value":2},{"tag":"enumerator","name":"Unknown","const_value":3}]},{"tag":"structure_type","name":"Count","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":13737,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Is","type":"Is","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Param","type":"Param","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"NextParam","type":"NextParam","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Implied","type":"Implied","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Is","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Param","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NextParam","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Implied","byte_size":8,"alignment":4}]}]}]},{"tag":"structure_type","name":"ArgumentV1","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&core::fmt::Void","alignment":4,"data_member_location":0},{"tag":"member","name":"formatter","type":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Void","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_priv","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"_oibit_remover","type":"PhantomData<*mut Fn<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Formatter","byte_size":52,"alignment":4,"children":[{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":48},{"tag":"member","name":"width","type":"Option<usize>","alignment":4,"data_member_location":8},{"tag":"member","name":"precision","type":"Option<usize>","alignment":4,"data_member_location":16},{"tag":"member","name":"buf","type":"&mut Write","alignment":4,"data_member_location":24},{"tag":"member","name":"curarg","type":"Iter<core::fmt::ArgumentV1>","alignment":4,"data_member_location":32},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":40}]},{"tag":"structure_type","name":"&mut Write","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h801be80cd33fcae3E","name":"fmt<str>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h64e432f86802e65dE","name":"fmt<std::ffi::os_str::OsStr>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN41_$LT$bool$u20$as$u20$core..fmt..Debug$GT$3fmt17h55b270119393f3a1E","name":"fmt","decl_file":15,"decl_line":1943,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$$BP$const$u20$T$u20$as$u20$core..fmt..Pointer$GT$3fmt17hf76f19d5b1f24269E","name":"fmt<u8>","decl_file":15,"decl_line":2007,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$$BP$const$u20$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h2e42c1fc100ad157E","name":"fmt<u8>","decl_file":15,"decl_line":2058,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$$LP$$RP$$u20$as$u20$core..fmt..Debug$GT$3fmt17h9e2b8e470868e824E","name":"fmt","decl_file":15,"decl_line":2106,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN48_$LT$$u5b$T$u5d$$u20$as$u20$core..fmt..Debug$GT$3fmt17hd6b2ac7e6c19211dE","name":"fmt<u8>","decl_file":15,"decl_line":2098,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN48_$LT$$u5b$T$u5d$$u20$as$u20$core..fmt..Debug$GT$3fmt17hbf538a44a472e0ffE","name":"fmt<std::ffi::os_str::OsString>","decl_file":15,"decl_line":2098,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17hce8a6af6fb50481eE","name":"fmt<alloc::boxed::Box<std::io::error::Custom>>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Display$GT$3fmt17h619d3bd051baeb6dE","name":"fmt<core::str::lossy::Utf8Lossy>","decl_file":15,"decl_line":1914,"inline":"inlined"}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u32$GT$3fmt17hb0293d31e6820497E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17hcf9174035eb5e775E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u64$GT$3fmt17ha14c1f7a27b15e99E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i64$GT$3fmt17h6d0db092329e2635E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..Debug$u20$for$u20$usize$GT$3fmt17h9443525d0da36952E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"}]}]},{"tag":"namespace","name":"builders","children":[{"tag":"structure_type","name":"DebugList","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"DebugInner","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17h346b55f6ef607892E","name":"entries<&u8,core::slice::Iter<u8>>","decl_file":39,"decl_line":421,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17hc099b124f4dfb75eE","name":"entries<&std::ffi::os_str::OsString,core::slice::Iter<std::ffi::os_str::OsString>>","decl_file":39,"decl_line":421,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17h93ed0e441ad79bc7E","name":"entries<std::path::Component,std::path::Components>","decl_file":39,"decl_line":421,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17h62d1d5e79d8102b1E","name":"entries<&std::ffi::os_str::OsStr,std::path::Iter>","decl_file":39,"decl_line":421,"inline":"inlined"}]},{"tag":"structure_type","name":"DebugInner","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":4},{"tag":"member","name":"has_fields","type":"bool","alignment":1,"data_member_location":5}]}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_mut17h852df80a17c40738E","name":"as_mut<alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":0,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ref17h2ba06e436622195dE","name":"as_ref<alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":0,"decl_line":2919,"inline":"inlined"}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_mut17hc69206dc1bccd2dbE","name":"as_mut<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":0,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ref17hc86a2662856726a7E","name":"as_ref<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":0,"decl_line":2919,"inline":"inlined"}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_mut17h0e4fa739f2b4844aE","name":"as_mut<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":0,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ref17hcdbc12a2c9de1cadE","name":"as_ref<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":0,"decl_line":2919,"inline":"inlined"}]},{"tag":"structure_type","name":"Unique<alloc::boxed::Box<FnBox<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::boxed::Box<FnBox<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<alloc::boxed::Box<FnBox<()>>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<core::task::wake::LocalWaker>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const core::task::wake::LocalWaker>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<UnsafeWake>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const UnsafeWake>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::thread::Inner>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::thread::Inner>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_mut17hfdf2cea7c97a4e81E","name":"as_mut<alloc::sync::ArcInner<std::thread::Inner>>","decl_file":0,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ref17h584e96becbff4514E","name":"as_ref<alloc::sync::ArcInner<std::thread::Inner>>","decl_file":0,"decl_line":2919,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17h2ce2a5620a363f7bE","name":"write<alloc::raw_vec::RawVec<u8, alloc::alloc::Global>>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17he4f35225da5c53d9E","name":"drop_in_place<std::io::buffered::BufWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h43aeb1c104eecc64E","name":"drop_in_place<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h4265b079066edc7bE","name":"drop_in_place<core::cell::UnsafeCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h88ae68e26fc4d005E","name":"drop_in_place<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h850a7298f148e2dbE","name":"drop_in_place<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h81125b9f61d9e8f8E","name":"drop_in_place<alloc::raw_vec::RawVec<u8, alloc::alloc::Global>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h73f3dfdafc70df51E","name":"drop_in_place<alloc::vec::Vec<u8>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h5b903b269cf7501bE","name":"drop_in_place<std::thread::Inner>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hfdd3ad6015e3e34fE","name":"drop_in_place<core::option::Option<std::ffi::c_str::CString>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17habd4ec9491232400E","name":"drop_in_place<std::ffi::c_str::CString>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h19c9122f5d2e841fE","name":"drop_in_place<alloc::boxed::Box<[u8]>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hffea51a65b15b5c0E","name":"drop_in_place<alloc::boxed::Box<std::sys_common::mutex::Mutex>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hc144bfe5d4c6525dE","name":"drop_in_place<std::sync::mutex::Mutex<()>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_mut17h9de0868207b97defE","name":"as_mut<alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","decl_file":0,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ref17h60a39ca90254f1b0E","name":"as_ref<alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","decl_file":0,"decl_line":2919,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17ha5a1cf60a7d21df4E","name":"drop_in_place<alloc::sync::Arc<std::thread::Inner>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h4c3d198ea56e1bf3E","name":"drop_in_place<std::thread::Thread>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb4e1d8d4d3dac84dE","name":"drop_in_place<std::sync::mpsc::blocking::Inner>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h8df31e7ad0b49912E","name":"drop_in_place<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hc72c3036d3e72946E","name":"drop_in_place<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h7a2e65b9b238e6d6E","name":"drop_in_place<core::cell::UnsafeCell<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h6bd503537184e556E","name":"offset<u8>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hc8c77c366ba9271fE","name":"offset<std::ffi::os_str::OsString>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h953f835a476b5ddcE","name":"add<u8>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hd883fde0849ad06cE","name":"offset<u8>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17he74a77de5c7f44c2E","name":"add<u8>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hb307506599a621a4E","name":"offset<std::ffi::os_str::OsString>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h4a63e834458bf3eeE","name":"add<std::ffi::os_str::OsString>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$11offset_from17hf381e70ef5f06f24E","name":"offset_from<std::ffi::os_str::OsString>","decl_file":0,"decl_line":1192,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h3ff2724e1156e2f4E","name":"offset<u16>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hb2b61610af8565cbE","name":"offset<std::net::addr::SocketAddr>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h7557bbcea043e53cE","name":"add<std::net::addr::SocketAddr>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h5da86e07b859c495E","name":"offset<u16>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17hf0a6e0adf34ee45bE","name":"add<u16>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17ha110ef5aa0a3e047E","name":"offset<alloc::collections::btree::node::BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h51616094ff6ef796E","name":"add<alloc::collections::btree::node::BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":1297,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hba3b57864b9e078fE","name":"drop_in_place<core::result::Result<(), std::io::error::Error>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h6e636d0143c2b666E","name":"drop_in_place<std::io::error::Repr>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb1ad9bdd8ac4cbf5E","name":"drop_in_place<std::io::error::Error>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h377f22bc7ba7e9b8E","name":"drop_in_place<alloc::boxed::Box<std::io::error::Custom>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h22a19fd676ef3660E","name":"drop_in_place<alloc::boxed::Box<Error>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h76129ae3da7d1308E","name":"drop_in_place<std::io::error::Custom>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h3f1d94c640c7cdeeE","name":"swap_nonoverlapping_one<isize>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h356b8c71e68fddceE","name":"drop_in_place<core::cell::BorrowRefMut>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hd566ed84af477f3dE","name":"drop_in_place<core::cell::RefMut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","low_pc":11970,"high_pc":11972,"linkage_name":"_ZN4core3ptr13drop_in_place17h0237f67e0370a25bE","name":"drop_in_place<&std::net::addr::SocketAddrV4>","decl_file":0,"decl_line":194},{"tag":"subprogram","low_pc":11973,"high_pc":12005,"abstract_origin":"_ZN4core3ptr13drop_in_place17h73f3dfdafc70df51E","children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h81125b9f61d9e8f8E","low_pc":11973,"high_pc":12003,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h32c521ec5670cd01E","low_pc":11973,"high_pc":12003,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hb67e6fc3ca39c235E","low_pc":11973,"high_pc":12003,"call_file":13,"call_line":729,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h62834538e5e7018fE","low_pc":11973,"high_pc":11983,"call_file":13,"call_line":719},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","low_pc":11993,"high_pc":12003,"call_file":13,"call_line":720,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","low_pc":11993,"high_pc":12003,"call_file":12,"call_line":159}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hca835d8500a3e24bE","name":"drop_in_place<alloc::boxed::Box<Any>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h575b1021ef6b0055E","name":"drop_in_place<core::option::Option<alloc::string::String>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hc8e1957d25feb8d3E","name":"drop_in_place<alloc::string::String>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","low_pc":12006,"high_pc":12048,"linkage_name":"_ZN4core3ptr13drop_in_place17hf25728a71da40244E","name":"drop_in_place<std::panicking::continue_panic_fmt::PanicPayload>","decl_file":0,"decl_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h575b1021ef6b0055E","low_pc":12006,"high_pc":12046,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17hc8e1957d25feb8d3E","low_pc":12021,"high_pc":12046,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h73f3dfdafc70df51E","low_pc":12021,"high_pc":12046,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h81125b9f61d9e8f8E","low_pc":12021,"high_pc":12046,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h32c521ec5670cd01E","low_pc":12021,"high_pc":12046,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hb67e6fc3ca39c235E","low_pc":12021,"high_pc":12046,"call_file":13,"call_line":729,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h62834538e5e7018fE","low_pc":12021,"high_pc":12029,"call_file":13,"call_line":719},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","low_pc":12034,"high_pc":12046,"call_file":13,"call_line":720,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","low_pc":12034,"high_pc":12046,"call_file":12,"call_line":159}]}]}]}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h3ea42da24c0d7a6aE","name":"drop_in_place<std::sys_common::mutex::MutexGuard>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h11c0c1195121291fE","name":"read<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hdcb44ab37f8671c5E","name":"swap_nonoverlapping_one<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h3a8da43efd166145E","name":"drop_in_place<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h4641dc7ccd89cff8E","name":"drop_in_place<alloc::boxed::Box<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17hd4c15dc673484329E","name":"read<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hde6ca5851640c852E","name":"swap_nonoverlapping_one<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h28164d9a56d6b25aE","name":"drop_in_place<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h334f7878a0521008E","name":"drop_in_place<alloc::boxed::Box<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h9adbc9e989712941E","name":"read<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h826b58156891213bE","name":"swap_nonoverlapping_one<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h077f6de29ecc2846E","name":"drop_in_place<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h284f9a55d436234bE","name":"drop_in_place<alloc::boxed::Box<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17hdfafc58547be0720E","name":"write<u8>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hf060cf2b1e9af996E","name":"swap_nonoverlapping_one<core::option::Option<core::cell::Cell<usize>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h94675b143fa9fa8bE","name":"swap_nonoverlapping_one<usize>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17ha35fe8e5d09f29dcE","name":"drop_in_place<std::sync::mutex::MutexGuard<()>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"structure_type","name":"Unique<std::ffi::os_str::OsString>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const std::ffi::os_str::OsString>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<std::ffi::os_str::OsString>","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17hdc0b65f183ea5074E","name":"write<std::ffi::os_str::OsString>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"structure_type","name":"NonNull<std::ffi::os_str::OsString>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const std::ffi::os_str::OsString>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h59bdad4db7f97a2eE","name":"drop_in_place<std::ffi::c_str::NulError>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h9f4a386c14b0ecf0E","name":"drop_in_place<alloc::vec::SetLenOnDrop>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h263e00a7b2beec26E","name":"drop_in_place<core::result::Result<bool, std::io::error::Error>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h72457f620300e181E","name":"drop_in_place<std::io::Guard>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h7e6fc6b44a0aac6bE","name":"drop_in_place<std::sync::mutex::MutexGuard<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h74da37db43b04617E","name":"drop_in_place<std::io::stdio::StdinLock>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hfacf471a091139ceE","name":"drop_in_place<std::sys_common::remutex::ReentrantMutexGuard<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h1b1265b0d6d48ac9E","name":"drop_in_place<std::io::stdio::StdoutLock>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h2cee0907498d635cE","name":"drop_in_place<core::cell::RefMut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb346bf28a792cc78E","name":"drop_in_place<std::sys_common::remutex::ReentrantMutexGuard<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hf6219b71b66bddf7E","name":"drop_in_place<std::io::stdio::StderrLock>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h1a67167b37c5cd4eE","name":"read<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h111770615eaf6b75E","name":"swap_nonoverlapping_one<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h39fa1e5d884187baE","name":"swap_nonoverlapping_one<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h1c1bb99780c27df0E","name":"drop_in_place<core::cell::RefMut<core::option::Option<alloc::boxed::Box<Write>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hfed6678c76f4d397E","name":"drop_in_place<std::io::stdio::Stdout>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h6e1819c0d812f47bE","name":"drop_in_place<std::io::stdio::Stderr>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h66b46bc78984535bE","name":"drop_in_place<core::result::Result<usize, std::io::error::Error>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h62554e5959ef8829E","name":"drop_in_place<std::sys::wasm::os_str::Buf>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h459db34c00590e80E","name":"drop_in_place<std::ffi::os_str::OsString>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb8d5a6b36cf23be0E","name":"drop_in_place<core::result::Result<std::fs::Metadata, std::io::error::Error>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"structure_type","name":"Unique<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h347f12fd777b1efbE","name":"read<alloc::collections::btree::map::BTreeMap<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hddf845726e99200bE","name":"drop_in_place<alloc::collections::btree::map::BTreeMap<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"structure_type","name":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h2af9335555e23467E","name":"drop_in_place<alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h3d6a43774e70e8eeE","name":"read<alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>, alloc::collections::btree::node::marker::Edge>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h60d2d033231dcd8eE","name":"read<core::option::Option<std::ffi::os_str::OsString>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17hc1a52421a40690d8E","name":"read<std::sys_common::process::DefaultEnvKey>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h3f5415067729a930E","name":"drop_in_place<std::sys_common::process::DefaultEnvKey>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h41c0cc85b7c2fa90E","name":"drop_in_place<(std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>)>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h7c94869328e7d26dE","name":"drop_in_place<core::option::Option<std::ffi::os_str::OsString>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr2eq17hafe16c047b0752cbE","name":"eq<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":0,"decl_line":2508,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h55eea6db78131274E","name":"drop_in_place<alloc::sync::Arc<std::sync::mpsc::blocking::Inner>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h42380c9483d44976E","name":"drop_in_place<std::sync::mpsc::blocking::WaitToken>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Unique<core::option::Option<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const core::option::Option<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<core::option::Option<()>>","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hfe90ce4c449da698E","name":"drop_in_place<std::sync::mpsc::blocking::SignalToken>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17ha367021f88d3bd08E","name":"drop_in_place<core::option::Option<std::sync::mpsc::blocking::SignalToken>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17hce5121bb8e891770E","name":"read<core::option::Option<std::sync::mpsc::blocking::SignalToken>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hb19e25bc52f49a14E","name":"swap_nonoverlapping_one<core::option::Option<std::sync::mpsc::blocking::SignalToken>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hd5bb5e858382b0c6E","name":"drop_in_place<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h5251e2f60d3fbdb7E","name":"read<core::option::Option<closure>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hc10da6bc5d498a36E","name":"swap_nonoverlapping_one<core::option::Option<closure>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h644dc478dd31a915E","name":"read<*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h33798c1d7b935be9E","name":"swap_nonoverlapping_one<*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17hb3aec557b88c1bdfE","name":"read<alloc::boxed::Box<FnBox<()>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h6862b551040da9a5E","name":"drop_in_place<alloc::raw_vec::RawVec<alloc::boxed::Box<FnBox<()>>, alloc::alloc::Global>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17haafcffb93dcdf862E","name":"drop_in_place<alloc::vec::IntoIter<alloc::boxed::Box<FnBox<()>>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hfb444edcf0a8f9bcE","name":"drop_in_place<core::option::Option<std::thread::Thread>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h992d3ed8c36fe49cE","name":"drop_in_place<std::sync::once::Waiter>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h102289e01104a743E","name":"drop_in_place<std::sync::once::Finish>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h8238cf30fd483ae7E","name":"read<core::option::Option<std::thread::Thread>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h300d61814b1f7132E","name":"swap_nonoverlapping_one<core::option::Option<std::thread::Thread>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h8b9c96cff6a2d217E","name":"swap_nonoverlapping_one<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17hb03dade3bc04f27eE","name":"read<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hc94ca2e12fb6ebb0E","name":"swap_nonoverlapping_one<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h8fed3bf64ebf57b3E","name":"drop_in_place<alloc::boxed::Box<FnBox<()>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17hdde5e57bdd597fd1E","name":"write<alloc::boxed::Box<FnBox<()>>>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h805a01d81e557862E","name":"swap_nonoverlapping_one<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h159af6c1b56f1e14E","name":"drop_in_place<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h1f83068609f7619eE","name":"drop_in_place<std::sys_common::thread_info::ThreadInfo>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h90893a2254afee59E","name":"drop_in_place<core::cell::RefMut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h478634d8410eb055E","name":"drop_in_place<alloc::boxed::Box<std::sys::wasm::thread_local::Allocated>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h53ca5e37eb4254f5E","name":"drop_in_place<alloc::boxed::Box<Fn<(&core::panic::PanicInfo)>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hc9e310ebe3de8313E","name":"drop_in_place<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hd8719d2e5c3c6187E","name":"drop_in_place<alloc::boxed::Box<Write>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17he0d53da0ce217253E","name":"write<i32>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17he755636b8c4af4feE","name":"read<closure>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h50db8561207ec1daE","name":"read<alloc::string::String>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h935a40d8b085a85bE","name":"swap_nonoverlapping_one<alloc::string::String>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"structure_type","name":"NonNull<Any>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const Any>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ptr17h069f348455340b37E","name":"as_ptr<Any>","decl_file":0,"decl_line":2908,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h59ac3e2430b5922fE","name":"read<core::option::Option<&str>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17h25e5144ea99581a0E","name":"swap_nonoverlapping_one<core::option::Option<&str>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17he7d382d156901d3eE","name":"read<alloc::boxed::Box<Any>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hd4e135a8b466dcbeE","name":"swap_nonoverlapping_one<alloc::boxed::Box<Any>>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb7b4f412b350d3d3E","name":"drop_in_place<core::result::Result<i32, alloc::boxed::Box<Any>>>","decl_file":0,"decl_line":194,"inline":"inlined"}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::boxed::Box<FnBox<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::boxed::Box<FnBox<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const core::task::wake::LocalWaker>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const core::task::wake::LocalWaker","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const UnsafeWake>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const UnsafeWake","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::thread::Inner>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::thread::Inner>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const std::ffi::os_str::OsString>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const core::option::Option<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const core::option::Option<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const Any>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const Any","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<alloc::boxed::Box<FnBox<()>>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<*mut std::sync::once::Waiter>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<*mut Fn<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&core::fmt::ArgumentV1>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<core::hash::sip::Sip13Rounds>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::thread::Inner>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mpsc::blocking::Inner>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&std::ffi::os_str::OsString>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::ffi::os_str::OsString>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<*mut ()>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&u16>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::Internal)>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<alloc::collections::btree::node::marker::Edge>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::Leaf)>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<(alloc::collections::btree::node::marker::Immut, alloc::collections::btree::node::marker::Leaf)>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<alloc::collections::btree::node::marker::KV>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<(alloc::collections::btree::node::marker::Immut, alloc::collections::btree::node::marker::Internal)>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::LeafOrInternal)>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mpsc::oneshot::Packet<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mpsc::stream::Packet<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mpsc::shared::Packet<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<core::option::Option<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<std::sync::mpsc::sync::Packet<()>>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"result","children":[{"tag":"structure_type","name":"Result<(), std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":19754,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$5is_ok17hadef20f51c423734E","name":"is_ok<(),std::io::error::Error>","decl_file":6,"decl_line":292,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6is_err17h16262beec91d5be9E","name":"is_err<(),std::io::error::Error>","decl_file":6,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17hf72609031f0f5d46E","name":"and_then<(),std::io::error::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::time::SystemTime, std::io::error::Error>","byte_size":24,"alignment":8,"children":[{"tag":"variant_part","discr":19879,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"SystemTime","alignment":8,"data_member_location":8}]},{"tag":"structure_type","name":"Err","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":4}]}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Result","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Ok","const_value":0},{"tag":"enumerator","name":"Err","const_value":1}]},{"tag":"structure_type","name":"Result<core::cell::RefMut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>, core::cell::BorrowMutError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":19990,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefMut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"BorrowMutError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17hcd40903468772c71E","name":"expect<core::cell::RefMut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>,core::cell::BorrowMutError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<(), alloc::collections::CollectionAllocErr>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":20281,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"CollectionAllocErr","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17h205607cb1322ca1dE","name":"unwrap_or_else<(),alloc::collections::CollectionAllocErr,closure>","decl_file":6,"decl_line":771,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::sync::mutex::MutexGuard<()>, std::sys_common::poison::PoisonError<std::sync::mutex::MutexGuard<()>>>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":20380,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"MutexGuard<()>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"PoisonError<std::sync::mutex::MutexGuard<()>>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6unwrap17h82b57b472b0889a4E","name":"unwrap<std::sync::mutex::MutexGuard<()>,std::sys_common::poison::PoisonError<std::sync::mutex::MutexGuard<()>>>","decl_file":6,"decl_line":805,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::ffi::c_str::CString, std::ffi::c_str::NulError>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":20480,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"CString","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NulError","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h76235d467fda26b6E","name":"expect<std::ffi::c_str::CString,std::ffi::c_str::NulError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::option::Option<std::ffi::os_str::OsString>, std::io::error::Error>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":20580,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Option<std::ffi::os_str::OsString>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17he45a706a02f6dc91E","name":"unwrap_or_else<core::option::Option<std::ffi::os_str::OsString>,std::io::error::Error,closure>","decl_file":6,"decl_line":771,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::alloc::Layout, core::alloc::LayoutErr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":20680,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Layout","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"LayoutErr","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17hcaaf499797a270e1E","name":"map_err<core::alloc::Layout,core::alloc::LayoutErr,alloc::collections::CollectionAllocErr,closure>","decl_file":6,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h91c4980d53b0391aE","name":"map_err<core::alloc::Layout,core::alloc::LayoutErr,alloc::collections::CollectionAllocErr,closure>","decl_file":6,"decl_line":527,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<alloc::string::String, alloc::string::FromUtf8Error>","byte_size":24,"alignment":4,"children":[{"tag":"variant_part","discr":20792,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"FromUtf8Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h41cefe40064d1e6aE","name":"map_err<alloc::string::String,alloc::string::FromUtf8Error,std::sys::wasm::os_str::Buf,closure>","decl_file":6,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h5f2f08168ced9011E","name":"map_err<alloc::string::String,alloc::string::FromUtf8Error,std::ffi::c_str::IntoStringError,closure>","decl_file":6,"decl_line":527,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<alloc::string::String, std::ffi::os_str::OsString>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":20905,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"OsString","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6unwrap17h35c82961c3e954d0E","name":"unwrap<alloc::string::String,std::ffi::os_str::OsString>","decl_file":6,"decl_line":805,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<alloc::string::String, std::sys::wasm::os_str::Buf>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":21005,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Buf","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17hb4a889adf660edd1E","name":"map_err<alloc::string::String,std::sys::wasm::os_str::Buf,std::ffi::os_str::OsString,closure>","decl_file":6,"decl_line":527,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<&str, core::str::Utf8Error>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":21105,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Utf8Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$2ok17hdab643627dfa0d81E","name":"ok<&str,core::str::Utf8Error>","decl_file":6,"decl_line":344,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$5is_ok17hbc81c1a5b938c4aaE","name":"is_ok<&str,core::str::Utf8Error>","decl_file":6,"decl_line":292,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6is_err17hfce56170a0175a0dE","name":"is_err<&str,core::str::Utf8Error>","decl_file":6,"decl_line":316,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17h2aed76fa40a84e24E","name":"from_error<std::fs::File,std::io::error::Error>","decl_file":6,"decl_line":1274,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$11into_result17h0b6ac76c1416414dE","name":"into_result<std::sys::wasm::fs::File,std::io::error::Error>","decl_file":6,"decl_line":1264,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17hebffc681d6bf8e6fE","name":"from_error<usize,std::io::error::Error>","decl_file":6,"decl_line":1274,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17h39589ff0f784cfc4E","name":"from_error<alloc::vec::IntoIter<std::net::addr::SocketAddr>,std::io::error::Error>","decl_file":6,"decl_line":1274,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$11into_result17h11ebfcd2a39de552E","name":"into_result<std::sys::wasm::net::LookupHost,std::io::error::Error>","decl_file":6,"decl_line":1264,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::sys::wasm::fs::FileAttr, std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$3map17h6027a04eae1480a4E","name":"map<std::sys::wasm::fs::FileAttr,std::io::error::Error,std::fs::Metadata,fn(std::sys::wasm::fs::FileAttr) -> std::fs::Metadata>","decl_file":6,"decl_line":466,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::fs::Metadata, std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$3map17hdc108fb135678d6eE","name":"map<std::fs::Metadata,std::io::error::Error,bool,closure>","decl_file":6,"decl_line":466,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<bool, std::io::error::Error>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":21412,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"bool","alignment":1,"data_member_location":1}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$9unwrap_or17h14820c8e5abaeb09E","name":"unwrap_or<bool,std::io::error::Error>","decl_file":6,"decl_line":746,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<usize, core::num::TryFromIntError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":21512,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"TryFromIntError","alignment":1,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h0f227c1edf767ecdE","name":"map_err<usize,core::num::TryFromIntError,std::io::error::Error,closure>","decl_file":6,"decl_line":527,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<usize, std::io::error::Error>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":21612,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17hba33be013e1bd542E","name":"and_then<usize,std::io::error::Error,usize,closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17haf26746134ebcda0E","name":"and_then<usize,std::io::error::Error,usize,closure>","decl_file":6,"decl_line":645,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::cell::RefMut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>, core::cell::BorrowMutError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":21725,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefMut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"BorrowMutError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17haf986bcbe5a1eb04E","name":"expect<core::cell::RefMut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>,core::cell::BorrowMutError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::cell::RefMut<core::option::Option<alloc::boxed::Box<Write>>>, core::cell::BorrowMutError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":21824,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefMut<core::option::Option<alloc::boxed::Box<Write>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"BorrowMutError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h11f4f96de160ee90E","name":"expect<core::cell::RefMut<core::option::Option<alloc::boxed::Box<Write>>>,core::cell::BorrowMutError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::result::Result<(), std::io::error::Error>, std::thread::local::AccessError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":21923,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Result<(), std::io::error::Error>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AccessError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17hd0db465bd7f88905E","name":"unwrap_or_else<core::result::Result<(), std::io::error::Error>,std::thread::local::AccessError,closure>","decl_file":6,"decl_line":771,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17h110766914b9df0f8E","name":"unwrap_or_else<core::result::Result<(), std::io::error::Error>,std::thread::local::AccessError,closure>","decl_file":6,"decl_line":771,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::net::addr::SocketAddr, std::net::parser::AddrParseError>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":22035,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddr","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AddrParseError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$2ok17hbb9d8200b57f17a6E","name":"ok<std::net::addr::SocketAddr,std::net::parser::AddrParseError>","decl_file":6,"decl_line":344,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::sys::wasm::net::TcpStream, std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$3map17h6b51d42eb01f7b28E","name":"map<std::sys::wasm::net::TcpStream,std::io::error::Error,std::net::tcp::TcpStream,fn(std::sys::wasm::net::TcpStream) -> std::net::tcp::TcpStream>","decl_file":6,"decl_line":466,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::sys::wasm::fs::ReadDir, std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$3map17h9f60e893edc56268E","name":"map<std::sys::wasm::fs::ReadDir,std::io::error::Error,std::fs::ReadDir,fn(std::sys::wasm::fs::ReadDir) -> std::fs::ReadDir>","decl_file":6,"decl_line":466,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>, alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":22244,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$2ok17h90e277f0a8b7613eE","name":"ok<alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>,alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>>","decl_file":6,"decl_line":344,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>, alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":22344,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$2ok17h2adf1d63c3c95132E","name":"ok<alloc::collections::btree::node::Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>,alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>>","decl_file":6,"decl_line":344,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<(std::sys::wasm::process::Process, std::sys::wasm::process::StdioPipes), std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$3map17hb46f515844f57c96E","name":"map<(std::sys::wasm::process::Process, std::sys::wasm::process::StdioPipes),std::io::error::Error,std::process::Child,fn((std::sys::wasm::process::Process, std::sys::wasm::process::StdioPipes)) -> std::process::Child>","decl_file":6,"decl_line":466,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::process::Child, std::io::error::Error>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Error","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h974b18d324e1022cE","name":"and_then<std::process::Child,std::io::error::Error,std::process::Output,closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h3b01f7611cec9dfeE","name":"and_then<std::process::Child,std::io::error::Error,std::process::ExitStatus,closure>","decl_file":6,"decl_line":645,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>, std::sys_common::poison::PoisonError<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>>>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":22567,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"MutexGuard<std::sync::barrier::BarrierState>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"PoisonError<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6unwrap17hd6d47d70264f32d9E","name":"unwrap<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>,std::sys_common::poison::PoisonError<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>>>","decl_file":6,"decl_line":805,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::time::Duration, core::time::Duration>","byte_size":24,"alignment":8,"children":[{"tag":"variant_part","discr":22667,"children":[{"tag":"member","type":"u64","alignment":8,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":8}]},{"tag":"structure_type","name":"Err","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":8}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h912948bca6e2d942E","name":"map_err<core::time::Duration,core::time::Duration,std::time::SystemTimeError,fn(core::time::Duration) -> std::time::SystemTimeError>","decl_file":6,"decl_line":527,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::cell::Ref<core::option::Option<std::sys_common::thread_info::ThreadInfo>>, core::cell::BorrowError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":22767,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ref<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"BorrowError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h84a13d31d482dedfE","name":"expect<core::cell::Ref<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,core::cell::BorrowError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<core::cell::RefMut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>, core::cell::BorrowMutError>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":22866,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefMut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"BorrowMutError","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h7738715d5b66ec6eE","name":"expect<core::cell::RefMut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,core::cell::BorrowMutError>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"structure_type","name":"Result<i32, alloc::boxed::Box<Any>>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":22965,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"i32","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Box<Any>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$9unwrap_or17h71f68145260028aeE","name":"unwrap_or<i32,alloc::boxed::Box<Any>>","decl_file":6,"decl_line":746,"inline":"inlined"}]}]},{"tag":"namespace","name":"sync","children":[{"tag":"namespace","name":"atomic","children":[{"tag":"structure_type","name":"AtomicBool","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10AtomicBool4load17h5119bc22c7a6647fE","name":"load","decl_file":20,"decl_line":358,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10AtomicBool5store17h4bf69e3b6c4a4aa1E","name":"store","decl_file":20,"decl_line":390,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10AtomicBool16compare_exchange17h097f92683e87584aE","name":"compare_exchange","decl_file":20,"decl_line":510,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10AtomicBool16compare_and_swap17h2198a9f7c56637ffE","name":"compare_and_swap","decl_file":20,"decl_line":459,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<usize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize9fetch_sub17h39c2730b6f3ee10dE","name":"fetch_sub","decl_file":20,"decl_line":1516,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize16compare_exchange17hddb54728ef8d0321E","name":"compare_exchange","decl_file":20,"decl_line":1394,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize4swap17h154460f02ffa4da3E","name":"swap","decl_file":20,"decl_line":1296,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize9fetch_add17h938aa481cf200a52E","name":"fetch_add","decl_file":20,"decl_line":1484,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize16compare_and_swap17hd90b95fbd8a49b7fE","name":"compare_and_swap","decl_file":20,"decl_line":1336,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize4load17h0741b33a28325388E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize5store17hd178fc802d4d84ddE","name":"store","decl_file":20,"decl_line":1266,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicIsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicIsize4load17h44d356fd1215243bE","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicIsize5store17hb39a666fda866159E","name":"store","decl_file":20,"decl_line":1266,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicPtr<()>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"p","type":"UnsafeCell<*mut ()>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..sync..atomic..AtomicPtr$LT$T$GT$$GT$5store17h6db34fc76960152bE","name":"store<()>","decl_file":20,"decl_line":877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..sync..atomic..AtomicPtr$LT$T$GT$$GT$4swap17h994668bd52826f5aE","name":"swap<()>","decl_file":20,"decl_line":910,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..sync..atomic..AtomicPtr$LT$T$GT$$GT$4load17h04df2205efa17d68E","name":"load<()>","decl_file":20,"decl_line":843,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicU32","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u32>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10atomic_sub17h0c68c55b3c4d0bd9E","name":"atomic_sub<usize>","decl_file":20,"decl_line":2072,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic23atomic_compare_exchange17h6da04bcb6fa47951E","name":"atomic_compare_exchange<usize>","decl_file":20,"decl_line":2084,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17hd4911304bc9d5061E","name":"atomic_load<u8>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_swap17hf08a9bc95ae5d243E","name":"atomic_swap<usize>","decl_file":20,"decl_line":2046,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic12atomic_store17h306352e2c772f9f1E","name":"atomic_store<u8>","decl_file":20,"decl_line":2023,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10atomic_add17h267d3cd8e5e5ea2cE","name":"atomic_add<usize>","decl_file":20,"decl_line":2059,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic23atomic_compare_exchange17h6de927e4008ff3c6E","name":"atomic_compare_exchange<u8>","decl_file":20,"decl_line":2084,"inline":"inlined"},{"tag":"structure_type","name":"AtomicPtr<std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"p","type":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"AtomicPtr<std::sync::mpsc::mpsc_queue::Node<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"p","type":"UnsafeCell<*mut std::sync::mpsc::mpsc_queue::Node<()>>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17he8a0208e42cf5365E","name":"atomic_load<usize>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic12atomic_store17he97144563363e390E","name":"atomic_store<usize>","decl_file":20,"decl_line":2023,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h16dac3e760e6292bE","name":"atomic_load<isize>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic12atomic_store17h40a8a68fd5e70951E","name":"atomic_store<isize>","decl_file":20,"decl_line":2023,"inline":"inlined"}]}]},{"tag":"namespace","name":"cell","children":[{"tag":"structure_type","name":"UnsafeCell<u8>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"u8","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"Cell<isize>","alignment":4,"data_member_location":0},{"tag":"member","name":"value","type":"UnsafeCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$3new17h1093c763c5e04099E","name":"new<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","decl_file":25,"decl_line":660,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$14try_borrow_mut17hcad1d29a049af0a6E","name":"try_borrow_mut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","decl_file":25,"decl_line":913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$10borrow_mut17ha3b40e948ef363c3E","name":"borrow_mut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","decl_file":25,"decl_line":885,"inline":"inlined"}]},{"tag":"structure_type","name":"Cell<isize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17h87f23d44b65c9c11E","name":"get<isize>","decl_file":25,"decl_line":258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h9d314c0705471f6dE","name":"replace<isize>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h6d8cb63cbcc817a8E","name":"set<isize>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<isize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"isize","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"value","type":"LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"Cell<isize>","alignment":4,"data_member_location":0},{"tag":"member","name":"value","type":"UnsafeCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$14try_borrow_mut17h4e970c4c9e7e182bE","name":"try_borrow_mut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","decl_file":25,"decl_line":913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$10borrow_mut17hd51ee1470c3c49bfE","name":"borrow_mut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","decl_file":25,"decl_line":885,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"Maybe","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<bool>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"bool","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h88fe24f51514d293E","name":"replace<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17hcabb153b5605b554E","name":"get<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":25,"decl_line":258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h2f3657d16ca4f80dE","name":"set<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"usize","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"value","type":"BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h3fca4cbd689cea26E","name":"replace<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17he79ca456a1dda116E","name":"get<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":25,"decl_line":258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h08492fb982a702dfE","name":"set<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h53687960b2936dacE","name":"replace<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17h1a9e4819f285d87dE","name":"get<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":25,"decl_line":258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h42beede58f45db95E","name":"set<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<*mut ()>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut ()","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<u32>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"u32","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::cell::Cell<(u64, u64)>>>","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"value","type":"Option<core::cell::Cell<(u64, u64)>>","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<(u64, u64)>","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"value","type":"UnsafeCell<(u64, u64)>","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<(u64, u64)>","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"value","type":"(u64, u64)","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"RefCell<core::option::Option<alloc::boxed::Box<Write>>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"Cell<isize>","alignment":4,"data_member_location":0},{"tag":"member","name":"value","type":"UnsafeCell<core::option::Option<alloc::boxed::Box<Write>>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$14try_borrow_mut17hf2592e52db2990d4E","name":"try_borrow_mut<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":25,"decl_line":913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$10borrow_mut17h66f5bbdba5e2a164E","name":"borrow_mut<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":25,"decl_line":885,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<alloc::boxed::Box<Write>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<alloc::boxed::Box<Write>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h9bb17ff8e8e0e0e0E","name":"replace<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h1135908d1c4dd0deE","name":"set<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<core::ptr::NonNull<core::task::wake::LocalWaker>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"Cell<isize>","alignment":4,"data_member_location":0},{"tag":"member","name":"value","type":"UnsafeCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$10try_borrow17h68b4b16ae80a2eb3E","name":"try_borrow<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","decl_file":25,"decl_line":835,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$6borrow17h3fb76acbd716c6ffE","name":"borrow<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","decl_file":25,"decl_line":804,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$14try_borrow_mut17h66c0658716288d22E","name":"try_borrow_mut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","decl_file":25,"decl_line":913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$core..cell..RefCell$LT$T$GT$$GT$10borrow_mut17h2a049470d853083aE","name":"borrow_mut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","decl_file":25,"decl_line":885,"inline":"inlined"}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<std::sys_common::thread_info::ThreadInfo>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<()>","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"value","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<core::cell::Cell<usize>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<core::cell::Cell<usize>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Cell<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"UnsafeCell<usize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17h53823485519654e3E","name":"get<usize>","decl_file":25,"decl_line":258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h4d641de484797b00E","name":"replace<usize>","decl_file":25,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h1bd04e28e2963583E","name":"set<usize>","decl_file":25,"decl_line":398,"inline":"inlined"}]},{"tag":"structure_type","name":"BorrowRefMut","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"&core::cell::Cell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4cell12BorrowRefMut3new17h9ae77fa33e975146E","name":"new","decl_file":25,"decl_line":1320,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN80_$LT$core..cell..BorrowRefMut$LT$$u27$_$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h5b87f654e49be111E","name":"drop","decl_file":25,"decl_line":1311,"inline":"inlined"}]},{"tag":"structure_type","name":"RefMut<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&mut std::io::stdio::Maybe<std::io::stdio::StderrRaw>","alignment":4,"data_member_location":0},{"tag":"member","name":"borrow","type":"BorrowRefMut","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"BorrowMutError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_private","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"RefMut<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&mut std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","alignment":4,"data_member_location":0},{"tag":"member","name":"borrow","type":"BorrowRefMut","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"RefMut<core::option::Option<alloc::boxed::Box<Write>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&mut core::option::Option<alloc::boxed::Box<Write>>","alignment":4,"data_member_location":0},{"tag":"member","name":"borrow","type":"BorrowRefMut","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"UnsafeCell<std::sync::mpsc::select::SelectInner>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"SelectInner","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::sync::mpsc::Flavor<()>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"Flavor<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<core::option::Option<()>>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"Option","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::sync::mpsc::oneshot::MyUpgrade<()>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"MyUpgrade<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<*mut std::sync::mpsc::mpsc_queue::Node<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"*mut std::sync::mpsc::mpsc_queue::Node<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::sync::mpsc::sync::State<()>>","byte_size":48,"alignment":4,"children":[{"tag":"member","name":"value","type":"State<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<std::sync::barrier::BarrierState>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"BarrierState","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"BorrowRef","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"borrow","type":"&core::cell::Cell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4cell9BorrowRef3new17hcdf0ed9d1f4f7c0bE","name":"new","decl_file":25,"decl_line":1083,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4cell10is_writing17h0c90f6dd8b83696fE","name":"is_writing","decl_file":25,"decl_line":639,"inline":"inlined"},{"tag":"structure_type","name":"Ref<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&core::option::Option<std::sys_common::thread_info::ThreadInfo>","alignment":4,"data_member_location":0},{"tag":"member","name":"borrow","type":"BorrowRef","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"BorrowError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_private","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"RefMut<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&mut core::option::Option<std::sys_common::thread_info::ThreadInfo>","alignment":4,"data_member_location":0},{"tag":"member","name":"borrow","type":"BorrowRefMut","alignment":4,"data_member_location":4}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":25044,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":1,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Maybe","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h2ceb59fe70047d4dE","name":"is_some<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h54d9e208c9193edaE","name":"as_mut<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<u8>","byte_size":2,"alignment":1,"children":[{"tag":"variant_part","discr":25143,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":2,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]}]},{"tag":"structure_type","name":"Option<std::process::ChildStdin>","byte_size":0,"alignment":1,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":0,"alignment":1}]},{"tag":"structure_type","name":"Option<std::process::ChildStdout>","byte_size":0,"alignment":1,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":0,"alignment":1}]},{"tag":"structure_type","name":"Option<std::process::ChildStderr>","byte_size":0,"alignment":1,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":0,"alignment":1}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Option","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"None","const_value":0},{"tag":"enumerator","name":"Some","const_value":1},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17h875e2fcb40f5ed30E","name":"take<closure>","decl_file":14,"decl_line":857,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h387e9d098eef6dc9E","name":"unwrap<closure>","decl_file":14,"decl_line":352,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h9c468489a123c6bdE","name":"as_mut<std::sys::wasm::stdio::Stderr>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<unsafe extern \\\"C\\\" fn(*mut u8)>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":25371,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"unsafe extern \"C\" fn(*mut u8)","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&core::fmt::Arguments>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":25445,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::fmt::Arguments","alignment":4,"data_member_location":0}]},{"tag":"subprogram","low_pc":11916,"high_pc":11942,"linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h06da9fa65d5ab8eaE","name":"unwrap<&core::fmt::Arguments>","decl_file":14,"decl_line":352}]},{"tag":"structure_type","name":"Option<&[core::fmt::rt::v1::Argument]>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":25539,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[core::fmt::rt::v1::Argument]","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":25613,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h13b04b7b2dc99901E","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h41f0d08a6dea7e34E","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h62b4a2ec45ced259E","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h0725e4b6630b8e9bE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<alloc::string::String>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":25740,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h0be4836165dc9ac6E","name":"map<alloc::string::String,std::ffi::c_str::CString,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$18get_or_insert_with17h8ad7ae85412cd4c9E","name":"get_or_insert_with<alloc::string::String,closure>","decl_file":14,"decl_line":822,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&str>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":25840,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$9unwrap_or17h995f1c149f0aa1e5E","name":"unwrap_or<&str>","decl_file":14,"decl_line":375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17ha758aaabe6f164c5E","name":"take<&str>","decl_file":14,"decl_line":857,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::cell::Cell<(u64, u64)>>","byte_size":24,"alignment":8,"children":[{"tag":"variant_part","discr":25940,"children":[{"tag":"member","type":"u64","alignment":8,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":24,"alignment":8},{"tag":"structure_type","name":"Some","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Cell<(u64, u64)>","alignment":8,"data_member_location":8}]}]},{"tag":"structure_type","name":"Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":26015,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefCell<core::option::Option<alloc::boxed::Box<Write>>>","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"Option<alloc::boxed::Box<Write>>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":26090,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Box<Write>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17he48e12e9fe33d246E","name":"and_then<alloc::boxed::Box<Write>,alloc::boxed::Box<Write>,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h135a629ec12428b4E","name":"and_then<alloc::boxed::Box<Write>,alloc::boxed::Box<Write>,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h0ea07e3f4b06dba2E","name":"as_mut<alloc::boxed::Box<Write>>","decl_file":14,"decl_line":266,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17h8f14695ec4f7b9a5E","name":"take<alloc::boxed::Box<Write>>","decl_file":14,"decl_line":857,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&std::path::Path>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":26216,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::path::Path","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h05cd873b6a8f5f8bE","name":"and_then<&std::path::Path,&std::path::Path,fn(&std::path::Path) -> core::option::Option<&std::path::Path>>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":26303,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"Option<core::ptr::NonNull<core::task::wake::LocalWaker>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":26378,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonNull<core::task::wake::LocalWaker>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17h4400da94fae968b2E","name":"take<core::ptr::NonNull<core::task::wake::LocalWaker>>","decl_file":14,"decl_line":857,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":26465,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"Option<std::sys_common::thread_info::ThreadInfo>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":26540,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"ThreadInfo","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h9bdee7c8fe10369fE","name":"is_some<std::sys_common::thread_info::ThreadInfo>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17hd0a47fc9a13624b2E","name":"is_none<std::sys_common::thread_info::ThreadInfo>","decl_file":14,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17heb895eb0913b7304E","name":"as_mut<std::sys_common::thread_info::ThreadInfo>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<!>","byte_size":0,"alignment":1,"children":[{"tag":"variant_part","children":[{"tag":"variant","children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":0,"alignment":1}]},{"tag":"structure_type","name":"Option<std::ffi::c_str::CString>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":26681,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"CString","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_ref17h4f02de9fc07e78e3E","name":"as_ref<std::ffi::c_str::CString>","decl_file":14,"decl_line":245,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::cell::Cell<usize>>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":26767,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Cell<usize>","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"Option<&core::panic::Location>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":26842,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::panic::Location","alignment":4,"data_member_location":0}]},{"tag":"subprogram","low_pc":11943,"high_pc":11969,"abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h0c238cc562e9cab5E"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h0c238cc562e9cab5E","name":"unwrap<&core::panic::Location>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17heafefb9828378630E","name":"fmt<&std::path::Path>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17ha95d116106822d4eE","name":"fmt<alloc::string::String>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17ha61ad404d14c8df8E","name":"fmt<usize>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h5198f0610ed5644eE","name":"fmt<&str>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hfb45beea235835d2E","name":"clone<std::path::Prefix>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..cmp..PartialEq$GT$2eq17he285b52e70bb9da3E","name":"eq<&[u8]>","decl_file":14,"decl_line":158,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::path::Component>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":27039,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":5,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Component","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h3f19f7dc1588ba1dE","name":"is_some<std::path::Component>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17he97e6603f573f3baE","name":"is_none<std::path::Component>","decl_file":14,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h6e9ae6aceb7e8955E","name":"and_then<std::path::Component,&std::path::Path,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hcfcaef4d3c2248acE","name":"map<std::path::Component,&std::ffi::os_str::OsStr,fn(std::path::Component) -> &std::ffi::os_str::OsStr>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h07407c71b364238dE","name":"and_then<std::path::Component,&std::ffi::os_str::OsStr,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&[u8]>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":27176,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[u8]","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17he20413c48608ac3fE","name":"map<&[u8],std::ffi::os_str::OsString,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::thread::Thread>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27263,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Thread","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h5173c483b4d52881E","name":"expect<std::thread::Thread>","decl_file":14,"decl_line":319,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17h94a246195894ba79E","name":"take<std::thread::Thread>","decl_file":14,"decl_line":857,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17hdf2d3ab6f8691b23E","name":"unwrap<std::thread::Thread>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27376,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&std::ffi::c_str::CString>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27450,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::c_str::CString","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h9f45f3307ec5c77fE","name":"map<&std::ffi::c_str::CString,&std::ffi::c_str::CStr,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&std::ffi::c_str::CStr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":27537,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::c_str::CStr","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h7609ed1612f97ebaE","name":"map<&std::ffi::c_str::CStr,&str,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::ffi::os_str::OsString>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":27624,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"OsString","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h3de05f701ebdd808E","name":"map<std::ffi::os_str::OsString,alloc::string::String,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17ha07db43054bbe35dE","name":"map<std::ffi::os_str::OsString,alloc::string::String,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&u8>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27724,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&u8","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h2052e5da20a99a43E","name":"map<&u8,core::ascii::EscapeDefault,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hdb9bb4736d5f0682E","name":"map<&u8,bool,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::ascii::EscapeDefault>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":27824,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDefault","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h273319caa28cb74dE","name":"as_mut<core::ascii::EscapeDefault>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut core::ascii::EscapeDefault>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27912,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::ascii::EscapeDefault","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h85b3c526c5547d94E","name":"and_then<&mut core::ascii::EscapeDefault,u8,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":27999,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h2996b41503467ebaE","name":"expect<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":14,"decl_line":319,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":28086,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h9eaf2e84d9f2384fE","name":"expect<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":14,"decl_line":319,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":28173,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut std::io::stdio::Maybe<std::io::stdio::StdoutRaw>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17hdff7f74c1c1c70d1E","name":"unwrap<&mut std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":28260,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h74bc7ab38b87fbc0E","name":"expect<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":14,"decl_line":319,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":28347,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<std::net::ip::Ipv4Addr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":28421,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ipv4Addr","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17h049c0db9a689e077E","name":"filter<std::net::ip::Ipv4Addr,closure>","decl_file":14,"decl_line":661,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h2f7f5f15a8bc0a1fE","name":"is_some<std::net::ip::Ipv4Addr>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17hbe644fe74e51389eE","name":"is_none<std::net::ip::Ipv4Addr>","decl_file":14,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hd3b7480662f7708fE","name":"map<std::net::ip::Ipv4Addr,std::net::ip::IpAddr,fn(std::net::ip::Ipv4Addr) -> std::net::ip::IpAddr>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::net::ip::Ipv6Addr>","byte_size":17,"alignment":1,"children":[{"tag":"variant_part","discr":28546,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":17,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":17,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Ipv6Addr","alignment":1,"data_member_location":1}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17h827f177f493e6ffdE","name":"filter<std::net::ip::Ipv6Addr,closure>","decl_file":14,"decl_line":661,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h74a8f2e85effc5d8E","name":"is_some<std::net::ip::Ipv6Addr>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h3c2fafd88078e183E","name":"map<std::net::ip::Ipv6Addr,std::net::ip::IpAddr,fn(std::net::ip::Ipv6Addr) -> std::net::ip::IpAddr>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::net::addr::SocketAddrV4>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":28659,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddrV4","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h14b51182c65206e6E","name":"map<std::net::addr::SocketAddrV4,std::net::addr::SocketAddr,fn(std::net::addr::SocketAddrV4) -> std::net::addr::SocketAddr>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17h8563ccbc41a49de4E","name":"filter<std::net::addr::SocketAddrV4,closure>","decl_file":14,"decl_line":661,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::net::addr::SocketAddrV6>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":28760,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddrV6","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h2abd7c829f5e7082E","name":"map<std::net::addr::SocketAddrV6,std::net::addr::SocketAddr,fn(std::net::addr::SocketAddrV6) -> std::net::addr::SocketAddr>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17h2e9f8731c774ba84E","name":"filter<std::net::addr::SocketAddrV6,closure>","decl_file":14,"decl_line":661,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::net::addr::SocketAddr>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":28861,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddr","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17hc79324c5518126e5E","name":"filter<std::net::addr::SocketAddr,closure>","decl_file":14,"decl_line":661,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<char>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":28948,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17he4bac74f62997a96E","name":"and_then<char,u8,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hbd70809d1a11d05bE","name":"map<char,core::char::EscapeDebug,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hd02f8b49f859596cE","name":"map<char,core::char::EscapeDebug,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<u32>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":29064,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"u32","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17ha2bcc39bb626c28eE","name":"map<u32,u16,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hf05341f66e3bfe3aE","name":"map<u32,u16,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<(std::net::ip::Ipv4Addr, char, u16)>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":29165,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"(std::net::ip::Ipv4Addr, char, u16)","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h035fa67240bea801E","name":"map<(std::net::ip::Ipv4Addr, char, u16),std::net::addr::SocketAddrV4,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<(char, std::net::ip::Ipv6Addr, char)>","byte_size":24,"alignment":4,"children":[{"tag":"variant_part","discr":29255,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":24,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"(char, std::net::ip::Ipv6Addr, char)","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h7935846f14fb4645E","name":"is_some<(char, std::net::ip::Ipv6Addr, char)>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17h42854f1d18de4095E","name":"is_none<(char, std::net::ip::Ipv6Addr, char)>","decl_file":14,"decl_line":215,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<(std::net::ip::Ipv6Addr, char, u16)>","byte_size":24,"alignment":4,"children":[{"tag":"variant_part","discr":29356,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":24,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"(std::net::ip::Ipv6Addr, char, u16)","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h0c2cd7c84a34fa8aE","name":"map<(std::net::ip::Ipv6Addr, char, u16),std::net::addr::SocketAddrV6,closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::net::ip::IpAddr>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":29446,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":20,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"IpAddr","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6filter17h97071da3c92b2ff1E","name":"filter<std::net::ip::IpAddr,closure>","decl_file":14,"decl_line":661,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::path::Prefix>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":29533,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":6,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":20,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Prefix","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_ref17hf2feeb342b8171faE","name":"as_ref<std::path::Prefix>","decl_file":14,"decl_line":245,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h8bac5cd29b550413E","name":"unwrap<std::path::Prefix>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&std::path::Prefix>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":29632,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::path::Prefix","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h2184648f12865d68E","name":"map<&std::path::Prefix,usize,fn(&std::path::Prefix) -> usize>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h246da00f658a7affE","name":"map<&std::path::Prefix,bool,fn(&std::path::Prefix) -> bool>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<bool>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":29732,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":1,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"bool","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$9unwrap_or17h84bc46d799167e1cE","name":"unwrap_or<bool>","decl_file":14,"decl_line":375,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::path::Components>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":29819,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":28,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Components","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17haf9b215b39d25581E","name":"map<std::path::Components,&std::path::Path,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17hb8842c9895cffd46E","name":"is_some<std::path::Components>","decl_file":14,"decl_line":193,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::iter::Rev<std::path::Components>>","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":29918,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":28,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Rev<std::path::Components>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h67f8859ec946f1e3E","name":"is_some<core::iter::Rev<std::path::Components>>","decl_file":14,"decl_line":193,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&std::ffi::os_str::OsStr>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":30004,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hbe4ab2fd120c2392E","name":"map<&std::ffi::os_str::OsStr,(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>),fn(&std::ffi::os_str::OsStr) -> (core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>)>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$2or17h1c1f1098dca03c26E","name":"or<&std::ffi::os_str::OsStr>","decl_file":14,"decl_line":699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3and17hed5df89fdbdb6b18E","name":"and<&std::ffi::os_str::OsStr,&std::ffi::os_str::OsStr>","decl_file":14,"decl_line":603,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>)>","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":30117,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":20,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>)","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h246f79e04eb03049E","name":"and_then<(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>),&std::ffi::os_str::OsStr,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17hc30d4f629f7826deE","name":"and_then<(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>),&std::ffi::os_str::OsStr,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<std::sync::mpsc::stream::Message<()>>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":30218,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":5,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Message<()>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<std::sync::mpsc::blocking::SignalToken>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30292,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SignalToken","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$4take17h8b8d7d694c7b1338E","name":"take<std::sync::mpsc::blocking::SignalToken>","decl_file":14,"decl_line":857,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h6d62f615e12e7483E","name":"unwrap<std::sync::mpsc::blocking::SignalToken>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut bool>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30392,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut bool","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<*mut std::sync::mpsc::select::Handle<()>>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":30466,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*mut std::sync::mpsc::select::Handle<()>","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h3983c65b9fabc289E","name":"map<*mut std::sync::mpsc::select::Handle<()>,(usize, *mut std::sync::mpsc::select::Handle<()>),closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::time::Duration>","byte_size":24,"alignment":8,"children":[{"tag":"variant_part","discr":30554,"children":[{"tag":"member","type":"u64","alignment":8,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":24,"alignment":8},{"tag":"structure_type","name":"Some","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":8}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$10ok_or_else17h61434b2200e798e8E","name":"ok_or_else<core::time::Duration,core::time::Duration,closure>","decl_file":14,"decl_line":525,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30642,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30716,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&mut std::sys_common::thread_info::ThreadInfo>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30790,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut std::sys_common::thread_info::ThreadInfo","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h5082ed167199aee1E","name":"unwrap<&mut std::sys_common::thread_info::ThreadInfo>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::char::EscapeDebug>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":30877,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDebug","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h4bc17e0ec1ba5c40E","name":"as_mut<core::char::EscapeDebug>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut core::char::EscapeDebug>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":30964,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::char::EscapeDebug","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h5aaadf483f4e5411E","name":"and_then<&mut core::char::EscapeDebug,char,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h93d6e1563f92da3aE","name":"and_then<&mut core::char::EscapeDebug,char,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&std::thread::Thread>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":31064,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::thread::Thread","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h4d9c8e35ba6f919dE","name":"and_then<&std::thread::Thread,&str,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]}]},{"tag":"namespace","name":"panic","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"internal_constructor","children":[{"tag":"structure_type","name":"NoPayload","byte_size":0,"alignment":1}]}]},{"tag":"structure_type","name":"PanicInfo","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"payload","type":"&Any","alignment":4,"data_member_location":0},{"tag":"member","name":"message","type":"Option<&core::fmt::Arguments>","alignment":4,"data_member_location":8},{"tag":"member","name":"location","type":"Location","alignment":4,"data_member_location":12},{"tag":"subprogram","linkage_name":"_ZN4core5panic9PanicInfo20internal_constructor17h7f7883a6234f3b51E","name":"internal_constructor","decl_file":26,"decl_line":58,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5panic9PanicInfo11set_payload17h9b2665da676a8519E","name":"set_payload","decl_file":26,"decl_line":67,"inline":"inlined"}]},{"tag":"structure_type","name":"Location","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"file","type":"&str","alignment":4,"data_member_location":0},{"tag":"member","name":"line","type":"u32","alignment":4,"data_member_location":8},{"tag":"member","name":"col","type":"u32","alignment":4,"data_member_location":12}]}]},{"tag":"namespace","name":"time","children":[{"tag":"structure_type","name":"Duration","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"secs","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"nanos","type":"u32","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11from_millis17hd22d8e7d93558431E","name":"from_millis","decl_file":49,"decl_line":132,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_sub17h5512088d1030ded3E","name":"checked_sub","decl_file":49,"decl_line":382,"inline":"inlined"}]}]},{"tag":"namespace","name":"str","children":[{"tag":"structure_type","name":"Utf8Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"valid_up_to","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"error_len","type":"Option<u8>","alignment":1,"data_member_location":4}]},{"tag":"namespace","name":"pattern","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN109_$LT$core..str..pattern..CharSearcher$LT$$u27$a$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$8haystack17h49cb89acce8b5aa9E","name":"haystack","decl_file":46,"decl_line":281,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN116_$LT$core..str..pattern..CharSearcher$LT$$u27$a$GT$$u20$as$u20$core..str..pattern..ReverseSearcher$LT$$u27$a$GT$$GT$15next_match_back17hb2be641ee388e27cE","name":"next_match_back","decl_file":46,"decl_line":374,"inline":"inlined"}]},{"tag":"structure_type","name":"CharSearcher","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"haystack","type":"&str","alignment":4,"data_member_location":0},{"tag":"member","name":"finger","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"finger_back","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"needle","type":"char","alignment":4,"data_member_location":16},{"tag":"member","name":"utf8_size","type":"usize","alignment":4,"data_member_location":20},{"tag":"member","name":"utf8_encoded","type":"u8[]","alignment":1,"data_member_location":24}]}]},{"tag":"namespace","name":"traits","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str6traits101_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..Range$LT$usize$GT$$GT$13get_unchecked17he6beb4ad135e2370E","name":"get_unchecked","decl_file":3,"decl_line":1880,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$13get_unchecked17hdd6fa99444bc00a6E","name":"get_unchecked<core::ops::range::Range<usize>>","decl_file":3,"decl_line":2374,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5parse17h1b2e341e33dbd847E","name":"parse<std::net::ip::Ipv4Addr>","decl_file":3,"decl_line":3954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5parse17h1b5b7c9a85dc9912E","name":"parse<std::net::ip::Ipv6Addr>","decl_file":3,"decl_line":3954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5parse17hb3f8549cc269004aE","name":"parse<std::net::addr::SocketAddr>","decl_file":3,"decl_line":3954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$7rsplitn17hbb2800c4b126132fE","name":"rsplitn<char>","decl_file":3,"decl_line":3383,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN92_$LT$core..str..RSplitN$LT$$u27$a$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h34c30e689171fea1E","name":"next<char>","decl_file":3,"decl_line":970,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5parse17h2555ed7b2b7c2d53E","name":"parse<u16>","decl_file":3,"decl_line":3954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5chars17h17846ad5a6c66389E","name":"chars","decl_file":3,"decl_line":2631,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h31769beda6688264E","name":"next","decl_file":3,"decl_line":570,"inline":"inlined"}]},{"tag":"structure_type","name":"SplitInternal<char>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"matcher","type":"CharSearcher","alignment":4,"data_member_location":8},{"tag":"member","name":"allow_trailing_empty","type":"bool","alignment":1,"data_member_location":36},{"tag":"member","name":"finished","type":"bool","alignment":1,"data_member_location":37},{"tag":"subprogram","linkage_name":"_ZN56_$LT$core..str..SplitInternal$LT$$u27$a$C$$u20$P$GT$$GT$7get_end17h2c05e3d931d37302E","name":"get_end<char>","decl_file":3,"decl_line":1054,"inline":"inlined"}]},{"tag":"structure_type","name":"SplitNInternal<char>","byte_size":44,"alignment":4,"children":[{"tag":"member","name":"iter","type":"SplitInternal<char>","alignment":4,"data_member_location":0},{"tag":"member","name":"count","type":"usize","alignment":4,"data_member_location":40},{"tag":"subprogram","linkage_name":"_ZN57_$LT$core..str..SplitNInternal$LT$$u27$a$C$$u20$P$GT$$GT$9next_back17he772717f137dd8eaE","name":"next_back<char>","decl_file":3,"decl_line":1177,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3str15next_code_point17hdbac06f528eb958fE","name":"next_code_point<core::slice::Iter<u8>>","decl_file":3,"decl_line":502,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","name":"unwrap_or_0","decl_file":3,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","name":"utf8_acc_cont_byte","decl_file":3,"decl_line":483,"inline":"inlined"}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"function","children":[{"tag":"structure_type","name":"*mut Fn<(&core::panic::PanicInfo)>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"Fn","children":[]},{"tag":"namespace","name":"FnMut","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5FnMut8call_mut17h634d8e7cb3c5f689E","name":"call_mut<fn((std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>)),((std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>))>","decl_file":50,"decl_line":156,"inline":"inlined"}]},{"tag":"namespace","name":"FnOnce","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17ha708533fbcf5d64eE","name":"call_once<closure,(bool)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17hdeecbb9f31f6b7b6E","name":"call_once<fn(&core::panic::PanicInfo),(&core::panic::PanicInfo)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h5a9e886e1316573dE","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17hf09462bd8ccff82cE","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17hcd17e83337ec0d89E","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h26f774b8ffa2a41dE","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17he92d9eea02d09d81E","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h9e81c7ad3222f329E","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h0f4b04e03a25045fE","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h89ccb203176c0e7bE","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17hcecb33a4c8a8eec0E","name":"call_once<closure,(&mut std::net::parser::Parser)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h4c5a63ff23cf8929E","name":"call_once<fn(&std::path::Prefix) -> usize,(&std::path::Prefix)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17ha9654facd996ee74E","name":"call_once<fn(&std::path::Prefix) -> bool,(&std::path::Prefix)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17hd680963623bb9823E","name":"call_once<fn(std::path::Component) -> &std::ffi::os_str::OsStr,(std::path::Component)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h91bff52ab3da457aE","name":"call_once<fn(&std::path::Path) -> core::option::Option<&std::path::Path>,(&std::path::Path)>","decl_file":50,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function6FnOnce9call_once17h61664ad8cec43cbfE","name":"call_once<fn(&std::ffi::os_str::OsStr) -> (core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>),(&std::ffi::os_str::OsStr)>","decl_file":50,"decl_line":238,"inline":"inlined"}]},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17h0c150d43a47f5ebbE","name":"call_once<(&[u8]),closure>","decl_file":50,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17h5f91bc796ba8ca51E","name":"call_once<(&u8),closure>","decl_file":50,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17h22915f09280c7d5cE","name":"call_once<(char),closure>","decl_file":50,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17h7fb086d22623133eE","name":"call_once<(char),closure>","decl_file":50,"decl_line":285,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"range","children":[{"tag":"structure_type","name":"Range<usize>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4}]}]}]},{"tag":"namespace","name":"any","children":[{"tag":"structure_type","name":"&Any","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"structure_type","name":"Box<Any>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":11889,"high_pc":11901,"linkage_name":"_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h99bea1411b3a879cE","name":"get_type_id<alloc::string::String>","decl_file":17,"decl_line":115},{"tag":"subprogram","low_pc":11902,"high_pc":11915,"linkage_name":"_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h9db561077ca8e03bE","name":"get_type_id<core::panic::{{impl}}::internal_constructor::NoPayload>","decl_file":17,"decl_line":115},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$2is17hb53ce662f3dab55cE","name":"is<&str>","decl_file":17,"decl_line":169,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17h810b43aa1893bd61E","name":"downcast_ref<&str>","decl_file":17,"decl_line":203,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17h474a74114b08f405E","name":"downcast_ref<&str>","decl_file":17,"decl_line":300,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$2is17h34f4cf6584d7d96bE","name":"is<alloc::string::String>","decl_file":17,"decl_line":169,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17h6439ff1876bf2f36E","name":"downcast_ref<alloc::string::String>","decl_file":17,"decl_line":203,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17h0bf3ec356f81b28aE","name":"downcast_ref<alloc::string::String>","decl_file":17,"decl_line":300,"inline":"inlined"}]},{"tag":"structure_type","name":"*const Any","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"structure_type","name":"Iter<core::fmt::ArgumentV1>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&core::fmt::ArgumentV1>","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hce1a4372b7e225c1E","name":"next<u8>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hefe003e6c8ffb20bE","name":"next<std::ffi::os_str::OsString>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$$u5b$u8$u5d$$u20$as$u20$core..slice..SliceOrd$LT$u8$GT$$GT$7compare17h2c45b29d7d7c6a81E","name":"compare","decl_file":9,"decl_line":4998,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialOrd$LT$A$GT$$GT$15partial_compare17ha712fd4a7832e4e1E","name":"partial_compare<u8>","decl_file":9,"decl_line":4961,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice63_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$$u5b$T$u5d$$GT$11partial_cmp17h18f3c69e744f92b1E","name":"partial_cmp<u8>","decl_file":9,"decl_line":4879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialEq$LT$A$GT$$GT$5equal17h871d9b1d44da0423E","name":"equal<u8>","decl_file":9,"decl_line":4915,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice81_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u5d$$GT$$u20$for$u20$$u5b$A$u5d$$GT$2eq17h56debeb0e017e027E","name":"eq<u8,u8>","decl_file":9,"decl_line":4856,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice56_$LT$impl$u20$core..cmp..Ord$u20$for$u20$$u5b$T$u5d$$GT$3cmp17h0d8e509ce108b29eE","name":"cmp<u8>","decl_file":9,"decl_line":4871,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h92cb7cb445a84fe7E","name":"get<u8>","decl_file":9,"decl_line":2463,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17hf3619dc250de2bd3E","name":"get<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h98d177e70d6fd9aaE","name":"get_unchecked<u8>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17hda4efc090753f459E","name":"get_unchecked<u8,usize>","decl_file":9,"decl_line":333,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h38fb9cf88fc4e911E","name":"get_unchecked<u8>","decl_file":9,"decl_line":2485,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h61954f5381f7c5e6E","name":"index<u8>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h1f5eb40d0fa873c8E","name":"index<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hea4970eadcdb2fa1E","name":"next<u8,closure>","decl_file":9,"decl_line":3236,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h729d081ffb720e1dE","name":"iter<u8>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h7ff54dba7ceae18eE","name":"try_fold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17h40d388dc674cfd45E","name":"position<u8,closure>","decl_file":9,"decl_line":2913,"inline":"inlined"},{"tag":"namespace","name":"position","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0be8c53aa45c9c18E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2919,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h6bce035f5f88439aE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2923,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hf9b9a0221f1f3324E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2919,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h9a846931eeb5b51dE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2923,"inline":"inlined"}]},{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h8311ee8da4daf57aE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":3239,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h3e7bc7ef2d591216E","name":"index<u8>","decl_file":9,"decl_line":2544,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17hac03d0ebc58668efE","name":"index<u8,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN93_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..slice..SplitIter$GT$6finish17h062388425879c668E","name":"finish<u8,closure>","decl_file":9,"decl_line":3278,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h5442f3bbc72d0ffdE","name":"index<u8>","decl_file":9,"decl_line":2579,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17hc10c3acf53d0fd81E","name":"index<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17h59b33e4d5a2eda96E","name":"copy_from_slice<u8>","decl_file":9,"decl_line":1957,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hce3ad0ef1c396649E","name":"get_unchecked_mut<u8>","decl_file":9,"decl_line":2490,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h1a64b20495db2ce0E","name":"get_unchecked_mut<u8>","decl_file":9,"decl_line":2574,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h82c854383ee416d4E","name":"get_unchecked_mut<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":360,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17hafedef44323e3c49E","name":"size_hint<u8,closure>","decl_file":9,"decl_line":3250,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8is_empty17h1ff26ffdaeed3a66E","name":"is_empty<u8>","decl_file":9,"decl_line":105,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h9f8917cc3a2bb1f2E","name":"index_mut<u8>","decl_file":9,"decl_line":2507,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17hf12f3d50b589f4b5E","name":"index_mut<u8>","decl_file":9,"decl_line":2584,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17heb0d03d176d7f089E","name":"index_mut<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17hb762a5f99eb9b6b9E","name":"index_mut<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialEq$LT$A$GT$$GT$5equal17h236f49171a78434fE","name":"equal<u16>","decl_file":9,"decl_line":4915,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice81_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u5d$$GT$$u20$for$u20$$u5b$A$u5d$$GT$2eq17h68f50d65c018544eE","name":"eq<u16,u16>","decl_file":9,"decl_line":4856,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h532d1a49a8fb1274E","name":"next<u16>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hba18ca901b888788E","name":"index<u16>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h75d4d7823a5db449E","name":"index<u16>","decl_file":9,"decl_line":2579,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h2fd53f22968c6855E","name":"index<u16,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8is_empty17h0520917c1823cce9E","name":"is_empty<u16>","decl_file":9,"decl_line":105,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN62_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SliceOrd$LT$A$GT$$GT$7compare17hfd4861b677191358E","name":"compare<u16>","decl_file":9,"decl_line":4975,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice56_$LT$impl$u20$core..cmp..Ord$u20$for$u20$$u5b$T$u5d$$GT$3cmp17h4f0b1637531ab546E","name":"cmp<u16>","decl_file":9,"decl_line":4871,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$6as_ptr17h8185b19239d15faaE","name":"as_ptr<u8>","decl_file":9,"decl_line":389,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h3561a83354356dc7E","name":"iter<std::net::addr::SocketAddr>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hc7991176e1cc9f9eE","name":"index<u16>","decl_file":9,"decl_line":2544,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17hc2e35387a23e6faaE","name":"index<u16,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17h618e5ae4339fdb79E","name":"copy_from_slice<u16>","decl_file":9,"decl_line":1957,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h05e61012c5a1bd29E","name":"get_unchecked_mut<u16>","decl_file":9,"decl_line":2490,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h33fe0dbcf6afbcb6E","name":"index_mut<u16>","decl_file":9,"decl_line":2507,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17heda6c72e70c83474E","name":"index_mut<u16,core::ops::range::Range<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h67a3da258fa27a7fE","name":"try_fold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17h62c4e1b795189b5cE","name":"position<u8,closure>","decl_file":9,"decl_line":2913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition17h2bf436f5cb474311E","name":"rposition<u8,closure>","decl_file":9,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17hceb90ee8432fb2d8E","name":"try_rfold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"namespace","name":"rposition","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17hfcdade385c140a07E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2936,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17hda67bee031e4b87dE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2941,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17h93d778d5c642e4d2E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2936,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17hdf1962321988840fE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2941,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4last17h4b2b6acdd0f66cebE","name":"last<u8>","decl_file":9,"decl_line":242,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h5d04232ed0e5de30E","name":"get<u8>","decl_file":9,"decl_line":2414,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h0ef4c8462836fe2fE","name":"get<u8,usize>","decl_file":9,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17he32f168aafb9407cE","name":"try_rfold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition17hdf69f816468f92b4E","name":"rposition<u8,closure>","decl_file":9,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN110_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17ha4e0b2c966007097E","name":"next_back<u8,closure>","decl_file":9,"decl_line":3262,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN102_$LT$core..slice..RSplit$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hab62d87158a8b92dE","name":"next<u8,closure>","decl_file":9,"decl_line":3412,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$core..slice..GenericSplitN$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hee24a27b335e80a6E","name":"next<&[u8],core::slice::RSplit<u8, closure>>","decl_file":9,"decl_line":3512,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..slice..RSplitN$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h290a8d7201f006cfE","name":"next<u8,closure>","decl_file":9,"decl_line":3622,"inline":"inlined"},{"tag":"namespace","name":"next_back","children":[{"tag":"subprogram","linkage_name":"_ZN110_$LT$core..slice..Split$LT$$u27$a$C$$u20$T$C$$u20$P$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back28_$u7b$$u7b$closure$u7d$$u7d$17h505e7ba3ff63658fE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":3265,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h68c64c342cee924bE","name":"get_unchecked<alloc::collections::btree::node::BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17h615e9eb90372a063E","name":"get_unchecked<alloc::collections::btree::node::BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,usize>","decl_file":9,"decl_line":333,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<u8>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u8","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hb0af95b08033507eE","name":"post_inc_start<u8>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<std::ffi::os_str::OsString>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&std::ffi::os_str::OsString>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h2ecefd8bc1c5a907E","name":"post_inc_start<std::ffi::os_str::OsString>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<u16>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u16","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u16","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u16>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hb30d1890ac39e47cE","name":"post_inc_start<u16>","decl_file":9,"decl_line":2781,"inline":"inlined"}]}]},{"tag":"namespace","name":"hash","children":[{"tag":"namespace","name":"sip","children":[{"tag":"structure_type","name":"SipHasher13","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"hasher","type":"Hasher<core::hash::sip::Sip13Rounds>","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4hash3sip11SipHasher1313new_with_keys17h86fac150d52cc408E","name":"new_with_keys","decl_file":51,"decl_line":181,"inline":"inlined"}]},{"tag":"structure_type","name":"Hasher<core::hash::sip::Sip13Rounds>","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"k0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"k1","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":56},{"tag":"member","name":"state","type":"State","alignment":8,"data_member_location":16},{"tag":"member","name":"tail","type":"u64","alignment":8,"data_member_location":48},{"tag":"member","name":"ntail","type":"usize","alignment":4,"data_member_location":60},{"tag":"member","name":"_marker","type":"PhantomData<core::hash::sip::Sip13Rounds>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN41_$LT$core..hash..sip..Hasher$LT$S$GT$$GT$13new_with_keys17h22ac514897378757E","name":"new_with_keys<core::hash::sip::Sip13Rounds>","decl_file":51,"decl_line":190,"inline":"inlined"}]},{"tag":"structure_type","name":"State","byte_size":32,"alignment":8,"children":[{"tag":"member","name":"v0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"v2","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"v1","type":"u64","alignment":8,"data_member_location":16},{"tag":"member","name":"v3","type":"u64","alignment":8,"data_member_location":24}]}]}]},{"tag":"namespace","name":"task","children":[{"tag":"namespace","name":"wake","children":[{"tag":"structure_type","name":"LocalWaker","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Waker","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Waker","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"NonNull<UnsafeWake>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"*const UnsafeWake","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]}]}]},{"tag":"namespace","name":"char","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"EscapeUnicodeState","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Done","const_value":0},{"tag":"enumerator","name":"RightBrace","const_value":1},{"tag":"enumerator","name":"Value","const_value":2},{"tag":"enumerator","name":"LeftBrace","const_value":3},{"tag":"enumerator","name":"Type","const_value":4},{"tag":"enumerator","name":"Backslash","const_value":5}]},{"tag":"namespace","name":"methods","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","name":"encode_utf8","decl_file":18,"decl_line":438,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","name":"len_utf8","decl_file":18,"decl_line":361,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8is_ascii17hee2c3395cfe8a1a8E","name":"is_ascii","decl_file":18,"decl_line":906,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$20is_grapheme_extended17h4b971a495728c8c1E","name":"is_grapheme_extended","decl_file":18,"decl_line":713,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$16escape_debug_ext17h1a540b8ae47edbc9E","name":"escape_debug_ext","decl_file":18,"decl_line":196,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$12escape_debug17ha4e065e1a8f6fe5dE","name":"escape_debug","decl_file":18,"decl_line":247,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_unicode17h0dce6bdf98b58dc9E","name":"escape_unicode","decl_file":18,"decl_line":173,"inline":"inlined"}]}]},{"tag":"structure_type","name":"EscapeDebug","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDefault","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"EscapeDefault","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"state","type":"EscapeDefaultState","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"EscapeDefaultState","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":34576,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Done","type":"Done","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Char","type":"Char","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Backslash","type":"Backslash","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Unicode","type":"Unicode","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Done","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Char","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Backslash","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Unicode","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeUnicode","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"EscapeUnicode","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"c","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"state","type":"EscapeUnicodeState","alignment":1,"data_member_location":8},{"tag":"member","name":"hex_digit_idx","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"namespace","name":"cmp","children":[{"tag":"enumeration_type","type":"i8","enum_class":true,"name":"Ordering","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Less","const_value":4294967295},{"tag":"enumerator","name":"Equal","const_value":0},{"tag":"enumerator","name":"Greater","const_value":1}]},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls92_$LT$impl$u20$core..cmp..PartialOrd$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$11partial_cmp17h309b45386e590d30E","name":"partial_cmp<std::ffi::os_str::OsStr,std::ffi::os_str::OsStr>","decl_file":16,"decl_line":1023,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","name":"le","decl_file":16,"decl_line":952,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls50_$LT$impl$u20$core..cmp..Ord$u20$for$u20$usize$GT$3cmp17he8b1f000ca5cdb66E","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls50_$LT$impl$u20$core..cmp..Ord$u20$for$u20$isize$GT$3cmp17hc053dd63f63987edE","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$isize$GT$11partial_cmp17hadf355906cc382fbE","name":"partial_cmp","decl_file":16,"decl_line":946,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2ne17h8298395e62b859abE","name":"ne<std::ffi::os_str::OsStr,std::ffi::os_str::OsStr>","decl_file":16,"decl_line":1018,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls50_$LT$impl$u20$core..cmp..Ord$u20$for$u20$$RF$A$GT$3cmp17h1d52552720295b42E","name":"cmp<std::ffi::os_str::OsStr>","decl_file":16,"decl_line":1038,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h173b7787a546461eE","name":"eq<[u8],[u8]>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17hc58b12901353282eE","name":"eq<std::ffi::os_str::OsStr,std::ffi::os_str::OsStr>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17hfe2446a2782b2a1cE","name":"eq<std::ffi::os_str::OsStr,str>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17hdcbd9d76944f5bb3E","name":"eq<std::path::Path,std::path::Path>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u64$GT$2le17h43075afd40677f7aE","name":"le","decl_file":16,"decl_line":952,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h531a4978cbc998e2E","name":"eq<std::net::ip::Ipv4Addr,std::net::ip::Ipv4Addr>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls48_$LT$impl$u20$core..cmp..Ord$u20$for$u20$u32$GT$3cmp17h155cd93ccb529052E","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17hbc5b34f675031a47E","name":"eq<std::net::ip::Ipv6Addr,std::net::ip::Ipv6Addr>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls50_$LT$impl$u20$core..cmp..Ord$u20$for$u20$$RF$A$GT$3cmp17hee9e36d736b0bc65E","name":"cmp<[u16]>","decl_file":16,"decl_line":1038,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls48_$LT$impl$u20$core..cmp..Ord$u20$for$u20$u16$GT$3cmp17hd08b86212d803208E","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h8fb5be242d333773E","name":"eq<std::path::Component,std::path::Component>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls47_$LT$impl$u20$core..cmp..Ord$u20$for$u20$u8$GT$3cmp17h8d45fd778af3de6aE","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u8$GT$11partial_cmp17h545c3781c5ffb7e4E","name":"partial_cmp","decl_file":16,"decl_line":946,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17he41b6e54f73a7dd6E","name":"eq<[u8],[u8; 2]>","decl_file":16,"decl_line":1016,"inline":"inlined"}]}]},{"tag":"namespace","name":"Ord","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3max17h3f93369c4fdfee14E","name":"max<usize>","decl_file":16,"decl_line":556,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3min17hbf2291d18d0818a4E","name":"min<usize>","decl_file":16,"decl_line":573,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3min17h581c9ebeab318869E","name":"min<u64>","decl_file":16,"decl_line":573,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3max17h498b7425de300345E","name":"max<usize>","decl_file":16,"decl_line":857,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3min17h70a2d51f6d9f8115E","name":"min<usize>","decl_file":16,"decl_line":837,"inline":"inlined"},{"tag":"namespace","name":"PartialEq","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp9PartialEq2ne17h79502d1abea5ec72E","name":"ne<std::ffi::os_str::OsStr,std::ffi::os_str::OsStr>","decl_file":16,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp9PartialEq2ne17h0806c3043d27ffe3E","name":"ne<std::path::PrefixComponent,std::path::PrefixComponent>","decl_file":16,"decl_line":209,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3min17h182c0109c69f8a06E","name":"min<u64>","decl_file":16,"decl_line":837,"inline":"inlined"},{"tag":"namespace","name":"PartialOrd","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp10PartialOrd2le17h501b133601ed804dE","name":"le<std::path::State,std::path::State>","decl_file":16,"decl_line":770,"inline":"inlined"}]}]},{"tag":"namespace","name":"num","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"IntErrorKind","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Empty","const_value":0},{"tag":"enumerator","name":"InvalidDigit","const_value":1},{"tag":"enumerator","name":"Overflow","const_value":2},{"tag":"enumerator","name":"Underflow","const_value":3}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$10swap_bytes17h7dff3aec9ebd91c5E","name":"swap_bytes","decl_file":8,"decl_line":2350,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$7from_be17hba3c46a0d62e9c5cE","name":"from_be","decl_file":8,"decl_line":2400,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_add17hdff24069b684c048E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_add17ha11c8a50db2b24c6E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_mul17hcf1db6cc43b48612E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_mul17h848f1b83517064d7E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$isize$GT$12wrapping_sub17h6c96eff5049a6211E","name":"wrapping_sub","decl_file":8,"decl_line":1033,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$10swap_bytes17h70121265cd7b421bE","name":"swap_bytes","decl_file":8,"decl_line":2350,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$7from_be17hfd302ec5aa6fc88fE","name":"from_be","decl_file":8,"decl_line":2400,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$5to_be17h3a9f698bdc055729E","name":"to_be","decl_file":8,"decl_line":2468,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$5to_be17hc15008be8a7a0acbE","name":"to_be","decl_file":8,"decl_line":2468,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_sub17h9cd6f7fbda80d79eE","name":"overflowing_sub","decl_file":8,"decl_line":3193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_sub17h5aa66de5d4ebae0dE","name":"checked_sub","decl_file":8,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_add17hb27fb94204ae9b96E","name":"wrapping_add","decl_file":8,"decl_line":2877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_sub17h4a98596a1d4e53a4E","name":"overflowing_sub","decl_file":8,"decl_line":3193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_sub17hd263f9a3880ab409E","name":"checked_sub","decl_file":8,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$10swap_bytes17hb698a82d76cff7e2E","name":"swap_bytes","decl_file":8,"decl_line":419,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$7from_be17h2b9af9db965df723E","name":"from_be","decl_file":8,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$5to_be17h1481ee388a0a5bbcE","name":"to_be","decl_file":8,"decl_line":537,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$10swap_bytes17h0eefd518228ad8dcE","name":"swap_bytes","decl_file":8,"decl_line":419,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$7from_be17h7dff3ff2a204b439E","name":"from_be","decl_file":8,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$5to_be17h525eee3445641bf9E","name":"to_be","decl_file":8,"decl_line":537,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$10swap_bytes17h0d215dd0481e3229E","name":"swap_bytes","decl_file":8,"decl_line":2350,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$10swap_bytes17h9e071d9f187ba0a1E","name":"swap_bytes","decl_file":8,"decl_line":419,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$7from_be17h2b807d119eec84f3E","name":"from_be","decl_file":8,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$5to_be17h275ec4929838620aE","name":"to_be","decl_file":8,"decl_line":537,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$isize$GT$10swap_bytes17hbcc3f3acc6023630E","name":"swap_bytes","decl_file":8,"decl_line":419,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$isize$GT$7from_be17h95740ed9bb38b4a2E","name":"from_be","decl_file":8,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$7from_be17hd8c9debcd24b7e71E","name":"from_be","decl_file":8,"decl_line":2400,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$10swap_bytes17ha899459e56d472a7E","name":"swap_bytes","decl_file":8,"decl_line":2350,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$7from_be17h64d820f0a585c4baE","name":"from_be","decl_file":8,"decl_line":2400,"inline":"inlined"}]},{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"ptr_try_from_impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num18ptr_try_from_impls69_$LT$impl$u20$core..convert..TryFrom$LT$u64$GT$$u20$for$u20$usize$GT$8try_from17hc09270559ce32c4bE","name":"try_from","decl_file":8,"decl_line":4508,"inline":"inlined"}]}]},{"tag":"structure_type","name":"TryFromIntError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"mem","children":[{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h7572b59cb9bd99a7E","name":"swap<isize>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h1e86e5333d347827E","name":"replace<isize>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h87eff2ae806e345eE","name":"swap<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17hd790d0e247cb78b3E","name":"replace<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17hc7c5a6dcd25e2de4E","name":"drop<alloc::boxed::Box<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h2bc28c0a337bbc2eE","name":"swap<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17hd03f0de1a899f615E","name":"replace<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17h9b0f57b54d8d0808E","name":"drop<alloc::boxed::Box<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h60e3a6d5fa6fe617E","name":"swap<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17hcd0b095645a4f680E","name":"replace<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17h93efb367a89985d6E","name":"drop<alloc::boxed::Box<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h566a4e0f924002f9E","name":"swap<core::option::Option<core::cell::Cell<usize>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h49452eb8f281725fE","name":"replace<core::option::Option<core::cell::Cell<usize>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hf711740a18b5e7f3E","name":"swap<usize>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h52eea3db70e8e218E","name":"replace<usize>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17hb389a44eb25ddbb1E","name":"drop<std::sync::mutex::MutexGuard<()>>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h579f4c836d886418E","name":"swap<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h13f8ba0682d55784E","name":"replace<core::option::Option<alloc::boxed::Box<Write>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h967d975ba0cdc6dfE","name":"swap<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17ha126cc9f6d4f6da0E","name":"replace<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"union_type","name":"MaybeUninit<u16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"uninit","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"value","type":"ManuallyDrop<u16>","alignment":2,"data_member_location":0}]},{"tag":"structure_type","name":"ManuallyDrop<u16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"value","type":"u16","alignment":2,"data_member_location":0}]},{"tag":"union_type","name":"MaybeUninit<[std::sys_common::process::DefaultEnvKey; 11]>","byte_size":132,"alignment":4,"children":[{"tag":"member","name":"uninit","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"value","type":"ManuallyDrop<[std::sys_common::process::DefaultEnvKey; 11]>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"ManuallyDrop<[std::sys_common::process::DefaultEnvKey; 11]>","byte_size":132,"alignment":4,"children":[{"tag":"member","name":"value","type":"DefaultEnvKey[]","alignment":4,"data_member_location":0}]},{"tag":"union_type","name":"MaybeUninit<[core::option::Option<std::ffi::os_str::OsString>; 11]>","byte_size":132,"alignment":4,"children":[{"tag":"member","name":"uninit","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"value","type":"ManuallyDrop<[core::option::Option<std::ffi::os_str::OsString>; 11]>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"ManuallyDrop<[core::option::Option<std::ffi::os_str::OsString>; 11]>","byte_size":132,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<std::ffi::os_str::OsString>[]","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17h27a382a8bc6aa3caE","name":"drop<alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4drop17h0a70e24aaa4c984bE","name":"drop<(std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>)>","decl_file":10,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h749d7fa56f6d30fbE","name":"swap<core::option::Option<std::sync::mpsc::blocking::SignalToken>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h5c1aa4d28f7c6612E","name":"replace<core::option::Option<std::sync::mpsc::blocking::SignalToken>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h5495166364c04ee7E","name":"swap<core::option::Option<closure>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h893b8b574168e2f3E","name":"replace<core::option::Option<closure>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hcb65fef7efbb3538E","name":"swap<*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h45e1ff49358d6f12E","name":"replace<*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h3ca7a00f4f7bfea5E","name":"swap<core::option::Option<std::thread::Thread>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h4ba6dd602a864f63E","name":"replace<core::option::Option<std::thread::Thread>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hc0e6cdeed62eb86eE","name":"swap<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h1f89dd9f888f1146E","name":"replace<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h323a10703b220356E","name":"swap<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h896d35759d1c078cE","name":"replace<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hd6552ea87db60dbbE","name":"swap<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h148f594a73ecc0aeE","name":"replace<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h08d425ed2f2c996cE","name":"swap<alloc::string::String>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17hda88f1782fc15c22E","name":"replace<alloc::string::String>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17ha9d81be2925c8d54E","name":"swap<core::option::Option<&str>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h8ce784e87bee6a96E","name":"replace<core::option::Option<&str>>","decl_file":10,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17h8655ee3527dd210bE","name":"swap<alloc::boxed::Box<Any>>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17hecdc08eef5171a4fE","name":"replace<alloc::boxed::Box<Any>>","decl_file":10,"decl_line":669,"inline":"inlined"}]},{"tag":"namespace","name":"iter","children":[{"tag":"namespace","name":"iterator","children":[{"tag":"namespace","name":"Iterator","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator9size_hint17he13fd85a7ee54790E","name":"size_hint<std::sys::wasm::os::Env>","decl_file":36,"decl_line":210,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator9size_hint17h430b73f0e3a1d948E","name":"size_hint<std::sys::wasm::os::SplitPaths>","decl_file":36,"decl_line":210,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3map17h8510a43924aa90beE","name":"map<core::slice::Split<u8, closure>,std::ffi::os_str::OsString,closure>","decl_file":36,"decl_line":568,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator7collect17h87eebea67e651a48E","name":"collect<core::iter::Map<core::slice::Split<u8, closure>, closure>,alloc::vec::Vec<std::ffi::os_str::OsString>>","decl_file":36,"decl_line":1475,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3rev17h35ce168a1fe25529E","name":"rev<std::path::Components>","decl_file":36,"decl_line":2193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator8try_fold17h6842930dd78982b3E","name":"try_fold<&mut alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,(),closure,core::result::Result<(), !>>","decl_file":36,"decl_line":1578,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold17ha63f3501b4892859E","name":"fold<&mut alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,(),closure>","decl_file":36,"decl_line":1692,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator8for_each17hadbd2ab91ed3701bE","name":"for_each<&mut alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,fn((std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>))>","decl_file":36,"decl_line":611,"inline":"inlined"},{"tag":"namespace","name":"for_each","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator8for_each28_$u7b$$u7b$closure$u7d$$u7d$17h6cb25cd9d502bb94E","name":"{{closure}}<&mut alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,fn((std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>))>","decl_file":36,"decl_line":614,"inline":"inlined"}]},{"tag":"namespace","name":"fold","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold28_$u7b$$u7b$closure$u7d$$u7d$17haab85ea4bc200b8eE","name":"{{closure}}<&mut alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>,(),closure>","decl_file":36,"decl_line":1695,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha0f34cc6f81a7438E","name":"next<alloc::collections::btree::map::IntoIter<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","decl_file":36,"decl_line":2623,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17hb2a40b179ec22d9dE","name":"size_hint<std::ffi::os_str::OsString,core::slice::Split<u8, closure>,closure>","decl_file":52,"decl_line":1398,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h15ab820172d6865fE","name":"next<core::iter::Map<core::slice::Iter<u8>, closure>,core::ascii::EscapeDefault>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h4c24ee6f21b752ffE","name":"next<core::slice::Iter<u8>,core::ascii::EscapeDefault,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h724b6179135f7546E","name":"next<core::ascii::EscapeDefault,core::slice::Iter<u8>,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"},{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h16a20b4dab02f49aE","name":"{{closure}}<core::iter::Map<core::slice::Iter<u8>, closure>,core::ascii::EscapeDefault>","decl_file":52,"decl_line":2687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17ha266502f84c2dfc2E","name":"{{closure}}<std::sync::mpsc::select::Packets>","decl_file":52,"decl_line":1748,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17he1b6a31509599c7dE","name":"{{closure}}<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h73f01e99fd12115dE","name":"{{closure}}<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2687,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN63_$LT$core..iter..Rev$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17ha09baad148d2ac27E","name":"clone<std::path::Components>","decl_file":52,"decl_line":415,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hc9e582337d16d3e0E","name":"next<std::path::Components>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h8737e0150bae83f4E","name":"next<std::sync::mpsc::select::Packets>","decl_file":52,"decl_line":1747,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$core..iter..Take$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h9dd3f9397b2ee84eE","name":"next<std::sync::mpsc::select::Packets>","decl_file":52,"decl_line":2363,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1132a66b3f9de299E","name":"next<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h985f772978687e60E","name":"next<core::str::Chars,core::char::EscapeDebug,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hbc1350eb5f20a943E","name":"next<core::char::EscapeDebug,core::str::Chars,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h16d12fb860ce0553E","name":"next<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hca055bb0e929154bE","name":"next<core::str::Chars,core::char::EscapeDebug,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h64400e5681e03193E","name":"next<core::char::EscapeDebug,core::str::Chars,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"}]},{"tag":"namespace","name":"traits","children":[{"tag":"namespace","name":"ExactSizeIterator","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter6traits17ExactSizeIterator3len17hb3bf95e23b0d19e2E","name":"len<alloc::vec::IntoIter<std::ffi::os_str::OsString>>","decl_file":53,"decl_line":689,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter6traits17ExactSizeIterator8is_empty17h3b28266a1d24e12cE","name":"is_empty<std::sys::wasm::args::Args>","decl_file":53,"decl_line":721,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN54_$LT$I$u20$as$u20$core..iter..traits..IntoIterator$GT$9into_iter17h6e5a4a60cf84f0f9E","name":"into_iter<core::iter::FlatMap<core::slice::Iter<u8>, core::ascii::EscapeDefault, closure>>","decl_file":53,"decl_line":259,"inline":"inlined"}]}]},{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17h1e6c23da7b1b79a7E","name":"next<usize>","decl_file":32,"decl_line":221,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter5range102_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..RangeInclusive$LT$A$GT$$GT$4next17h893f203ab6283722E","name":"next<usize>","decl_file":32,"decl_line":340,"inline":"inlined"}]}]},{"tag":"structure_type","name":"Rev<std::path::Components>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"iter","type":"Components","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"convert","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..Into$LT$U$GT$$GT$4into17h4d857938d8fabf7dE","name":"into<alloc::string::String,alloc::vec::Vec<u8>>","decl_file":1,"decl_line":455,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..Into$LT$U$GT$$GT$4into17h82731061f92a41e2E","name":"into<&[u8],alloc::boxed::Box<[u8]>>","decl_file":1,"decl_line":455,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..Into$LT$U$GT$$GT$4into17h7bdf0565267eb63cE","name":"into<&str,alloc::boxed::Box<Error>>","decl_file":1,"decl_line":455,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$T$u20$as$u20$core..convert..TryInto$LT$U$GT$$GT$8try_into17hd10e2c8da43cbd45E","name":"try_into<u64,usize>","decl_file":1,"decl_line":473,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..From$LT$T$GT$$GT$4from17he7b1f6e03ee1a60bE","name":"from<std::io::error::Error>","decl_file":1,"decl_line":463,"inline":"inlined"}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Layout","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size_","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"align_","type":"NonZeroUsize","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN4core5alloc6Layout6repeat17h03214d031cd47020E","name":"repeat","decl_file":2,"decl_line":231,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5alloc6Layout5array17hfa759b38aab133e3E","name":"array<std::ffi::os_str::OsString>","decl_file":2,"decl_line":312,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5alloc6Layout5array17h72c337ef9424bb48E","name":"array<alloc::boxed::Box<FnBox<()>>>","decl_file":2,"decl_line":312,"inline":"inlined"}]},{"tag":"structure_type","name":"LayoutErr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"private","type":"()","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"ascii","children":[{"tag":"structure_type","name":"EscapeDefault","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"range","type":"Range<usize>","alignment":4,"data_member_location":0},{"tag":"member","name":"data","type":"u8[]","alignment":1,"data_member_location":8}]}]},{"tag":"namespace","name":"array","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core5array103_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u3b$$u20$_$u5d$$GT$$u20$for$u20$$u5b$A$u3b$$u20$_$u5d$$GT$2eq17h260c85080fee55e5E","name":"eq<u16,u16>","decl_file":54,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5array103_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u3b$$u20$_$u5d$$GT$$u20$for$u20$$u5b$A$u3b$$u20$_$u5d$$GT$2eq17h64cf13bc778ce26bE","name":"eq<u8,u8>","decl_file":54,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5array67_$LT$impl$u20$core..cmp..Ord$u20$for$u20$$u5b$T$u3b$$u20$_$u5d$$GT$3cmp17he97be2c2ffe40970E","name":"cmp<u16>","decl_file":54,"decl_line":251,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5array92_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$A$u3b$$u20$_$u5d$$GT$$u20$for$u20$$u5b$B$u5d$$GT$2eq17he9e20678416724c0E","name":"eq<u8,u8>","decl_file":54,"decl_line":110,"inline":"inlined"}]}]},{"tag":"namespace","name":"clone","children":[{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls54_$LT$impl$u20$core..clone..Clone$u20$for$u20$$RF$T$GT$5clone17h5cc47f7bce212e0fE","name":"clone<[u8]>","decl_file":47,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls53_$LT$impl$u20$core..clone..Clone$u20$for$u20$bool$GT$5clone17h051ead1721808a48E","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"}]}]}]}]},{"tag":"pointer_type","type":"String","name":"&mut alloc::string::String"},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"string","children":[{"tag":"structure_type","name":"String","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"vec","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String4push17h282a1665f9952b5fE","name":"push","decl_file":11,"decl_line":1067,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String8push_str17h524abcd6952f7a86E","name":"push_str","decl_file":11,"decl_line":807,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String9from_utf817h57d8522450984e7dE","name":"from_utf8","decl_file":11,"decl_line":503,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String19from_utf8_unchecked17h098f222982cf20a0E","name":"from_utf8_unchecked","decl_file":11,"decl_line":731,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String3len17h4a775f27be010a3eE","name":"len","decl_file":11,"decl_line":1377,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String3new17ha36327193e5f3a5fE","name":"new","decl_file":11,"decl_line":384,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN65_$LT$alloc..string..String$u20$as$u20$core..ops..deref..Deref$GT$5deref17h8a6e2f64ffe1fb81E","name":"deref","decl_file":11,"decl_line":2042,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Debug$GT$3fmt17ha526d829df31f4dcE","name":"fmt","decl_file":11,"decl_line":1867,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$10write_char17h5ae3f38b5c88c7ebE","name":"write_char","decl_file":11,"decl_line":2289,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$9write_str17h5482869985281e48E","name":"write_str","decl_file":11,"decl_line":2283,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN60_$LT$alloc..string..String$u20$as$u20$core..fmt..Display$GT$3fmt17h37bbf2a03b1dd17cE","name":"fmt","decl_file":11,"decl_line":1859,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$alloc..string..String$u20$as$u20$core..convert..From$LT$$RF$$u27$a$u20$str$GT$$GT$4from17ha4cbd3fa01fb1537E","name":"from","decl_file":11,"decl_line":2200,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$str$u20$as$u20$alloc..string..ToString$GT$9to_string17hed233b6e6f885885E","name":"to_string","decl_file":11,"decl_line":2160,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$alloc..string..String$u20$as$u20$core..ops..index..Index$LT$core..ops..range..RangeFull$GT$$GT$5index17h2ab774163840a2c7E","name":"index","decl_file":11,"decl_line":1971,"inline":"inlined"}]},{"tag":"structure_type","name":"FromUtf8Error","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"bytes","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Utf8Error","alignment":4,"data_member_location":12}]}]},{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$8capacity17hc6bc6bf6e74ef796E","name":"capacity<u8>","decl_file":4,"decl_line":447,"inline":"inlined"},{"tag":"subprogram","low_pc":11737,"high_pc":11888,"abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17hd8b395996dddb505E","children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17hc474bb996bf1032bE","ranges":[[11737,11747],[11754,11886]],"call_file":4,"call_line":470,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h7f2c3b5e9da6fa64E","ranges":[[11737,11747],[11754,11860],[11869,11886]],"call_file":13,"call_line":502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17hc5fd2ec542addbc2E","low_pc":11737,"high_pc":11747,"call_file":13,"call_line":661},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":11754,"high_pc":11757,"call_file":13,"call_line":661},{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h527541d661973407E","low_pc":11776,"high_pc":11797,"call_file":13,"call_line":668,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3max17h498b7425de300345E","low_pc":11783,"high_pc":11797,"call_file":13,"call_line":440,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3max17h3f93369c4fdfee14E","low_pc":11783,"high_pc":11797,"call_file":16,"call_line":858,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","ranges":[[11783,11785],[11787,11792]],"call_file":16,"call_line":558}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7realloc17h126027d72628d920E","low_pc":11814,"high_pc":11826,"call_file":13,"call_line":677,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7realloc17h61188e90de5f7cdaE","low_pc":11814,"high_pc":11826,"call_file":12,"call_line":169}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17h1b32f98fc464f104E","low_pc":11834,"high_pc":11844,"call_file":13,"call_line":679,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","low_pc":11834,"high_pc":11844,"call_file":12,"call_line":154}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h36fdd8d064e94d91E","name":"len<u8>","decl_file":4,"decl_line":1168,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17h25c1f8dae33ebda8E","name":"set_len<u8>","decl_file":4,"decl_line":796,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$5drain17h724b32b8e3731003E","name":"drain<u8,core::ops::range::RangeTo<usize>>","decl_file":4,"decl_line":1094,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13with_capacity17h06b7fbe89d617920E","name":"with_capacity<u8>","decl_file":4,"decl_line":366,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17h1c30330c056f186dE","name":"extend_from_slice<u8>","decl_file":4,"decl_line":1328,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$4push17h685aa171ecd1dd2aE","name":"push<u8>","decl_file":4,"decl_line":995,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13reserve_exact17h04f5f64586e3d39aE","name":"reserve_exact<u8>","decl_file":4,"decl_line":494,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13shrink_to_fit17h00809cd72cf76185E","name":"shrink_to_fit<u8>","decl_file":4,"decl_line":590,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$16into_boxed_slice17h4a3d3b2bad71af50E","name":"into_boxed_slice<u8>","decl_file":4,"decl_line":646,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3pop17h93216c0d907b6344E","name":"pop<u8>","decl_file":4,"decl_line":1022,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$8truncate17h4ba56063570f7ca6E","name":"truncate<u8>","decl_file":4,"decl_line":698,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$5clear17h5cb80b8ae76f39f9E","name":"clear<u8>","decl_file":4,"decl_line":1153,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$11extend_with17hf36b814ba5931503E","name":"extend_with<u8,alloc::vec::ExtendElement<u8>>","decl_file":4,"decl_line":1399,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$6resize17h53a9c8995bdacc64E","name":"resize<u8>","decl_file":4,"decl_line":1298,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17hd8b395996dddb505E","name":"reserve<u8>","decl_file":4,"decl_line":469,"inline":"inlined"}]},{"tag":"structure_type","name":"Vec<alloc::boxed::Box<FnBox<()>>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<alloc::boxed::Box<FnBox<()>>, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3new17h5577af8c89c2d17aE","name":"new<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":329,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$4push17h431953cf20becf3bE","name":"push<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":995,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17h7407130d2deed3fbE","name":"reserve<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":469,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h4f93e49c82ccff63E","name":"deref<u8>","decl_file":4,"decl_line":1676,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN61_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hba89498b4fd73b4eE","name":"fmt<u8>","decl_file":4,"decl_line":2130,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h5123a2c6f35f1db1E","name":"spec_extend<u8>","decl_file":4,"decl_line":1888,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h38e1111107f5ff14E","name":"deref_mut<u8>","decl_file":4,"decl_line":1687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$u8$u20$as$u20$alloc..vec..SpecFromElem$GT$9from_elem17he6e2c8c214f11669E","name":"from_elem","decl_file":4,"decl_line":1527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..iter..traits..FromIterator$LT$T$GT$$GT$9from_iter17h5057c46c11f34173E","name":"from_iter<std::ffi::os_str::OsString,core::iter::Map<core::slice::Split<u8, closure>, closure>>","decl_file":4,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN85_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$T$C$$u20$I$GT$$GT$9from_iter17ha0031c46fb5375d7E","name":"from_iter<std::ffi::os_str::OsString,core::iter::Map<core::slice::Split<u8, closure>, closure>>","decl_file":4,"decl_line":1782,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN85_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$T$C$$u20$I$GT$$GT$11spec_extend17h366054f661628091E","name":"spec_extend<std::ffi::os_str::OsString,core::iter::Map<core::slice::Split<u8, closure>, closure>>","decl_file":4,"decl_line":1804,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..iter..traits..IntoIterator$GT$9into_iter17h64ff42c31b27c7e8E","name":"into_iter<std::ffi::os_str::OsString>","decl_file":4,"decl_line":1723,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..IntoIter$LT$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha18d418f28f6b0a8E","name":"next<std::ffi::os_str::OsString>","decl_file":4,"decl_line":2330,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..IntoIter$LT$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17h7fcf14114838299bE","name":"size_hint<std::ffi::os_str::OsString>","decl_file":4,"decl_line":2354,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN89_$LT$alloc..vec..IntoIter$LT$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17hc1446fa2d3fb28c8E","name":"next_back<std::ffi::os_str::OsString>","decl_file":4,"decl_line":2372,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..SetLenOnDrop$LT$$u27$a$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hbeea29b3c8effdacE","name":"drop","decl_file":4,"decl_line":1457,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..index..IndexMut$LT$I$GT$$GT$9index_mut17h29b31e7e668fbec9E","name":"index_mut<u8,core::ops::range::Range<usize>>","decl_file":4,"decl_line":1667,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..index..Index$LT$I$GT$$GT$5index17h21ef25eaea85b257E","name":"index<u8,core::ops::range::RangeFrom<usize>>","decl_file":4,"decl_line":1652,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..index..IndexMut$LT$I$GT$$GT$9index_mut17ha201895a36a95d94E","name":"index_mut<u8,core::ops::range::RangeFrom<usize>>","decl_file":4,"decl_line":1667,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..iter..traits..IntoIterator$GT$9into_iter17ha29387d6cca7e8aeE","name":"into_iter<std::net::addr::SocketAddr>","decl_file":4,"decl_line":1723,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..IntoIter$LT$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h842fea5d705b0832E","name":"next<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":2330,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..iter..traits..IntoIterator$GT$9into_iter17he7860c0c182d008eE","name":"into_iter<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":1723,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$alloc..vec..IntoIter$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hc45c41e82c077083E","name":"drop<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":2415,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17h2b10e1b0aceadcb6E","name":"deref_mut<alloc::boxed::Box<FnBox<()>>>","decl_file":4,"decl_line":1687,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc3vec9from_elem17h117f04c1de3a7df3E","name":"from_elem<u8>","decl_file":4,"decl_line":1508,"inline":"inlined"},{"tag":"structure_type","name":"Vec<std::ffi::os_str::OsString>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<std::ffi::os_str::OsString, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13with_capacity17h35bba12f4eb654f8E","name":"with_capacity<std::ffi::os_str::OsString>","decl_file":4,"decl_line":366,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$16extend_desugared17hfa09c30fdca5963aE","name":"extend_desugared<std::ffi::os_str::OsString,core::iter::Map<core::slice::Split<u8, closure>, closure>>","decl_file":4,"decl_line":1900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17hbcf520a87708fdd5E","name":"reserve<std::ffi::os_str::OsString>","decl_file":4,"decl_line":469,"inline":"inlined"}]},{"tag":"structure_type","name":"IntoIter<std::ffi::os_str::OsString>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"buf","type":"NonNull<std::ffi::os_str::OsString>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::ffi::os_str::OsString>","alignment":1,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"ptr","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":8},{"tag":"member","name":"end","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":12},{"tag":"subprogram","linkage_name":"_ZN38_$LT$alloc..vec..IntoIter$LT$T$GT$$GT$8as_slice17h62738f948bad6cfbE","name":"as_slice<std::ffi::os_str::OsString>","decl_file":4,"decl_line":2293,"inline":"inlined"}]},{"tag":"structure_type","name":"SetLenOnDrop","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"len","type":"&mut usize","alignment":4,"data_member_location":0},{"tag":"member","name":"local_len","type":"usize","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN5alloc3vec12SetLenOnDrop13increment_len17hc4b4df9d4743af83E","name":"increment_len","decl_file":4,"decl_line":1445,"inline":"inlined"}]},{"tag":"structure_type","name":"Vec<core::option::Option<()>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<core::option::Option<()>, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17hc5fd2ec542addbc2E","name":"cap<u8,alloc::alloc::Global>","decl_file":13,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$13shrink_to_fit17he4acdbc4ecb1f366E","name":"shrink_to_fit<u8,alloc::alloc::Global>","decl_file":13,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hb67e6fc3ca39c235E","name":"dealloc_buffer<u8,alloc::alloc::Global>","decl_file":13,"decl_line":716,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h7f2c3b5e9da6fa64E","name":"reserve_internal<u8,alloc::alloc::Global>","decl_file":13,"decl_line":644,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17hc474bb996bf1032bE","name":"reserve<u8,alloc::alloc::Global>","decl_file":13,"decl_line":501,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h527541d661973407E","name":"amortized_new_size<u8,alloc::alloc::Global>","decl_file":13,"decl_line":432,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h62834538e5e7018fE","name":"current_layout<u8,alloc::alloc::Global>","decl_file":13,"decl_line":233,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17h97c1a7f9c2a1bef2E","name":"ptr<u8,alloc::alloc::Global>","decl_file":13,"decl_line":207,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in17hfd471ca14a2817ceE","name":"allocate_in<u8,alloc::alloc::Global>","decl_file":13,"decl_line":90,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$13with_capacity17h546a30a45af76ae2E","name":"with_capacity<u8>","decl_file":13,"decl_line":149,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$20with_capacity_zeroed17h10f517f6cc9986b8E","name":"with_capacity_zeroed<u8>","decl_file":13,"decl_line":155,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$13reserve_exact17hcf5d9d192a2a845eE","name":"reserve_exact<u8,alloc::alloc::Global>","decl_file":13,"decl_line":421,"inline":"inlined"}]},{"tag":"structure_type","name":"RawVec<alloc::boxed::Box<FnBox<()>>, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<alloc::boxed::Box<FnBox<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hdf50ecfb84f79feaE","name":"dealloc_buffer<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":716,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h97429b98a71901feE","name":"current_layout<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":233,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17h79d7bf55e808dcb8E","name":"cap<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h7512bb612508d438E","name":"amortized_new_size<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":432,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h644acae1ff70e3a3E","name":"reserve_internal<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":644,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17h89d1021127c7eca8E","name":"reserve<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":501,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hf2e430ee23d0bb4bE","name":"ptr<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":207,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h32c521ec5670cd01E","name":"drop<u8,alloc::alloc::Global>","decl_file":13,"decl_line":728,"inline":"inlined"},{"tag":"namespace","name":"allocate_in","children":[]},{"tag":"subprogram","linkage_name":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h0f524653fad86038E","name":"drop<alloc::boxed::Box<FnBox<()>>,alloc::alloc::Global>","decl_file":13,"decl_line":728,"inline":"inlined"}]},{"tag":"structure_type","name":"RawVec<std::ffi::os_str::OsString, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<std::ffi::os_str::OsString>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in17h30e9a9b569e51625E","name":"allocate_in<std::ffi::os_str::OsString,alloc::alloc::Global>","decl_file":13,"decl_line":90,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$13with_capacity17ha5ad9851bf65da76E","name":"with_capacity<std::ffi::os_str::OsString>","decl_file":13,"decl_line":149,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h002ba4d7dc408df5E","name":"reserve_internal<std::ffi::os_str::OsString,alloc::alloc::Global>","decl_file":13,"decl_line":644,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17hbcb7d13ed1693826E","name":"reserve<std::ffi::os_str::OsString,alloc::alloc::Global>","decl_file":13,"decl_line":501,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h945318002fb72592E","name":"amortized_new_size<std::ffi::os_str::OsString,alloc::alloc::Global>","decl_file":13,"decl_line":432,"inline":"inlined"}]},{"tag":"structure_type","name":"RawVec<core::option::Option<()>, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<core::option::Option<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc7realloc17h61188e90de5f7cdaE","name":"realloc","decl_file":12,"decl_line":113,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7realloc17h126027d72628d920E","name":"realloc","decl_file":12,"decl_line":163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","name":"dealloc","decl_file":12,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17h1b32f98fc464f104E","name":"alloc","decl_file":12,"decl_line":153,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$12alloc_zeroed17h968e9dc34d3387a6E","name":"alloc_zeroed","decl_file":12,"decl_line":173,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","name":"dealloc","decl_file":12,"decl_line":95,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","name":"alloc","decl_file":12,"decl_line":77,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17hd1b31ddfad6f25f8E","name":"box_free<[u8]>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h70aa9c18265f7cf8E","name":"box_free<std::sys_common::mutex::Mutex>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17hcfdaec7c8ad78189E","name":"box_free<Error>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h560ae976be167915E","name":"box_free<std::io::error::Custom>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17he7e51abb8fe721d6E","name":"box_free<Any>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h28bd10adb5ddee95E","name":"box_free<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h25e93d6d3da87c4bE","name":"box_free<closure>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h04a4c736e83c5381E","name":"box_free<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h9727c0197fd2c3deE","name":"box_free<closure>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h8293cf4de58fac02E","name":"box_free<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h49767763977e3990E","name":"box_free<closure>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc15exchange_malloc17hd81a4f1a1ec767d6E","name":"exchange_malloc","decl_file":12,"decl_line":183,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc12alloc_zeroed17h1909d539ee00f05eE","name":"alloc_zeroed","decl_file":12,"decl_line":146,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h2d128cedf3ff8d08E","name":"box_free<alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h21def441f9d54192E","name":"box_free<FnBox<()>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h8333662781747168E","name":"box_free<std::sys::wasm::thread_local::Allocated>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h45d27bf26f27249cE","name":"box_free<Fn<(&core::panic::PanicInfo)>>","decl_file":12,"decl_line":199,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc8box_free17h8b2401056caef352E","name":"box_free<Write>","decl_file":12,"decl_line":199,"inline":"inlined"}]},{"tag":"namespace","name":"sync","children":[{"tag":"structure_type","name":"Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$5inner17h99cc903dc323ba9fE","name":"inner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":55,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$3new17h2ed728f04ed4b896E","name":"new<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":55,"decl_line":296,"inline":"inlined"}]},{"tag":"structure_type","name":"ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","byte_size":36,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$5inner17h854c3fc5ecd320fcE","name":"inner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":55,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$3new17h7c4ad485ce7f7a1dE","name":"new<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":55,"decl_line":296,"inline":"inlined"}]},{"tag":"structure_type","name":"ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$5inner17heebe8381f9446f47E","name":"inner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":55,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$3new17h73eb9f976da3f106E","name":"new<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":55,"decl_line":296,"inline":"inlined"}]},{"tag":"structure_type","name":"ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Arc<std::thread::Inner>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::thread::Inner>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::thread::Inner>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$5inner17hbb17cb01d0c37af3E","name":"inner<std::thread::Inner>","decl_file":55,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$3new17h29491d6236de3eceE","name":"new<std::thread::Inner>","decl_file":55,"decl_line":296,"inline":"inlined"}]},{"tag":"structure_type","name":"ArcInner<std::thread::Inner>","byte_size":48,"alignment":8,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Inner","alignment":8,"data_member_location":8}]},{"tag":"structure_type","name":"ArcInner<std::sync::mpsc::blocking::Inner>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Inner","alignment":4,"data_member_location":8}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h272d42dffa30e9d4E","name":"drop<std::thread::Inner>","decl_file":55,"decl_line":955,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h89358e274bcfb99bE","name":"drop<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":55,"decl_line":955,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hed82cc4c793ec888E","name":"drop<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":55,"decl_line":955,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h6c0785ccb444407eE","name":"drop<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":55,"decl_line":955,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h260b03d002e9306dE","name":"deref<std::thread::Inner>","decl_file":55,"decl_line":764,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hb4f8e1932927d5f9E","name":"clone<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":55,"decl_line":726,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hfaee6442c660bacdE","name":"deref<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":55,"decl_line":764,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hefede9a7fe0dd9c2E","name":"clone<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":55,"decl_line":726,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h97842dc3c1a85f07E","name":"deref<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":55,"decl_line":764,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17h039e48cfaae23126E","name":"clone<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":55,"decl_line":726,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hd10688523d086d1bE","name":"deref<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":55,"decl_line":764,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hda0b3087d5867be3E","name":"clone<std::sync::mpsc::blocking::Inner>","decl_file":55,"decl_line":726,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h052fff375d6fff4eE","name":"deref<std::sync::mpsc::blocking::Inner>","decl_file":55,"decl_line":764,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h041a568b7dde208eE","name":"drop<std::sync::mpsc::blocking::Inner>","decl_file":55,"decl_line":955,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$alloc..sync..Arc$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17h746549c00ce21027E","name":"clone<std::thread::Inner>","decl_file":55,"decl_line":726,"inline":"inlined"}]},{"tag":"structure_type","name":"Arc<std::sync::mpsc::blocking::Inner>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mpsc::blocking::Inner>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$5inner17h5dabe0ca66953bebE","name":"inner<std::sync::mpsc::blocking::Inner>","decl_file":55,"decl_line":527,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN34_$LT$alloc..sync..Arc$LT$T$GT$$GT$3new17hefa999b2ed0604d8E","name":"new<std::sync::mpsc::blocking::Inner>","decl_file":55,"decl_line":296,"inline":"inlined"}]},{"tag":"structure_type","name":"Arc<std::sync::mpsc::oneshot::Packet<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mpsc::oneshot::Packet<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ArcInner<std::sync::mpsc::oneshot::Packet<()>>","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Packet<()>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Arc<std::sync::mpsc::stream::Packet<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mpsc::stream::Packet<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ArcInner<std::sync::mpsc::stream::Packet<()>>","byte_size":192,"alignment":64,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Packet<()>","alignment":64,"data_member_location":64}]},{"tag":"structure_type","name":"Arc<std::sync::mpsc::shared::Packet<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mpsc::shared::Packet<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ArcInner<std::sync::mpsc::shared::Packet<()>>","byte_size":48,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Packet<()>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Arc<std::sync::mpsc::sync::Packet<()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"NonNull<alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"phantom","type":"PhantomData<std::sync::mpsc::sync::Packet<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ArcInner<std::sync::mpsc::sync::Packet<()>>","byte_size":68,"alignment":4,"children":[{"tag":"member","name":"strong","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"weak","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"data","type":"Packet<()>","alignment":4,"data_member_location":8}]}]},{"tag":"namespace","name":"boxed","children":[{"tag":"structure_type","name":"Box<FnBox<()>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN63_$LT$alloc..boxed..Box$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h7d89475280add225E","name":"fmt<Error>","decl_file":28,"decl_line":554,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h4f35ede16992f115E","name":"new<std::error::{{impl}}::from::StringError>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN110_$LT$alloc..boxed..Box$LT$$u5b$T$u5d$$GT$$u20$as$u20$core..convert..From$LT$$RF$$u27$a$u20$$u5b$T$u5d$$GT$$GT$4from17h8cb3f29ced9f4643E","name":"from<u8>","decl_file":28,"decl_line":458,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h7a1df03a1c5df049E","name":"new<[u8; 1]>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$alloc..boxed..Box$LT$T$GT$$u20$as$u20$core..convert..From$LT$T$GT$$GT$4from17hf438276a865e6c1eE","name":"from<[u8; 1]>","decl_file":28,"decl_line":441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h2aeca365ea66ee4cE","name":"new<std::io::error::Custom>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$alloc..boxed..Box$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17he6ff3dae486a2716E","name":"fmt<std::io::error::Custom>","decl_file":28,"decl_line":554,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$alloc..boxed..Box$LT$T$GT$$u20$as$u20$core..fmt..Display$GT$3fmt17he222b02dd3e8a252E","name":"fmt<Error>","decl_file":28,"decl_line":547,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h5693c27811921913E","name":"new<closure>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17hc300c927334d3626E","name":"new<alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h7f59a66ecb4d3189E","name":"new<closure>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h8cd0191f3e57524cE","name":"new<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h41fe91aa8011b3daE","name":"new<closure>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17hf14ecf556aefca44E","name":"new<alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN167_$LT$alloc..boxed..Box$LT$$LP$dyn$u20$alloc..boxed..FnBox$LT$A$C$$u20$Output$u3d$R$GT$$u20$$u2b$$u20$$u27$a$RP$$GT$$u20$as$u20$core..ops..function..FnOnce$LT$A$GT$$GT$9call_once17h5a882c5b07feb6c0E","name":"call_once<(),()>","decl_file":28,"decl_line":681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17he750856764ed3ea0E","name":"new<std::sys::wasm::thread_local::Allocated>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h88cb49a123813c16E","name":"new<alloc::string::String>","decl_file":28,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$8into_raw17h1527315a575f6469E","name":"into_raw<Any>","decl_file":28,"decl_line":171,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17hbfa6fc65019632d3E","name":"new<&str>","decl_file":28,"decl_line":107,"inline":"inlined"}]}]},{"tag":"namespace","name":"collections","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"CollectionAllocErr","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"CapacityOverflow","const_value":0},{"tag":"enumerator","name":"AllocErr","const_value":1}]},{"tag":"namespace","name":"btree","children":[{"tag":"namespace","name":"map","children":[{"tag":"structure_type","name":"BTreeMap<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"root","type":"Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN67_$LT$alloc..collections..btree..map..BTreeMap$LT$K$C$$u20$V$GT$$GT$5clear17he0267792f4c3c796E","name":"clear<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":555,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN100_$LT$alloc..collections..btree..map..BTreeMap$LT$K$C$$u20$V$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h52fad003cd94b8bcE","name":"drop<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":142,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN111_$LT$alloc..collections..btree..map..BTreeMap$LT$K$C$$u20$V$GT$$u20$as$u20$core..iter..traits..IntoIterator$GT$9into_iter17hdf26c27e1d738199E","name":"into_iter<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":1296,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN109_$LT$alloc..collections..btree..map..IntoIter$LT$K$C$$u20$V$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h7465e38a37ca8563E","name":"next<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":1334,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$alloc..collections..btree..map..IntoIter$LT$K$C$$u20$V$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17haf653cb7f84f9aedE","name":"drop<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":1312,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc11collections5btree3map15first_leaf_edge17he68ba2ef805b2e89E","name":"first_leaf_edge<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":56,"decl_line":1815,"inline":"inlined"}]},{"tag":"namespace","name":"node","children":[{"tag":"structure_type","name":"Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"node","type":"BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0},{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN69_$LT$alloc..collections..btree..node..BoxedNode$LT$K$C$$u20$V$GT$$GT$6as_ptr17ha8b02b0cbb8caf9eE","name":"as_ptr<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":174,"inline":"inlined"}]},{"tag":"structure_type","name":"LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","byte_size":272,"alignment":4,"children":[{"tag":"member","name":"parent","type":"*const alloc::collections::btree::node::InternalNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0},{"tag":"member","name":"parent_idx","type":"MaybeUninit<u16>","alignment":2,"data_member_location":4},{"tag":"member","name":"len","type":"u16","alignment":2,"data_member_location":6},{"tag":"member","name":"keys","type":"MaybeUninit<[std::sys_common::process::DefaultEnvKey; 11]>","alignment":4,"data_member_location":8},{"tag":"member","name":"vals","type":"MaybeUninit<[core::option::Option<std::ffi::os_str::OsString>; 11]>","alignment":4,"data_member_location":140},{"tag":"subprogram","linkage_name":"_ZN68_$LT$alloc..collections..btree..node..LeafNode$LT$K$C$$u20$V$GT$$GT$14is_shared_root17hf4832365d3691ddaE","name":"is_shared_root<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":102,"inline":"inlined"}]},{"tag":"structure_type","name":"InternalNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","byte_size":320,"alignment":4,"children":[{"tag":"member","name":"data","type":"LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0},{"tag":"member","name":"edges","type":"BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>[]","alignment":4,"data_member_location":272}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::Edge>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::Edge>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN242_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$alloc..collections..btree..node..marker..Internal$GT$$C$$u20$alloc..collections..btree..node..marker..Edge$GT$$GT$7descend17hd47b3dae7b247c56E","name":"descend<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":1090,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN201_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..Edge$GT$$GT$8right_kv17h7fb4b3e1f99c202aE","name":"right_kv<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":943,"inline":"inlined"}]},{"tag":"structure_type","name":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"node","type":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"root","type":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":8},{"tag":"member","name":"_marker","type":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::Internal)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$3len17hc2d86d6a62369133E","name":"len<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":354,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$6ascend17h07ce3854a18114a2E","name":"ascend<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":410,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN178_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Owned$C$$u20$K$C$$u20$V$C$$u20$alloc..collections..btree..node..marker..Internal$GT$$GT$21deallocate_and_ascend17hfb0f5a6e34ba47c6E","name":"deallocate_and_ascend<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":487,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$10first_edge17h5d33768ad9297c90E","name":"first_edge<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":438,"inline":"inlined"}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>, alloc::collections::btree::node::marker::Edge>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::Edge>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN201_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..Edge$GT$$GT$8right_kv17h3b3448e2864075baE","name":"right_kv<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":943,"inline":"inlined"}]},{"tag":"structure_type","name":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"node","type":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"root","type":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":8},{"tag":"member","name":"_marker","type":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::Leaf)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$3len17h6ca460b7a706af32E","name":"len<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":354,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$6ascend17hc0c66ddfe3caf8efE","name":"ascend<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":410,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN174_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Owned$C$$u20$K$C$$u20$V$C$$u20$alloc..collections..btree..node..marker..Leaf$GT$$GT$21deallocate_and_ascend17hccfa829d77ac5766E","name":"deallocate_and_ascend<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":465,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$14is_shared_root17ha383aa1f1a289f7cE","name":"is_shared_root<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":391,"inline":"inlined"}]},{"tag":"structure_type","name":"NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"node","type":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"root","type":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":8},{"tag":"member","name":"_marker","type":"PhantomData<(alloc::collections::btree::node::marker::Immut, alloc::collections::btree::node::marker::Leaf)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN147_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$14into_key_slice17hbd8b22e68db9578aE","name":"into_key_slice<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":553,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN147_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$11into_slices17hb529229634c28e3eE","name":"into_slices<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":584,"inline":"inlined"}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>, alloc::collections::btree::node::marker::KV>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::KV>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN249_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..KV$GT$$GT$7into_kv17hcc06dfd693001468E","name":"into_kv<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":1103,"inline":"inlined"}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>, alloc::collections::btree::node::marker::KV>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Leaf>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::KV>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN199_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..KV$GT$$GT$10right_edge17h00e34d76ddd89991E","name":"right_edge<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Leaf>","decl_file":57,"decl_line":863,"inline":"inlined"}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::KV>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::KV>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN199_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..KV$GT$$GT$10right_edge17h580a2ef6b827689aE","name":"right_edge<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":863,"inline":"inlined"}]},{"tag":"structure_type","name":"NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"node","type":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"root","type":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":8},{"tag":"member","name":"_marker","type":"PhantomData<(alloc::collections::btree::node::marker::Immut, alloc::collections::btree::node::marker::Internal)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN147_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$14into_key_slice17hd952c317f4bfc540E","name":"into_key_slice<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":553,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN147_$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$Type$GT$$GT$11into_slices17hfdca283e400ee82eE","name":"into_slices<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":584,"inline":"inlined"}]},{"tag":"structure_type","name":"Handle<alloc::collections::btree::node::NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>, alloc::collections::btree::node::marker::KV>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"node","type":"NodeRef<alloc::collections::btree::node::marker::Immut, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::Internal>","alignment":4,"data_member_location":0},{"tag":"member","name":"idx","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::marker::KV>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN249_$LT$alloc..collections..btree..node..Handle$LT$alloc..collections..btree..node..NodeRef$LT$alloc..collections..btree..node..marker..Immut$LT$$u27$a$GT$$C$$u20$K$C$$u20$V$C$$u20$NodeType$GT$$C$$u20$alloc..collections..btree..node..marker..KV$GT$$GT$7into_kv17h63c27d703350d205E","name":"into_kv<std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>,alloc::collections::btree::node::marker::Internal>","decl_file":57,"decl_line":1103,"inline":"inlined"}]},{"tag":"structure_type","name":"NodeRef<alloc::collections::btree::node::marker::Owned, std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>, alloc::collections::btree::node::marker::LeafOrInternal>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"height","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"node","type":"NonNull<alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"root","type":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":8},{"tag":"member","name":"_marker","type":"PhantomData<(alloc::collections::btree::node::marker::Owned, alloc::collections::btree::node::marker::LeafOrInternal)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN148_$LT$alloc..collections..btree..node..NodeRef$LT$BorrowType$C$$u20$K$C$$u20$V$C$$u20$alloc..collections..btree..node..marker..LeafOrInternal$GT$$GT$5force17h55768530804d49a6E","name":"force<alloc::collections::btree::node::marker::Owned,std::sys_common::process::DefaultEnvKey,core::option::Option<std::ffi::os_str::OsString>>","decl_file":57,"decl_line":794,"inline":"inlined"}]}]}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"hack","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc5slice4hack6to_vec17h1e498705042ce39aE","name":"to_vec<u8>","decl_file":58,"decl_line":166,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice4hack8into_vec17h4791698701fa876dE","name":"into_vec<u8>","decl_file":58,"decl_line":157,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$6to_vec17he59f435b3ad239f1E","name":"to_vec<u8>","decl_file":58,"decl_line":367,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice64_$LT$impl$u20$alloc..borrow..ToOwned$u20$for$u20$$u5b$T$u5d$$GT$8to_owned17h0e9805027a43627dE","name":"to_owned<u8>","decl_file":58,"decl_line":628,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8into_vec17hdc175dbc0cbd0674E","name":"into_vec<u8>","decl_file":58,"decl_line":390,"inline":"inlined"}]}]},{"tag":"namespace","name":"str","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str56_$LT$impl$u20$alloc..borrow..ToOwned$u20$for$u20$str$GT$8to_owned17haaef7e841f840852E","name":"to_owned","decl_file":59,"decl_line":207,"inline":"inlined"}]}]},{"tag":"namespace","name":"borrow","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN85_$LT$alloc..borrow..Cow$LT$$u27$a$C$$u20$B$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hdc2be72f6d29c656E","name":"deref<std::ffi::os_str::OsStr>","decl_file":60,"decl_line":303,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$alloc..borrow..Cow$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..convert..AsRef$LT$T$GT$$GT$6as_ref17h71f8ad53adb9bdc2E","name":"as_ref<std::ffi::os_str::OsStr>","decl_file":60,"decl_line":395,"inline":"inlined"}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":11232,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Adaptor<std::sys::wasm::stdio::Stderr>","name":"&mut std::io::Write::write_fmt::Adaptor<std::sys::wasm::stdio::Stderr>"},{"tag":"namespace","name":"std","children":[{"tag":"namespace","name":"io","children":[{"tag":"namespace","name":"Write","children":[{"tag":"namespace","name":"write_fmt","children":[{"tag":"structure_type","name":"Adaptor<std::sys::wasm::stdio::Stderr>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"&mut std::sys::wasm::stdio::Stderr","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Result<(), std::io::error::Error>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Adaptor<std::io::stdio::StdoutLock>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"&mut std::io::stdio::StdoutLock","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Result<(), std::io::error::Error>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Adaptor<std::io::stdio::StderrLock>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"&mut std::io::stdio::StderrLock","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Result<(), std::io::error::Error>","alignment":4,"data_member_location":4}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN94_$LT$std..io..Write..write_fmt..Adaptor$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h79bdbd936aa712fdE","name":"write_str<std::io::stdio::StdoutLock>","decl_file":61,"decl_line":1127,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$std..io..Write..write_fmt..Adaptor$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h7a155d65532ac710E","name":"write_str<std::io::stdio::StderrLock>","decl_file":61,"decl_line":1127,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std2io5Write9write_all17hf45454ee03877a2eE","name":"write_all<std::io::stdio::StderrLock>","decl_file":61,"decl_line":1066,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5Write9write_all17h527a1e8e85d63614E","name":"write_all<std::sys::wasm::stdio::Stderr>","decl_file":61,"decl_line":1066,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5Write9write_fmt17h49fe34295ee7319dE","name":"write_fmt<std::sys::wasm::stdio::Stderr>","decl_file":61,"decl_line":1118,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5Write9write_fmt17hde404504d0ecba74E","name":"write_fmt<std::io::stdio::StdoutLock>","decl_file":61,"decl_line":1118,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5Write9write_fmt17h50fd7c3f3b15d970E","name":"write_fmt<std::io::stdio::StderrLock>","decl_file":61,"decl_line":1118,"inline":"inlined"}]},{"tag":"namespace","name":"error","children":[{"tag":"structure_type","name":"Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"repr","type":"Repr","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std2io5error5Error3new17h19a242b36612b99eE","name":"new<&str>","decl_file":62,"decl_line":256,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5error5Error4_new17h4e775d8ce50e0016E","name":"_new","decl_file":62,"decl_line":262,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5error5Error4kind17h5c188ef2730a7e90E","name":"kind","decl_file":62,"decl_line":512,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5error5Error17from_raw_os_error17hb536d494c9ad1f19E","name":"from_raw_os_error","decl_file":62,"decl_line":315,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Repr","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":47942,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Os","type":"Os","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Simple","type":"Simple","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Custom","type":"Custom","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Os","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"i32","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Simple","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"ErrorKind","alignment":1,"data_member_location":1}]},{"tag":"structure_type","name":"Custom","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Box<std::io::error::Custom>","alignment":4,"data_member_location":4}]}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"ErrorKind","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"NotFound","const_value":0},{"tag":"enumerator","name":"PermissionDenied","const_value":1},{"tag":"enumerator","name":"ConnectionRefused","const_value":2},{"tag":"enumerator","name":"ConnectionReset","const_value":3},{"tag":"enumerator","name":"ConnectionAborted","const_value":4},{"tag":"enumerator","name":"NotConnected","const_value":5},{"tag":"enumerator","name":"AddrInUse","const_value":6},{"tag":"enumerator","name":"AddrNotAvailable","const_value":7},{"tag":"enumerator","name":"BrokenPipe","const_value":8},{"tag":"enumerator","name":"AlreadyExists","const_value":9},{"tag":"enumerator","name":"WouldBlock","const_value":10},{"tag":"enumerator","name":"InvalidInput","const_value":11},{"tag":"enumerator","name":"InvalidData","const_value":12},{"tag":"enumerator","name":"TimedOut","const_value":13},{"tag":"enumerator","name":"WriteZero","const_value":14},{"tag":"enumerator","name":"Interrupted","const_value":15},{"tag":"enumerator","name":"Other","const_value":16},{"tag":"enumerator","name":"UnexpectedEof","const_value":17},{"tag":"subprogram","linkage_name":"_ZN3std2io5error9ErrorKind6as_str17h3c7c9448194ea8bcE","name":"as_str","decl_file":62,"decl_line":187,"inline":"inlined"}]},{"tag":"structure_type","name":"Custom","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"kind","type":"ErrorKind","alignment":1,"data_member_location":8},{"tag":"member","name":"error","type":"Box<Error>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN59_$LT$std..io..error..Custom$u20$as$u20$core..fmt..Debug$GT$3fmt17h266d7d0b53d395d9E","name":"fmt","decl_file":62,"decl_line":83,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$std..io..error..ErrorKind$u20$as$u20$core..cmp..PartialEq$GT$2eq17hfcd13eb788feeda8E","name":"eq","decl_file":62,"decl_line":97,"inline":"inlined"}]}]},{"tag":"namespace","name":"stdio","children":[{"tag":"structure_type","name":"StdoutLock","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"ReentrantMutexGuard<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Maybe","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Real","const_value":0},{"tag":"enumerator","name":"Fake","const_value":1}]},{"tag":"structure_type","name":"StderrLock","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"ReentrantMutexGuard<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"stdin","children":[{"tag":"variable","name":"INSTANCE","type":"Lazy<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":63,"decl_line":200,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std2io5stdio5stdin8INSTANCE17hc2e35ed291dc0163E"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio5stdin10stdin_init17h252c0eb2f572ff97E","name":"stdin_init","decl_file":63,"decl_line":207,"inline":"inlined"}]},{"tag":"namespace","name":"stdout","children":[{"tag":"variable","name":"INSTANCE","type":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":63,"decl_line":401,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std2io5stdio6stdout8INSTANCE17h767fb40af1de30b8E"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio6stdout11stdout_init17h713401106c9635ffE","name":"stdout_init","decl_file":63,"decl_line":408,"inline":"inlined"}]},{"tag":"namespace","name":"stderr","children":[{"tag":"variable","name":"INSTANCE","type":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":63,"decl_line":539,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std2io5stdio6stderr8INSTANCE17ha6f449475240c395E"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio6stderr11stderr_init17h18cb50640af15a1eE","name":"stderr_init","decl_file":63,"decl_line":546,"inline":"inlined"}]},{"tag":"namespace","name":"LOCAL_STDOUT","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","decl_file":24,"decl_line":177,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std2io5stdio12LOCAL_STDOUT7__getit5__KEY17h265dea1765684164E"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..io..stdio..StderrLock$LT$$u27$a$GT$$u20$as$u20$std..io..Write$GT$5write17h5cd9ebb8aff9c7cfE","name":"write","decl_file":63,"decl_line":607,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..io..stdio..StdinLock$LT$$u27$a$GT$$u20$as$u20$std..io..BufRead$GT$8fill_buf17hed44f94d1fffce81E","name":"fill_buf","decl_file":63,"decl_line":322,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..io..stdio..StdinLock$LT$$u27$a$GT$$u20$as$u20$std..io..BufRead$GT$7consume17he0f5f90bb540844dE","name":"consume","decl_file":63,"decl_line":323,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$std..io..stdio..StdinLock$LT$$u27$a$GT$$u20$as$u20$std..io..Read$GT$4read17h87455d829bd485e0E","name":"read","decl_file":63,"decl_line":311,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..io..stdio..Maybe$LT$R$GT$$u20$as$u20$std..io..Read$GT$4read17hb7849fdb249c770aE","name":"read<std::io::stdio::StdinRaw>","decl_file":63,"decl_line":115,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..io..stdio..StdoutLock$LT$$u27$a$GT$$u20$as$u20$std..io..Write$GT$5flush17h0a462e6da18afa79E","name":"flush","decl_file":63,"decl_line":472,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..io..stdio..Maybe$LT$W$GT$$u20$as$u20$std..io..Write$GT$5write17hd8860436f015062cE","name":"write<std::io::stdio::StderrRaw>","decl_file":63,"decl_line":99,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..io..stdio..StderrLock$LT$$u27$a$GT$$u20$as$u20$std..io..Write$GT$5flush17h749339c33e65f46eE","name":"flush","decl_file":63,"decl_line":610,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..io..stdio..Maybe$LT$W$GT$$u20$as$u20$std..io..Write$GT$5flush17heb62291c0f655f1fE","name":"flush<std::io::stdio::StderrRaw>","decl_file":63,"decl_line":106,"inline":"inlined"}]},{"tag":"structure_type","name":"Stdin","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio5Stdin4lock17h72bc71e290de8d0dE","name":"lock","decl_file":63,"decl_line":244,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio12handle_ebadf17h10e39ff0cc04a180E","name":"handle_ebadf<usize>","decl_file":63,"decl_line":123,"inline":"inlined"},{"tag":"structure_type","name":"Stdout","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio6Stdout4lock17h9d37555072ebb7aeE","name":"lock","decl_file":63,"decl_line":440,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Stderr","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio6Stderr4lock17h6bc813a1e51b3b73E","name":"lock","decl_file":63,"decl_line":578,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio12handle_ebadf17h6ad7dda19b4e21c1E","name":"handle_ebadf<()>","decl_file":63,"decl_line":123,"inline":"inlined"},{"tag":"namespace","name":"set_panic","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio9set_panic28_$u7b$$u7b$closure$u7d$$u7d$17h44a78d2b512eac6eE","name":"{{closure}}","decl_file":63,"decl_line":638,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio9set_panic28_$u7b$$u7b$closure$u7d$$u7d$17h6cc7bfcf2c3a85f8E","name":"{{closure}}","decl_file":63,"decl_line":640,"inline":"inlined"}]},{"tag":"namespace","name":"set_print","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio9set_print28_$u7b$$u7b$closure$u7d$$u7d$17h06b57d4780f7ccf6E","name":"{{closure}}","decl_file":63,"decl_line":661,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio9set_print28_$u7b$$u7b$closure$u7d$$u7d$17hebdc7584430a2256E","name":"{{closure}}","decl_file":63,"decl_line":663,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to17h2350d35e021a162cE","name":"print_to<std::io::stdio::Stdout>","decl_file":63,"decl_line":679,"inline":"inlined"},{"tag":"namespace","name":"print_to","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to28_$u7b$$u7b$closure$u7d$$u7d$17ha2fc59017ccd2bb8E","name":"{{closure}}<std::io::stdio::Stdout>","decl_file":63,"decl_line":688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to28_$u7b$$u7b$closure$u7d$$u7d$17hdc50c945a18b4d14E","name":"{{closure}}<std::io::stdio::Stdout>","decl_file":63,"decl_line":695,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to28_$u7b$$u7b$closure$u7d$$u7d$17h41a902eeba336be8E","name":"{{closure}}<std::io::stdio::Stderr>","decl_file":63,"decl_line":688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to28_$u7b$$u7b$closure$u7d$$u7d$17h3b5ada0c76be73eeE","name":"{{closure}}<std::io::stdio::Stderr>","decl_file":63,"decl_line":695,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io5stdio8print_to17h37b804a2f74a7e29E","name":"print_to<std::io::stdio::Stderr>","decl_file":63,"decl_line":679,"inline":"inlined"}]},{"tag":"namespace","name":"buffered","children":[{"tag":"structure_type","name":"LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"inner","type":"BufWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","alignment":4,"data_member_location":0},{"tag":"member","name":"need_flush","type":"bool","alignment":1,"data_member_location":16},{"tag":"subprogram","linkage_name":"_ZN47_$LT$std..io..buffered..LineWriter$LT$W$GT$$GT$13with_capacity17h84befdae1276d53cE","name":"with_capacity<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":798,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$std..io..buffered..LineWriter$LT$W$GT$$GT$3new17h1e74cd909d77a8a2E","name":"new<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":777,"inline":"inlined"}]},{"tag":"structure_type","name":"BufWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Option<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","alignment":1,"data_member_location":12},{"tag":"member","name":"buf","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"panicked","type":"bool","alignment":1,"data_member_location":13},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..io..buffered..BufWriter$LT$W$GT$$GT$9flush_buf17h391263a18a068e70E","name":"flush_buf<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":467,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..io..buffered..BufWriter$LT$W$GT$$GT$13with_capacity17h0defe64848c4756cE","name":"with_capacity<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":459,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..io..buffered..BufWriter$LT$W$GT$$GT$7get_mut17h18fec3ba2774bb1aE","name":"get_mut<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":526,"inline":"inlined"}]},{"tag":"structure_type","name":"BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Maybe","alignment":1,"data_member_location":16},{"tag":"member","name":"buf","type":"alloc::boxed::Box<[u8]>","alignment":4,"data_member_location":0},{"tag":"member","name":"pos","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":12}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN79_$LT$std..io..buffered..BufWriter$LT$W$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h4f5440d887590ed5E","name":"drop<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":598,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..io..buffered..BufReader$LT$R$GT$$u20$as$u20$std..io..BufRead$GT$8fill_buf17h6ace6b544c96b7e0E","name":"fill_buf<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>","decl_file":64,"decl_line":256,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..io..buffered..BufReader$LT$R$GT$$u20$as$u20$std..io..BufRead$GT$7consume17h4a2b7b3b93078b06E","name":"consume<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>","decl_file":64,"decl_line":269,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$std..io..buffered..BufReader$LT$R$GT$$u20$as$u20$std..io..Read$GT$4read17h83255d46fb519b92E","name":"read<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>","decl_file":64,"decl_line":233,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN72_$LT$std..io..buffered..BufWriter$LT$W$GT$$u20$as$u20$std..io..Write$GT$5flush17haa8e1dbefb302f3dE","name":"flush<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":571,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$std..io..buffered..LineWriter$LT$W$GT$$u20$as$u20$std..io..Write$GT$5flush17h1c13d5193111fa58E","name":"flush<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":919,"inline":"inlined"},{"tag":"namespace","name":"flush","children":[{"tag":"subprogram","linkage_name":"_ZN72_$LT$std..io..buffered..BufWriter$LT$W$GT$$u20$as$u20$std..io..Write$GT$5flush28_$u7b$$u7b$closure$u7d$$u7d$17haf8eae57ed85955dE","name":"{{closure}}<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":572,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN73_$LT$std..io..buffered..LineWriter$LT$W$GT$$u20$as$u20$std..io..Write$GT$5write17h6c17eec06c8488beE","name":"write<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":883,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN72_$LT$std..io..buffered..BufWriter$LT$W$GT$$u20$as$u20$std..io..Write$GT$5write17h5b86ab72fb8a0ba4E","name":"write<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","decl_file":64,"decl_line":558,"inline":"inlined"}]}]},{"tag":"namespace","name":"lazy","children":[{"tag":"structure_type","name":"Lazy<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"lock","type":"Mutex","alignment":1,"data_member_location":4},{"tag":"member","name":"ptr","type":"Cell<*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$3get17hf5f246f5395bd1d3E","name":"get<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":65,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init17hebd6e1a799b43773E","name":"init<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":65,"decl_line":53,"inline":"inlined"}]},{"tag":"structure_type","name":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"lock","type":"Mutex","alignment":1,"data_member_location":4},{"tag":"member","name":"ptr","type":"Cell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$3get17h68f2fad5fca45606E","name":"get<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":65,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init17h446aa63f178631f4E","name":"init<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":65,"decl_line":53,"inline":"inlined"}]},{"tag":"structure_type","name":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"lock","type":"Mutex","alignment":1,"data_member_location":4},{"tag":"member","name":"ptr","type":"Cell<*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$3get17hb5304161c4af1349E","name":"get<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":65,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init17h77451bdb75c39d98E","name":"init<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":65,"decl_line":53,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"init","children":[{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init28_$u7b$$u7b$closure$u7d$$u7d$17h646bb9395efe1cd3E","name":"{{closure}}<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","decl_file":65,"decl_line":58,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init28_$u7b$$u7b$closure$u7d$$u7d$17hebf009b997fb9622E","name":"{{closure}}<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","decl_file":65,"decl_line":58,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN37_$LT$std..io..lazy..Lazy$LT$T$GT$$GT$4init28_$u7b$$u7b$closure$u7d$$u7d$17hc670aa07992b19b5E","name":"{{closure}}<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","decl_file":65,"decl_line":58,"inline":"inlined"}]}]}]},{"tag":"structure_type","name":"Box<Write>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io5impls80_$LT$impl$u20$std..io..Write$u20$for$u20$$RF$$u27$a$u20$mut$u20$$u5b$u8$u5d$$GT$5write17h2aa9444d00cf63b2E","name":"write","decl_file":66,"decl_line":236,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5impls71_$LT$impl$u20$std..io..Read$u20$for$u20$$RF$$u27$a$u20$$u5b$u8$u5d$$GT$4read17h497d4914d7b78ba8E","name":"read","decl_file":66,"decl_line":167,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5impls70_$LT$impl$u20$std..io..Write$u20$for$u20$alloc..vec..Vec$LT$u8$GT$$GT$5write17h957c7ca71aa6cec6E","name":"write","decl_file":66,"decl_line":262,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5impls71_$LT$impl$u20$std..io..Write$u20$for$u20$alloc..boxed..Box$LT$W$GT$$GT$5flush17hd391fbfeb17ffc25E","name":"flush<Write>","decl_file":66,"decl_line":121,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io5impls71_$LT$impl$u20$std..io..Write$u20$for$u20$alloc..boxed..Box$LT$W$GT$$GT$9write_fmt17h30b38cc10d1411c2E","name":"write_fmt<Write>","decl_file":66,"decl_line":129,"inline":"inlined"}]}]},{"tag":"namespace","name":"cursor","children":[{"tag":"namespace","name":"vec_write","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io6cursor9vec_write28_$u7b$$u7b$closure$u7d$$u7d$17ha9d9c12fa502cf2eE","name":"{{closure}}","decl_file":67,"decl_line":266,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"util","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"subprogram","linkage_name":"_ZN3std2io10read_until17h1e011958c72122abE","name":"read_until<std::io::stdio::StdinLock>","decl_file":61,"decl_line":1252,"inline":"inlined"},{"tag":"namespace","name":"BufRead","children":[{"tag":"namespace","name":"read_line","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io7BufRead9read_line28_$u7b$$u7b$closure$u7d$$u7d$17hf49db0437f1541b9E","name":"{{closure}}<std::io::stdio::StdinLock>","decl_file":61,"decl_line":1519,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io7BufRead9read_line17hf6f52f5f1e5a0753E","name":"read_line<std::io::stdio::StdinLock>","decl_file":61,"decl_line":1515,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io16append_to_string17hbcae159517fabc44E","name":"append_to_string<closure>","decl_file":61,"decl_line":335,"inline":"inlined"},{"tag":"namespace","name":"append_to_string","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io16append_to_string28_$u7b$$u7b$closure$u7d$$u7d$17h50fded7a6958ed31E","name":"{{closure}}<closure>","decl_file":61,"decl_line":342,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io16append_to_string28_$u7b$$u7b$closure$u7d$$u7d$17had540f15d4cf0f50E","name":"{{closure}}<closure>","decl_file":61,"decl_line":342,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN70_$LT$std..io..Guard$LT$$u27$a$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h38dc5684a5a07f27E","name":"drop","decl_file":61,"decl_line":312,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"Read","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io4Read11read_to_end17hb609539f843c8552E","name":"read_to_end<std::io::stdio::StdinLock>","decl_file":61,"decl_line":608,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io4Read14read_to_string17h80b4eaf5ff807d11E","name":"read_to_string<std::io::stdio::StdinLock>","decl_file":61,"decl_line":651,"inline":"inlined"},{"tag":"namespace","name":"read_to_string","children":[{"tag":"subprogram","linkage_name":"_ZN3std2io4Read14read_to_string28_$u7b$$u7b$closure$u7d$$u7d$17he6ea526461331bceE","name":"{{closure}}<std::io::stdio::StdinLock>","decl_file":61,"decl_line":661,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io4Read10read_exact17he471a17f230310b9E","name":"read_exact<std::io::stdio::StdinLock>","decl_file":61,"decl_line":714,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2io16append_to_string17ha26e5da711415320E","name":"append_to_string<closure>","decl_file":61,"decl_line":335,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2io28read_to_end_with_reservation17hde26a4f5a72fdbf5E","name":"read_to_end_with_reservation<std::io::stdio::StdinLock>","decl_file":61,"decl_line":366,"inline":"inlined"}]},{"tag":"namespace","name":"sys","children":[{"tag":"namespace","name":"wasm","children":[{"tag":"namespace","name":"stdio","children":[{"tag":"structure_type","name":"Stderr","byte_size":0,"alignment":1,"children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm5stdio6Stderr5write17h3487e92f36d812b4E","name":"write","decl_file":68,"decl_line":48,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm5stdio6Stderr5flush17h80223a2f1a95c20cE","name":"flush","decl_file":68,"decl_line":53,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sys..wasm..stdio..Stderr$u20$as$u20$std..io..Write$GT$5write17ha3f1872555bb6fcfE","name":"write","decl_file":68,"decl_line":59,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sys..wasm..stdio..Stderr$u20$as$u20$std..io..Write$GT$5flush17hef44bdec6a49237bE","name":"flush","decl_file":68,"decl_line":62,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Stdin","byte_size":0,"alignment":1,"children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm5stdio5Stdin4read17hb24e64859b8c2543E","name":"read","decl_file":68,"decl_line":23,"inline":"inlined"}]}]},{"tag":"namespace","name":"mutex","children":[{"tag":"structure_type","name":"ReentrantMutex","byte_size":0,"alignment":1,"children":[]},{"tag":"structure_type","name":"Mutex","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"locked","type":"UnsafeCell<bool>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm5mutex5Mutex4lock17h36de9d64de6c684bE","name":"lock","decl_file":69,"decl_line":30,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm5mutex5Mutex6unlock17h4e721edf22ba59f3E","name":"unlock","decl_file":69,"decl_line":37,"inline":"inlined"}]}]},{"tag":"namespace","name":"os_str","children":[{"tag":"structure_type","name":"Slice","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"u8[]","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str5Slice6to_str17h747aeb139ef78cbcE","name":"to_str","decl_file":70,"decl_line":155,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str5Slice15to_string_lossy17hc096a3b2707c6a34E","name":"to_string_lossy","decl_file":70,"decl_line":159,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str5Slice8to_owned17h791872d7885e88d5E","name":"to_owned","decl_file":70,"decl_line":163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str5Slice8into_box17h183da25a2c7c976bE","name":"into_box","decl_file":70,"decl_line":168,"inline":"inlined"}]},{"tag":"structure_type","name":"Buf","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf8as_slice17h7c2cc25ecf3ca568E","name":"as_slice","decl_file":70,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf11into_string17h2714943ed0faf5b8E","name":"into_string","decl_file":70,"decl_line":116,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf13with_capacity17hb29e9aab5a2f9fffE","name":"with_capacity","decl_file":70,"decl_line":76,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf5clear17h0248348253c06b13E","name":"clear","decl_file":70,"decl_line":83,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf8capacity17ha1dcd48960f930cbE","name":"capacity","decl_file":70,"decl_line":88,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf7reserve17he0a110a2b84e8719E","name":"reserve","decl_file":70,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf13reserve_exact17h1f2119642825005eE","name":"reserve_exact","decl_file":70,"decl_line":98,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf13shrink_to_fit17h6e9c50d24b0aecb2E","name":"shrink_to_fit","decl_file":70,"decl_line":103,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf8into_box17h1416b3edce781335E","name":"into_box","decl_file":70,"decl_line":125,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf10push_slice17h46b86d5809e8ca63E","name":"push_slice","decl_file":70,"decl_line":120,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"into_string","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6os_str3Buf11into_string28_$u7b$$u7b$closure$u7d$$u7d$17h2bff7e14fdc43e22E","name":"{{closure}}","decl_file":70,"decl_line":117,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN68_$LT$std..sys..wasm..os_str..Slice$u20$as$u20$core..fmt..Display$GT$3fmt17h13a943453e129dbaE","name":"fmt","decl_file":70,"decl_line":40,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"pipe","children":[{"tag":"structure_type","name":"AnonPipe","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Void","byte_size":0,"alignment":1,"children":[{"tag":"variant_part"}]},{"tag":"namespace","name":"time","children":[{"tag":"structure_type","name":"SystemTime","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time10SystemTime8sub_time17h62b388b76c64379cE","name":"sub_time","decl_file":71,"decl_line":45,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time10SystemTime12add_duration17h888dbc568c7abcdaE","name":"add_duration","decl_file":71,"decl_line":50,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time10SystemTime12sub_duration17h5f140d1e4e5e88f5E","name":"sub_duration","decl_file":71,"decl_line":54,"inline":"inlined"}]},{"tag":"structure_type","name":"Instant","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time7Instant11sub_instant17h7f97af39301f037eE","name":"sub_instant","decl_file":71,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time7Instant12add_duration17h588c1e4fa54e96d9E","name":"add_duration","decl_file":71,"decl_line":31,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time7Instant12sub_duration17h02f62e6d675318b7E","name":"sub_duration","decl_file":71,"decl_line":35,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN66_$LT$std..sys..wasm..time..Instant$u20$as$u20$core..fmt..Debug$GT$3fmt17h78eb52623e06c2ecE","name":"fmt","decl_file":71,"decl_line":14,"external":true,"inline":"inlined"},{"tag":"namespace","name":"sub_time","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4time10SystemTime8sub_time28_$u7b$$u7b$closure$u7d$$u7d$17h9e1e3ebf6ff10d21E","name":"{{closure}}","decl_file":71,"decl_line":47,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN69_$LT$std..sys..wasm..time..SystemTime$u20$as$u20$core..fmt..Debug$GT$3fmt17h12f740d9f88b5ea1E","name":"fmt","decl_file":71,"decl_line":17,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"fs","children":[{"tag":"structure_type","name":"FileType","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"FilePermissions","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ReadDir","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"OpenOptions","byte_size":0,"alignment":1},{"tag":"structure_type","name":"DirBuilder","byte_size":0,"alignment":1,"children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs10DirBuilder5mkdir17h3ecc097fc7d9d788E","name":"mkdir","decl_file":72,"decl_line":243,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN68_$LT$std..sys..wasm..fs..OpenOptions$u20$as$u20$core..fmt..Debug$GT$3fmt17hdb8f4d33386b3538E","name":"fmt","decl_file":72,"decl_line":27,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..sys..wasm..fs..DirBuilder$u20$as$u20$core..fmt..Debug$GT$3fmt17h36e2f88b2ad2da00E","name":"fmt","decl_file":72,"decl_line":34,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"File","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs4File4open17h0721568534a0462cE","name":"open","decl_file":72,"decl_line":189,"inline":"inlined"}]},{"tag":"structure_type","name":"FileAttr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"DirEntry","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs4stat17hf9d476b3f9fbca21E","name":"stat","decl_file":72,"decl_line":290,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs5lstat17ha2f60237607fae85E","name":"lstat","decl_file":72,"decl_line":294,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs12canonicalize17hd647ba009c80c718E","name":"canonicalize","decl_file":72,"decl_line":298,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2fs8readlink17h695716dc73a83f35E","name":"readlink","decl_file":72,"decl_line":278,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"process","children":[{"tag":"structure_type","name":"ExitStatus","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ExitCode","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"bool","alignment":1,"data_member_location":0}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Stdio","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Inherit","const_value":0},{"tag":"enumerator","name":"Null","const_value":1},{"tag":"enumerator","name":"MakePipe","const_value":2}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN70_$LT$std..sys..wasm..process..ExitCode$u20$as$u20$core..fmt..Debug$GT$3fmt17haab1aa769673d3cbE","name":"fmt","decl_file":73,"decl_line":132,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Command","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"env","type":"CommandEnv<std::sys_common::process::DefaultEnvKey>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Process","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"rwlock","children":[{"tag":"structure_type","name":"RWLock","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"mode","type":"UnsafeCell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6rwlock6RWLock5write17he5b21528a2b04009E","name":"write","decl_file":27,"decl_line":49,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6rwlock6RWLock12write_unlock17h067d158f572f5585E","name":"write_unlock","decl_file":27,"decl_line":75,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6rwlock6RWLock4read17h84d7e980e2d60e65E","name":"read","decl_file":27,"decl_line":28,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6rwlock6RWLock11read_unlock17h98fcc9aaafa7b7d6E","name":"read_unlock","decl_file":27,"decl_line":70,"inline":"inlined"}]}]},{"tag":"namespace","name":"os","children":[{"tag":"structure_type","name":"JoinPathsError","byte_size":0,"alignment":1},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN71_$LT$std..sys..wasm..os..JoinPathsError$u20$as$u20$core..fmt..Debug$GT$3fmt17h4dc76ae9d52ee81eE","name":"fmt","decl_file":74,"decl_line":48,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$std..sys..wasm..os..JoinPathsError$u20$as$u20$core..fmt..Display$GT$3fmt17h02a6aab5fab0e041E","name":"fmt","decl_file":74,"decl_line":58,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os6getcwd17h45510231ddb78cd1E","name":"getcwd","decl_file":74,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os6getenv17h876403c1bdd48bc4E","name":"getenv","decl_file":74,"decl_line":86,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os8home_dir17h3acef91ddeb991a3E","name":"home_dir","decl_file":74,"decl_line":102,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os11current_exe17h373002ec77543ac6E","name":"current_exe","decl_file":74,"decl_line":69,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os12error_string17h94397c66b9aeffd6E","name":"error_string","decl_file":74,"decl_line":23,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm2os4exit17h8e0b8d6ef42152aeE","name":"exit","decl_file":74,"decl_line":106,"noreturn":true,"inline":"inlined"}]},{"tag":"namespace","name":"net","children":[{"tag":"namespace","name":"netc","children":[{"tag":"structure_type","name":"in6_addr","byte_size":16,"alignment":1,"children":[{"tag":"member","name":"s6_addr","type":"u8[]","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"in_addr","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"s_addr","type":"u32","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"sockaddr_in6","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"sin6_family","type":"u8","alignment":1,"data_member_location":10},{"tag":"member","name":"sin6_port","type":"u16","alignment":2,"data_member_location":8},{"tag":"member","name":"sin6_addr","type":"in6_addr","alignment":1,"data_member_location":11},{"tag":"member","name":"sin6_flowinfo","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"sin6_scope_id","type":"u32","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"sockaddr_in","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"sin_family","type":"u8","alignment":1,"data_member_location":6},{"tag":"member","name":"sin_port","type":"u16","alignment":2,"data_member_location":4},{"tag":"member","name":"sin_addr","type":"in_addr","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"TcpListener","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm3net11lookup_host17hfb1816354c5e321eE","name":"lookup_host","decl_file":75,"decl_line":296,"inline":"inlined"},{"tag":"structure_type","name":"TcpStream","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm3net9TcpStream15connect_timeout17h3f25eb6aee766d24E","name":"connect_timeout","decl_file":75,"decl_line":24,"inline":"inlined"}]},{"tag":"structure_type","name":"UdpSocket","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"condvar","children":[{"tag":"structure_type","name":"Condvar","byte_size":0,"alignment":1,"children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm7condvar7Condvar12wait_timeout17h5aacb5e5a5c6f601E","name":"wait_timeout","decl_file":76,"decl_line":36,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"perform","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11ArgsSysCall7perform28_$u7b$$u7b$closure$u7d$$u7d$17h61752473d7312aedE","name":"{{closure}}","decl_file":21,"decl_line":222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11ArgsSysCall7perform28_$u7b$$u7b$closure$u7d$$u7d$17h8736c180ddb36702E","name":"{{closure}}","decl_file":21,"decl_line":223,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm14receive_buffer17hdc5fc9bcaac6718bE","name":"receive_buffer<(),closure>","decl_file":21,"decl_line":185,"inline":"inlined"},{"tag":"structure_type","name":"GetEnvSysCall","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"key_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"key_len","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"value_ptr","type":"*mut u8","alignment":4,"data_member_location":8},{"tag":"member","name":"value_len","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"result","type":"usize","alignment":4,"data_member_location":16},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm13GetEnvSysCall7perform17haa0f255b75f58a0fE","name":"perform","decl_file":21,"decl_line":238,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm14receive_buffer17hfbf8e05988d1f089E","name":"receive_buffer<!,closure>","decl_file":21,"decl_line":185,"inline":"inlined"},{"tag":"structure_type","name":"ArgsSysCall","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*mut u8","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"result","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11ArgsSysCall7perform17h1969c0b059bff634E","name":"perform","decl_file":21,"decl_line":208,"inline":"inlined"}]},{"tag":"namespace","name":"args","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4args4args17hf4ed4869c941d212E","name":"args","decl_file":77,"decl_line":23,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN77_$LT$std..sys..wasm..args..Args$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha5de9ec812daa343E","name":"next","decl_file":77,"decl_line":44,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$std..sys..wasm..args..Args$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17h75e0b6c713e07c41E","name":"size_hint","decl_file":77,"decl_line":47,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$std..sys..wasm..args..Args$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17hf95aa846e7a4e855E","name":"len","decl_file":77,"decl_line":53,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$std..sys..wasm..args..Args$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h02e9207370196a82E","name":"next_back","decl_file":77,"decl_line":59,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Args","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"iter","type":"IntoIter<std::ffi::os_str::OsString>","alignment":4,"data_member_location":0},{"tag":"member","name":"_dont_send_or_sync_me","type":"PhantomData<*mut ()>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4args4Args11inner_debug17hfdebeae2f101b3f2E","name":"inner_debug","decl_file":77,"decl_line":37,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm6strlen17h2dce0d1cf54ea8bdE","name":"strlen","decl_file":21,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm15unsupported_err17h67e961e7d1962ae5E","name":"unsupported_err","decl_file":21,"decl_line":79,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17ha9e0f437fc2e3dc0E","name":"unsupported<std::sys::wasm::fs::File>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"namespace","name":"path","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm4path11is_sep_byte17h89660c1beb61cbbdE","name":"is_sep_byte","decl_file":78,"decl_line":15,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17hcecf10b016decce8E","name":"unsupported<std::sys::wasm::net::LookupHost>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"structure_type","name":"ExitSysCall","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"code","type":"usize","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11ExitSysCall7perform17h446076bfafe1ac52E","name":"perform","decl_file":21,"decl_line":174,"noreturn":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm14abort_internal17had2d0e68a83fe0edE","name":"abort_internal","decl_file":21,"decl_line":102,"noreturn":true,"inline":"inlined"},{"tag":"namespace","name":"thread_local","children":[{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm12thread_local6create17h08f765ad64c77310E","name":"create","decl_file":79,"decl_line":22,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm12thread_local7destroy17hc4aac5abb5759246E","name":"destroy","decl_file":79,"decl_line":40,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17hf3243ad2769e625dE","name":"unsupported<std::sys::wasm::fs::ReadDir>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17h1646c757da8e5c3aE","name":"unsupported<u64>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17h476f6a2efc067892E","name":"unsupported<std::sys::wasm::net::TcpListener>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3sys4wasm11unsupported17ha7dd054a506da8bfE","name":"unsupported<std::sys::wasm::thread::Thread>","decl_file":21,"decl_line":75,"inline":"inlined"},{"tag":"namespace","name":"thread","children":[{"tag":"structure_type","name":"Thread","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Void","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"guard","children":[]}]},{"tag":"structure_type","name":"TimeSysCall","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"clock","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"secs_hi","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"secs_lo","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"nanos","type":"usize","alignment":4,"data_member_location":12}]}]}]},{"tag":"namespace","name":"error","children":[{"tag":"structure_type","name":"Box<Error>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"from","children":[{"tag":"structure_type","name":"StringError","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"subprogram","linkage_name":"_ZN3std5error229_$LT$impl$u20$core..convert..From$LT$alloc..string..String$GT$$u20$for$u20$alloc..boxed..Box$LT$$LP$dyn$u20$std..error..Error$u20$$u2b$$u20$core..marker..Sync$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$static$RP$$GT$$GT$4from17h1c9cac6ac3a95b39E","name":"from","decl_file":80,"decl_line":311,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std5error163_$LT$impl$u20$core..convert..From$LT$alloc..string..String$GT$$u20$for$u20$alloc..boxed..Box$LT$$LP$dyn$u20$std..error..Error$u20$$u2b$$u20$$u27$static$RP$$GT$$GT$4from17h9ccf6e6f7a69e6d7E","name":"from","decl_file":80,"decl_line":343,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std5error221_$LT$impl$u20$core..convert..From$LT$$RF$$u27$b$u20$str$GT$$u20$for$u20$alloc..boxed..Box$LT$$LP$dyn$u20$std..error..Error$u20$$u2b$$u20$core..marker..Sync$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$a$RP$$GT$$GT$4from17h772867bcc14550c3E","name":"from","decl_file":80,"decl_line":365,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"Error","children":[]}]},{"tag":"namespace","name":"sys_common","children":[{"tag":"namespace","name":"remutex","children":[{"tag":"structure_type","name":"ReentrantMutexGuard<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__lock","type":"&std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"__poison","type":"Guard","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN81_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$mutex$C$$u20$T$GT$$GT$3new17h959c3f72709f7055E","name":"new<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":81,"decl_line":140,"inline":"inlined"}]},{"tag":"structure_type","name":"ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys::wasm::mutex::ReentrantMutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":28},{"tag":"member","name":"data","type":"RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..sys_common..remutex..ReentrantMutex$LT$T$GT$$GT$4lock17h94868ac1373595d4E","name":"lock<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":81,"decl_line":85,"inline":"inlined"}]},{"tag":"structure_type","name":"ReentrantMutexGuard<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__lock","type":"&std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"__poison","type":"Guard","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN81_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$mutex$C$$u20$T$GT$$GT$3new17hed0797f361c91b94E","name":"new<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","decl_file":81,"decl_line":140,"inline":"inlined"}]},{"tag":"structure_type","name":"ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys::wasm::mutex::ReentrantMutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":12},{"tag":"member","name":"data","type":"RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..sys_common..remutex..ReentrantMutex$LT$T$GT$$GT$4lock17h149c3ec5b37182d4E","name":"lock<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","decl_file":81,"decl_line":85,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN116_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$mutex$C$$u20$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hbf4911760ecc74ecE","name":"deref<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","decl_file":81,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN110_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h0f79632e48c5ef9bE","name":"drop<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":81,"decl_line":161,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN116_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$mutex$C$$u20$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hef6c189812ecddd4E","name":"deref<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","decl_file":81,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN110_$LT$std..sys_common..remutex..ReentrantMutexGuard$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h725d6aa0b0af94cbE","name":"drop<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","decl_file":81,"decl_line":161,"inline":"inlined"},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]}]},{"tag":"namespace","name":"poison","children":[{"tag":"structure_type","name":"Flag","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"failed","type":"AtomicBool","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6poison4Flag6borrow17hf3a1e4fbdf2e2693E","name":"borrow","decl_file":82,"decl_line":35,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6poison4Flag3get17h8b0de80852226f74E","name":"get","decl_file":82,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6poison4Flag4done17hbc9aee2a864e898dE","name":"done","decl_file":82,"decl_line":45,"inline":"inlined"}]},{"tag":"structure_type","name":"Guard","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"panicking","type":"bool","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"PoisonError<std::sync::mutex::MutexGuard<()>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"guard","type":"MutexGuard<()>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"PoisonError<std::sync::mutex::MutexGuard<std::sync::barrier::BarrierState>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"guard","type":"MutexGuard<std::sync::barrier::BarrierState>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"mutex","children":[{"tag":"structure_type","name":"Mutex","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Mutex","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common5mutex5Mutex8raw_lock17h2a98a103886d5e42E","name":"raw_lock","decl_file":83,"decl_line":46,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common5mutex5Mutex4lock17h187a6699a2f12063E","name":"lock","decl_file":83,"decl_line":51,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common5mutex5Mutex10raw_unlock17h47aa10fbbe172928E","name":"raw_unlock","decl_file":83,"decl_line":72,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN90_$LT$std..sys_common..mutex..MutexGuard$LT$$u27$a$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h169b2a87a3a00274E","name":"drop","decl_file":83,"decl_line":91,"inline":"inlined"}]}]},{"tag":"namespace","name":"at_exit_imp","children":[{"tag":"variable","name":"LOCK","type":"Mutex","decl_file":84,"decl_line":28,"location":"03000000000610011E1000229F // DW_OP_addr 0x0, DW_OP_deref, DW_OP_constu 0x1, DW_OP_mul, DW_OP_constu 0x0, DW_OP_plus, DW_OP_stack_value","linkage_name":"_ZN3std10sys_common11at_exit_imp4LOCK17hc473e57c7251016fE"},{"tag":"variable","name":"QUEUE","type":"*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>","decl_file":84,"decl_line":29,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std10sys_common11at_exit_imp5QUEUE17hf22a57ef3ccc22b7E"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11at_exit_imp7cleanup17h6496a00ffbd97631E","name":"cleanup","decl_file":84,"decl_line":51,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11at_exit_imp4init17hed493bf299b5198dE","name":"init","decl_file":84,"decl_line":39,"inline":"inlined"}]},{"tag":"namespace","name":"backtrace","children":[{"tag":"namespace","name":"print","children":[{"tag":"variable","name":"LOCK","type":"Mutex","decl_file":85,"decl_line":53,"linkage_name":"_ZN3std10sys_common9backtrace5print4LOCK17h28eb5748e33ee4fcE"}]},{"tag":"namespace","name":"log_enabled","children":[{"tag":"variable","name":"ENABLED","type":"AtomicIsize","decl_file":85,"decl_line":151,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std10sys_common9backtrace11log_enabled7ENABLED17hddaae6663bbe8e98E"}]},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common9backtrace11log_enabled17hec93a7bd17fc6438E","name":"log_enabled","decl_file":85,"decl_line":150,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"thread","children":[{"tag":"namespace","name":"min_stack","children":[{"tag":"variable","name":"MIN","type":"AtomicUsize","decl_file":86,"decl_line":28,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std10sys_common6thread9min_stack3MIN17h29e086eb8ff019eeE"}]}]},{"tag":"namespace","name":"thread_local","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"lazy_init","children":[{"tag":"variable","name":"INIT_LOCK","type":"Mutex","decl_file":87,"decl_line":166,"linkage_name":"_ZN3std10sys_common12thread_local9StaticKey9lazy_init9INIT_LOCK17h7b2b1b7f48937736E"}]}]},{"tag":"namespace","name":"register_dtor_fallback","children":[{"tag":"variable","name":"DTORS","type":"StaticKey","decl_file":87,"decl_line":254,"linkage_name":"_ZN3std10sys_common12thread_local22register_dtor_fallback5DTORS17h7f3e99ddeabf0f33E"}]},{"tag":"structure_type","name":"StaticKey","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"key","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"dtor","type":"Option<unsafe extern \"C\" fn(*mut u8)>","alignment":4,"data_member_location":4}]}]},{"tag":"namespace","name":"cleanup","children":[{"tag":"variable","name":"CLEANUP","type":"Once","decl_file":88,"decl_line":116,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std10sys_common7cleanup7CLEANUP17h52918013e55590eaE"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7cleanup28_$u7b$$u7b$closure$u7d$$u7d$17h464904d52778ec2dE","name":"{{closure}}","decl_file":88,"decl_line":117,"inline":"inlined"}]},{"tag":"namespace","name":"rwlock","children":[{"tag":"structure_type","name":"RWLock","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"RWLock","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6rwlock6RWLock5write17hd61e82868a544c33E","name":"write","decl_file":89,"decl_line":51,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6rwlock6RWLock12write_unlock17hfd59203c77698652E","name":"write_unlock","decl_file":89,"decl_line":74,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6rwlock6RWLock4read17hf647c9113ce8cc73E","name":"read","decl_file":89,"decl_line":33,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common6rwlock6RWLock11read_unlock17hf4c10452374d4c6bE","name":"read_unlock","decl_file":89,"decl_line":67,"inline":"inlined"}]}]},{"tag":"namespace","name":"thread_info","children":[{"tag":"namespace","name":"THREAD_INFO","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","decl_file":24,"decl_line":177,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std10sys_common11thread_info11THREAD_INFO7__getit5__KEY17hcdbbdd0ee9c0e2eaE"}]}]},{"tag":"structure_type","name":"ThreadInfo","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"stack_guard","type":"Option<!>","alignment":1,"data_member_location":0},{"tag":"member","name":"thread","type":"Thread","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info10ThreadInfo4with17hf302cfe7143b239cE","name":"with<std::thread::Thread,closure>","decl_file":90,"decl_line":25,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"with","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info10ThreadInfo4with28_$u7b$$u7b$closure$u7d$$u7d$17he69e9d7fa406df8dE","name":"{{closure}}<std::thread::Thread,closure>","decl_file":90,"decl_line":26,"inline":"inlined"}]}]},{"tag":"namespace","name":"current_thread","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info14current_thread28_$u7b$$u7b$closure$u7d$$u7d$17h8b49356adbd058f8E","name":"{{closure}}","decl_file":90,"decl_line":39,"inline":"inlined"}]},{"tag":"namespace","name":"set","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info3set28_$u7b$$u7b$closure$u7d$$u7d$17h3c3f2b69a9c9e0bfE","name":"{{closure}}","decl_file":90,"decl_line":47,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info3set28_$u7b$$u7b$closure$u7d$$u7d$17h662c2fd8de936677E","name":"{{closure}}","decl_file":90,"decl_line":48,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info3set17h9eaedeb2026719baE","name":"set","decl_file":90,"decl_line":46,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info11reset_guard17heea958bb3330b753E","name":"reset_guard","decl_file":90,"decl_line":54,"inline":"inlined"},{"tag":"namespace","name":"reset_guard","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common11thread_info11reset_guard28_$u7b$$u7b$closure$u7d$$u7d$17h923e4dfadfdb0577E","name":"{{closure}}","decl_file":90,"decl_line":55,"inline":"inlined"}]}]},{"tag":"namespace","name":"condvar","children":[{"tag":"structure_type","name":"Condvar","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Condvar","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7condvar7Condvar12wait_timeout17h825bff518faa9efaE","name":"wait_timeout","decl_file":91,"decl_line":60,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7at_exit17hfb02362cec0ce31eE","name":"at_exit<closure>","decl_file":88,"decl_line":110,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7at_exit17h57deac26df857a2bE","name":"at_exit<closure>","decl_file":88,"decl_line":110,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7at_exit17h7204faac5b09375fE","name":"at_exit<closure>","decl_file":88,"decl_line":110,"inline":"inlined"},{"tag":"namespace","name":"process","children":[{"tag":"structure_type","name":"CommandEnv<std::sys_common::process::DefaultEnvKey>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"clear","type":"bool","alignment":1,"data_member_location":12},{"tag":"member","name":"saw_path","type":"bool","alignment":1,"data_member_location":13},{"tag":"member","name":"vars","type":"BTreeMap<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN54_$LT$std..sys_common..process..CommandEnv$LT$K$GT$$GT$5clear17hcfedde3f6a131fd0E","name":"clear<std::sys_common::process::DefaultEnvKey>","decl_file":92,"decl_line":124,"inline":"inlined"}]},{"tag":"structure_type","name":"DefaultEnvKey","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"OsString","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"util","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common4util5abort17h018fa7f4d29effb9E","name":"abort","decl_file":93,"decl_line":28,"external":true,"noreturn":true,"inline":"inlined"}]},{"tag":"namespace","name":"wtf8","children":[{"tag":"structure_type","name":"Wtf8Buf","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"bytes","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common4wtf87Wtf8Buf12as_mut_slice17hf00f7181f2a8d7bdE","name":"as_mut_slice","decl_file":94,"decl_line":230,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"write_str_escaped","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sys_common..wtf8..Wtf8$u20$as$u20$core..fmt..Debug$GT$3fmt17write_str_escaped28_$u7b$$u7b$closure$u7d$$u7d$17h2e162990706013fbE","name":"{{closure}}","decl_file":94,"decl_line":427,"inline":"inlined"}]}]}]},{"tag":"structure_type","name":"Wtf8","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"bytes","type":"u8[]","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common4wtf84Wtf814next_surrogate17h030ae505605fae51E","name":"next_surrogate","decl_file":94,"decl_line":597,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common4wtf816decode_surrogate17h2711d5f520021221E","name":"decode_surrogate","decl_file":94,"decl_line":749,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std10sys_common7cleanup17hc54cdb65bc218c43E","name":"cleanup","decl_file":88,"decl_line":115,"inline":"inlined"},{"tag":"namespace","name":"bytestring","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common10bytestring20debug_fmt_bytestring17h4940e33df23b6e21E","name":"debug_fmt_bytestring","decl_file":95,"decl_line":16,"inline":"inlined"},{"tag":"namespace","name":"debug_fmt_bytestring","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common10bytestring20debug_fmt_bytestring17write_str_escaped17h994d07b7ef290ec3E","name":"write_str_escaped","decl_file":95,"decl_line":18,"inline":"inlined"},{"tag":"namespace","name":"write_str_escaped","children":[{"tag":"subprogram","linkage_name":"_ZN3std10sys_common10bytestring20debug_fmt_bytestring17write_str_escaped28_$u7b$$u7b$closure$u7d$$u7d$17h08189ce9591db513E","name":"{{closure}}","decl_file":95,"decl_line":19,"inline":"inlined"}]}]}]}]},{"tag":"namespace","name":"ffi","children":[{"tag":"namespace","name":"os_str","children":[{"tag":"structure_type","name":"OsStr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"Slice","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str5OsStr12to_os_string17hc96c75553dfd25ccE","name":"to_os_string","decl_file":96,"decl_line":562,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str5OsStr7display17hf12648fee8eaa19cE","name":"display","decl_file":96,"decl_line":873,"inline":"inlined"}]},{"tag":"structure_type","name":"OsString","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Buf","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString11into_string17h68ebc4261ad9a8bfE","name":"into_string","decl_file":96,"decl_line":156,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString17into_boxed_os_str17h89af79aea89bd892E","name":"into_boxed_os_str","decl_file":96,"decl_line":346,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString4push17h86af76461373407cE","name":"push<&str>","decl_file":96,"decl_line":174,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString4push17h69741f6e2b3c6a41E","name":"push<&std::path::Path>","decl_file":96,"decl_line":174,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString4push17h582b5f819d8bafa1E","name":"push<&std::ffi::os_str::OsStr>","decl_file":96,"decl_line":174,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi6os_str8OsString5clear17h97e415ee80fa2937E","name":"clear","decl_file":96,"decl_line":220,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN60_$LT$std..ffi..os_str..OsStr$u20$as$u20$core..fmt..Debug$GT$3fmt17h216a1554e6c9747cE","name":"fmt","decl_file":96,"decl_line":867,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN105_$LT$std..ffi..os_str..OsString$u20$as$u20$core..ops..index..Index$LT$core..ops..range..RangeFull$GT$$GT$5index17h7f8dc4287e929059E","name":"index","decl_file":96,"decl_line":374,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$std..ffi..os_str..OsString$u20$as$u20$core..ops..deref..Deref$GT$5deref17h979e32ff420954acE","name":"deref","decl_file":96,"decl_line":384,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$std..ffi..os_str..OsString$u20$as$u20$core..fmt..Debug$GT$3fmt17h0d285ff65314b0f9E","name":"fmt","decl_file":96,"decl_line":400,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..ffi..os_str..OsStr$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17he96fb62abf28ecc6E","name":"partial_cmp","decl_file":96,"decl_line":789,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..ffi..os_str..OsStr$u20$as$u20$core..cmp..PartialEq$GT$2eq17hcca3c59ca3a29b1aE","name":"eq","decl_file":96,"decl_line":764,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..ffi..os_str..OsStr$u20$as$u20$core..cmp..Ord$GT$3cmp17hc012278a7a12771dE","name":"cmp","decl_file":96,"decl_line":816,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..ffi..os_str..OsStr$u20$as$u20$core..cmp..PartialEq$LT$str$GT$$GT$2eq17hbf4d8f22d88bb1bfE","name":"eq","decl_file":96,"decl_line":771,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$std..ffi..os_str..OsString$u20$as$u20$core..convert..AsRef$LT$std..ffi..os_str..OsStr$GT$$GT$6as_ref17h628d866280e0408cE","name":"as_ref","decl_file":96,"decl_line":904,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$std..ffi..os_str..OsStr$u20$as$u20$alloc..borrow..ToOwned$GT$10clone_into17h663cba40ad0c0a53E","name":"clone_into","decl_file":96,"decl_line":889,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$std..ffi..os_str..OsString$u20$as$u20$core..borrow..Borrow$LT$std..ffi..os_str..OsStr$GT$$GT$6borrow17h8da5e3e4ca6d8ea0E","name":"borrow","decl_file":96,"decl_line":880,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"c_str","children":[{"tag":"structure_type","name":"FromBytesWithNulErrorKind","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":92566,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"InteriorNul","type":"InteriorNul","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"NotNulTerminated","type":"NotNulTerminated","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"InteriorNul","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NotNulTerminated","byte_size":8,"alignment":4}]},{"tag":"structure_type","name":"CString","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"alloc::boxed::Box<[u8]>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str7CString17as_bytes_with_nul17h7b9fec7319a3fce6E","name":"as_bytes_with_nul","decl_file":97,"decl_line":563,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str7CString3new17h418c85feb09dccdcE","name":"new<alloc::string::String>","decl_file":97,"decl_line":331,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str7CString4_new17h41a746d70f0dbbcbE","name":"_new","decl_file":97,"decl_line":335,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str7CString10into_bytes17h27f5273ad9cd67a6E","name":"into_bytes","decl_file":97,"decl_line":497,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN66_$LT$std..ffi..c_str..CString$u20$as$u20$core..ops..drop..Drop$GT$4drop17ha95a5ca954cdd61cE","name":"drop","decl_file":97,"decl_line":624,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$std..ffi..c_str..CString$u20$as$u20$core..ops..deref..Deref$GT$5deref17h9b6f0f138c647ac3E","name":"deref","decl_file":97,"decl_line":634,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN61_$LT$std..ffi..c_str..CString$u20$as$u20$core..fmt..Debug$GT$3fmt17hd2abd57f87e1002bE","name":"fmt","decl_file":97,"decl_line":641,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN79_$LT$std..ffi..c_str..FromBytesWithNulErrorKind$u20$as$u20$core..fmt..Debug$GT$3fmt17h80e7de8dbd06d769E","name":"fmt","decl_file":97,"decl_line":261,"external":true,"inline":"inlined"},{"tag":"namespace","name":"into_string","children":[{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str7CString11into_string28_$u7b$$u7b$closure$u7d$$u7d$17hd0e21cab7c8670e8E","name":"{{closure}}","decl_file":97,"decl_line":475,"inline":"inlined"}]},{"tag":"namespace","name":"fmt","children":[{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..ffi..c_str..CStr$u20$as$u20$core..fmt..Debug$GT$3fmt28_$u7b$$u7b$closure$u7d$$u7d$17h81fa190d7989fde6E","name":"{{closure}}","decl_file":97,"decl_line":664,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..ffi..c_str..CStr$u20$as$u20$alloc..borrow..ToOwned$GT$8to_owned17hdcc79a384f66096dE","name":"to_owned","decl_file":97,"decl_line":1275,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..ffi..c_str..FromBytesWithNulError$u20$as$u20$std..error..Error$GT$11description17h42e32caf3b6c5c5fE","name":"description","decl_file":97,"decl_line":879,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"NulError","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"Vec<u8>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"CStr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"i8[]","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3ffi5c_str4CStr8to_bytes17he75e340bb5edb3d3E","name":"to_bytes","decl_file":97,"decl_line":1117,"inline":"inlined"}]},{"tag":"structure_type","name":"IntoStringError","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"CString","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Utf8Error","alignment":4,"data_member_location":8}]}]}]},{"tag":"namespace","name":"path","children":[{"tag":"structure_type","name":"Component","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":96013,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Prefix","type":"Prefix","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"RootDir","type":"RootDir","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"CurDir","type":"CurDir","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"ParentDir","type":"ParentDir","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"Normal","type":"Normal","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Prefix","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"PrefixComponent","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"RootDir","byte_size":32,"alignment":4},{"tag":"structure_type","name":"CurDir","byte_size":32,"alignment":4},{"tag":"structure_type","name":"ParentDir","byte_size":32,"alignment":4},{"tag":"structure_type","name":"Normal","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN3std4path9Component9as_os_str17h5f0bfd9530022830E","name":"as_os_str","decl_file":98,"decl_line":562,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"PrefixComponent","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"raw","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":0},{"tag":"member","name":"parsed","type":"Prefix","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Prefix","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":96259,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Verbatim","type":"Verbatim","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"VerbatimUNC","type":"VerbatimUNC","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"VerbatimDisk","type":"VerbatimDisk","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"DeviceNS","type":"DeviceNS","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"UNC","type":"UNC","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":5,"children":[{"tag":"member","name":"Disk","type":"Disk","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Verbatim","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"VerbatimUNC","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":4},{"tag":"member","name":"__1","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":12}]},{"tag":"structure_type","name":"VerbatimDisk","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]},{"tag":"structure_type","name":"DeviceNS","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"UNC","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":4},{"tag":"member","name":"__1","type":"&std::ffi::os_str::OsStr","alignment":4,"data_member_location":12}]},{"tag":"structure_type","name":"Disk","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]},{"tag":"subprogram","linkage_name":"_ZN3std4path6Prefix3len17h02bd7b204da6459dE","name":"len","decl_file":98,"decl_line":200,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path6Prefix11is_verbatim17hf670c293fae5573dE","name":"is_verbatim","decl_file":98,"decl_line":247,"inline":"inlined"}]},{"tag":"structure_type","name":"Path","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"OsStr","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path10components17h68f56c9abde31139E","name":"components","decl_file":98,"decl_line":2217,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path6is_dir17he89ed670c59f3d59E","name":"is_dir","decl_file":98,"decl_line":2464,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path6parent17hdc6a92d8d44835d3E","name":"parent","decl_file":98,"decl_line":1885,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path4iter17hd1897b0d64a9f1aeE","name":"iter","decl_file":98,"decl_line":2251,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path8has_root17h813a78af1bd0f81fE","name":"has_root","decl_file":98,"decl_line":1861,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path3new17h0c295fa590def09aE","name":"new<std::ffi::os_str::OsString>","decl_file":98,"decl_line":1709,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path9file_name17h060fab40da46de0bE","name":"file_name","decl_file":98,"decl_line":1950,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path13into_path_buf17hf68d6d07193263a7E","name":"into_path_buf","decl_file":98,"decl_line":2474,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path11to_path_buf17h6da5f317c1b2b7cfE","name":"to_path_buf","decl_file":98,"decl_line":1789,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path4Path3new17h62115547bec35de1E","name":"new<alloc::borrow::Cow<std::ffi::os_str::OsStr>>","decl_file":98,"decl_line":1709,"inline":"inlined"}]},{"tag":"structure_type","name":"PathBuf","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"OsString","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf3pop17h470ab46e5a42516cE","name":"pop","decl_file":98,"decl_line":1263,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf5_push17h98382076a9df6bd7E","name":"_push","decl_file":98,"decl_line":1211,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf4push17h8e1279a9fb136ab6E","name":"push<&std::ffi::os_str::OsStr>","decl_file":98,"decl_line":1207,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf13set_file_name17ha55101f0b0bc853cE","name":"set_file_name<&std::ffi::os_str::OsString>","decl_file":98,"decl_line":1300,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf3new17h27d56dfd465a9806E","name":"new","decl_file":98,"decl_line":1154,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf4push17he693df10b29471ddE","name":"push<&std::path::Path>","decl_file":98,"decl_line":1207,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf13set_file_name17h6b64c557ec4a2945E","name":"set_file_name<&std::ffi::os_str::OsStr>","decl_file":98,"decl_line":1300,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf13set_extension17h6c16961cd72413e9E","name":"set_extension<&std::ffi::os_str::OsStr>","decl_file":98,"decl_line":1338,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"fmt","children":[{"tag":"structure_type","name":"DebugHelper","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::path::Path","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"DebugHelper","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::path::Path","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"subprogram","linkage_name":"_ZN77_$LT$std..path..PrefixComponent$LT$$u27$a$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hc74e6b3508dd059bE","name":"fmt","decl_file":98,"decl_line":425,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..path..Component$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17hc3bf9109e40100fbE","name":"partial_cmp","decl_file":98,"decl_line":509,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..path..Component$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialEq$GT$2ne17hd43ee868470838e2E","name":"ne","decl_file":98,"decl_line":509,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$std..path..Component$LT$$u27$a$GT$$u20$as$u20$core..cmp..Ord$GT$3cmp17hdf01a9840500fe0aE","name":"cmp","decl_file":98,"decl_line":509,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$std..path..Path$u20$as$u20$core..cmp..PartialEq$GT$2eq17he0716ad3636aba00E","name":"eq","decl_file":98,"decl_line":2536,"external":true,"inline":"inlined"},{"tag":"namespace","name":"parent","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path4Path6parent28_$u7b$$u7b$closure$u7d$$u7d$17h94dd1a2aa9222773E","name":"{{closure}}","decl_file":98,"decl_line":1888,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..path..Components$LT$$u27$a$GT$$u20$as$u20$core..clone..Clone$GT$5clone17h2777eb32721ac54dE","name":"clone","decl_file":98,"decl_line":607,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$std..path..Prefix$LT$$u27$a$GT$$u20$as$u20$core..clone..Clone$GT$5clone17h1816fe6860571313E","name":"clone","decl_file":98,"decl_line":148,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$std..path..State$u20$as$u20$core..clone..Clone$GT$5clone17ha4429c9bc68a58cbE","name":"clone","decl_file":98,"decl_line":380,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$std..path..Component$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialEq$GT$2eq17h351267f8a2279332E","name":"eq","decl_file":98,"decl_line":509,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN72_$LT$std..path..Prefix$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialEq$GT$2eq17hf978abfac27be479E","name":"eq","decl_file":98,"decl_line":148,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$std..path..Prefix$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17h1da9371504c46359E","name":"partial_cmp","decl_file":98,"decl_line":148,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$std..path..Prefix$LT$$u27$a$GT$$u20$as$u20$core..cmp..Ord$GT$3cmp17h107664a7a2bccb22E","name":"cmp","decl_file":98,"decl_line":148,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN57_$LT$std..path..State$u20$as$u20$core..cmp..PartialEq$GT$2eq17h4ed1f149bc171205E","name":"eq","decl_file":98,"decl_line":380,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..path..State$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17hd248b983ca046b08E","name":"partial_cmp","decl_file":98,"decl_line":380,"inline":"inlined"},{"tag":"namespace","name":"parse_next_component","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path10Components20parse_next_component28_$u7b$$u7b$closure$u7d$$u7d$17h9102387eb2c28a48E","name":"{{closure}}","decl_file":98,"decl_line":782,"inline":"inlined"}]},{"tag":"namespace","name":"parse_next_component_back","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path10Components25parse_next_component_back28_$u7b$$u7b$closure$u7d$$u7d$17h0868a284606b3ea0E","name":"{{closure}}","decl_file":98,"decl_line":794,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN80_$LT$std..path..Iter$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hcb01d933fbd21866E","name":"next","decl_file":98,"decl_line":897,"external":true,"inline":"inlined"},{"tag":"namespace","name":"_push","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path7PathBuf5_push28_$u7b$$u7b$closure$u7d$$u7d$17h5822b50455b002f5E","name":"{{closure}}","decl_file":98,"decl_line":1213,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN62_$LT$std..path..PathBuf$u20$as$u20$core..ops..deref..Deref$GT$5deref17h1f49c23c7426d74eE","name":"deref","decl_file":98,"decl_line":1486,"external":true,"inline":"inlined"},{"tag":"namespace","name":"file_name","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path4Path9file_name28_$u7b$$u7b$closure$u7d$$u7d$17ha458f0ca9a13c82cE","name":"{{closure}}","decl_file":98,"decl_line":1951,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN52_$LT$std..path..Path$u20$as$u20$core..fmt..Debug$GT$3fmt17hd3e5f3783570a59eE","name":"fmt","decl_file":98,"decl_line":2490,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..path..Components$LT$$u27$a$GT$$u20$as$u20$core..cmp..PartialEq$GT$2eq17hd7b85adb9c663878E","name":"eq","decl_file":98,"decl_line":1017,"external":true,"inline":"inlined"},{"tag":"namespace","name":"_strip_prefix","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path4Path13_strip_prefix28_$u7b$$u7b$closure$u7d$$u7d$17hf67db91991558599E","name":"{{closure}}","decl_file":98,"decl_line":1998,"inline":"inlined"}]},{"tag":"namespace","name":"file_stem","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path4Path9file_stem28_$u7b$$u7b$closure$u7d$$u7d$17hdec237d48ceb3638E","name":"{{closure}}","decl_file":98,"decl_line":2075,"inline":"inlined"}]},{"tag":"namespace","name":"extension","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path4Path9extension28_$u7b$$u7b$closure$u7d$$u7d$17hed4a1277f58bcb2bE","name":"{{closure}}","decl_file":98,"decl_line":2101,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN92_$LT$std..path..PathBuf$u20$as$u20$core..convert..From$LT$std..ffi..os_str..OsString$GT$$GT$4from17h2f17dd9b92a2796eE","name":"from","decl_file":98,"decl_line":1429,"external":true,"inline":"inlined"}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"State","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Prefix","const_value":0},{"tag":"enumerator","name":"StartDir","const_value":1},{"tag":"enumerator","name":"Body","const_value":2},{"tag":"enumerator","name":"Done","const_value":3}]},{"tag":"subprogram","linkage_name":"_ZN3std4path17has_physical_root17h3b8dc02570d14c88E","name":"has_physical_root","decl_file":98,"decl_line":337,"inline":"inlined"},{"tag":"structure_type","name":"Components","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"path","type":"&[u8]","alignment":4,"data_member_location":0},{"tag":"member","name":"prefix","type":"Option<std::path::Prefix>","alignment":4,"data_member_location":8},{"tag":"member","name":"has_physical_root","type":"bool","alignment":1,"data_member_location":28},{"tag":"member","name":"front","type":"State","alignment":1,"data_member_location":29},{"tag":"member","name":"back","type":"State","alignment":1,"data_member_location":30},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components9trim_left17h1e8f1c09b839f3aaE","name":"trim_left","decl_file":98,"decl_line":802,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components10trim_right17h3a10c51f562aeedaE","name":"trim_right","decl_file":98,"decl_line":814,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components15len_before_body17h5687027ff9a74273E","name":"len_before_body","decl_file":98,"decl_line":685,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components16prefix_remaining17hd78a6b8887670fecE","name":"prefix_remaining","decl_file":98,"decl_line":675,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components10prefix_len17h2fd33cd74b9f7239E","name":"prefix_len","decl_file":98,"decl_line":664,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components8has_root17he1eeea1b14402a0dE","name":"has_root","decl_file":98,"decl_line":740,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components11is_sep_byte17hfb5e090df6bc6591E","name":"is_sep_byte","decl_file":98,"decl_line":706,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components22parse_single_component17h79075ea8201160f4E","name":"parse_single_component","decl_file":98,"decl_line":766,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components15prefix_verbatim17h2071368f7ed1868cE","name":"prefix_verbatim","decl_file":98,"decl_line":669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path10Components8finished17h89a32efb09c89791E","name":"finished","decl_file":98,"decl_line":701,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Components","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4path4Iter7as_path17h3de02a631b60a36eE","name":"as_path","decl_file":98,"decl_line":874,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std4path10iter_after17h819e661fde69bd17E","name":"iter_after<core::iter::Rev<std::path::Components>,core::iter::Rev<std::path::Components>>","decl_file":98,"decl_line":302,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4path17split_file_at_dot17haeb21f348f2de881E","name":"split_file_at_dot","decl_file":98,"decl_line":347,"inline":"inlined"},{"tag":"namespace","name":"split_file_at_dot","children":[{"tag":"subprogram","linkage_name":"_ZN3std4path17split_file_at_dot28_$u7b$$u7b$closure$u7d$$u7d$17h5c04591e3d5a898aE","name":"{{closure}}","decl_file":98,"decl_line":358,"inline":"inlined"}]}]},{"tag":"namespace","name":"process","children":[{"tag":"structure_type","name":"ChildStderr","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"AnonPipe","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ChildStdout","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"AnonPipe","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ChildStdin","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"AnonPipe","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ExitStatus","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"ExitStatus","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"Command","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Command","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Stdio","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"Stdio","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Child","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"handle","type":"Process","alignment":1,"data_member_location":0},{"tag":"member","name":"stdin","type":"Option<std::process::ChildStdin>","alignment":1,"data_member_location":0},{"tag":"member","name":"stdout","type":"Option<std::process::ChildStdout>","alignment":1,"data_member_location":0},{"tag":"member","name":"stderr","type":"Option<std::process::ChildStderr>","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"time","children":[{"tag":"structure_type","name":"SystemTime","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"SystemTime","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"Instant","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Instant","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4time7Instant14duration_since17h7e10969972b56d48E","name":"duration_since","decl_file":99,"decl_line":184,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN88_$LT$std..time..Instant$u20$as$u20$core..ops..arith..Add$LT$core..time..Duration$GT$$GT$3add17h4decbf7989fcd931E","name":"add","decl_file":99,"decl_line":217,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN88_$LT$std..time..Instant$u20$as$u20$core..ops..arith..Sub$LT$core..time..Duration$GT$$GT$3sub17h282e6f9cc70195a0E","name":"sub","decl_file":99,"decl_line":233,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"SystemTimeError","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":0}]}]},{"tag":"namespace","name":"thread","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"new","children":[{"tag":"variable","name":"GUARD","type":"Mutex","decl_file":100,"decl_line":1023,"location":"03000000000610011E1000229F // DW_OP_addr 0x0, DW_OP_deref, DW_OP_constu 0x1, DW_OP_mul, DW_OP_constu 0x0, DW_OP_plus, DW_OP_stack_value","linkage_name":"_ZN3std6thread8ThreadId3new5GUARD17hecd0d2bdc6a6fd8bE"},{"tag":"variable","name":"COUNTER","type":"u64","decl_file":100,"decl_line":1024,"alignment":1,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std6thread8ThreadId3new7COUNTER17h004b34d2feb7804dE"},{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread3new28_$u7b$$u7b$closure$u7d$$u7d$17hc84d3d8adb04ee27E","name":"{{closure}}","decl_file":100,"decl_line":1091,"inline":"inlined"}]},{"tag":"namespace","name":"cname","children":[{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread5cname28_$u7b$$u7b$closure$u7d$$u7d$17had144bf3548031a1E","name":"{{closure}}","decl_file":100,"decl_line":1229,"inline":"inlined"}]},{"tag":"namespace","name":"name","children":[{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread4name28_$u7b$$u7b$closure$u7d$$u7d$17h18f9d7fbe3588d01E","name":"{{closure}}","decl_file":100,"decl_line":1225,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN58_$LT$std..thread..Thread$u20$as$u20$core..clone..Clone$GT$5clone17h858685f25e9d5891E","name":"clone","decl_file":100,"decl_line":1058,"inline":"inlined"}]},{"tag":"namespace","name":"local","children":[{"tag":"namespace","name":"statik","children":[{"tag":"structure_type","name":"Key<core::cell::Cell<(u64, u64)>>","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<core::option::Option<core::cell::Cell<(u64, u64)>>>","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"Key<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Key<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Key<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Key<core::cell::Cell<usize>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<core::option::Option<core::cell::Cell<usize>>>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"LocalKey<core::cell::Cell<usize>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"init","type":"fn() -> core::cell::Cell<usize>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17ha986eb6b675f0a35E","name":"try_with<core::cell::Cell<usize>,closure,usize>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17hd96594cad2d1c6c4E","name":"with<core::cell::Cell<usize>,closure,usize>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4init17hcad70d3ce9d30c83E","name":"init<core::cell::Cell<usize>>","decl_file":24,"decl_line":259,"inline":"inlined"}]},{"tag":"structure_type","name":"LocalKey<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"init","type":"fn() -> core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17h99fc20420c5aeb2dE","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17h007ff6e926770b4dE","name":"with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4init17h289dcf65387c44ccE","name":"init<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","decl_file":24,"decl_line":259,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hb94f6c8fffa286b9E","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17h7bf0bbeae409c0caE","name":"with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hba17f18f736cac73E","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::result::Result<(), std::io::error::Error>>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hae7002c70b706e19E","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::result::Result<(), std::io::error::Error>>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hfbfbc8e8755878a3E","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17h724266968a1bd949E","name":"with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,core::option::Option<alloc::boxed::Box<Write>>>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17h635d0f2d79542b2fE","name":"try_with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,()>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17h74d1c833b586ab44E","name":"with<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>,closure,()>","decl_file":24,"decl_line":253,"inline":"inlined"}]},{"tag":"structure_type","name":"AccessError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_private","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"LocalKey<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"init","type":"fn() -> core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17h6ed59a7a1e5f53f0E","name":"try_with<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>,closure,()>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17h59081fdcea2147ebE","name":"with<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>,closure,()>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4init17h766327efa4700cedE","name":"init<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","decl_file":24,"decl_line":259,"inline":"inlined"}]},{"tag":"structure_type","name":"LocalKey<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"init","type":"fn() -> core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17h0e12b4b894bc4ef4E","name":"try_with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,std::thread::Thread>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4init17hda44ccb240bd01c1E","name":"init<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>","decl_file":24,"decl_line":259,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hee94dfd3c60bf044E","name":"try_with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17hf7a6230dfa45a0baE","name":"with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17hf837eb1ff682577aE","name":"try_with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17hbe058123ca91d5a2E","name":"with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":253,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17h8fcdf19634f525d6E","name":"try_with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":301,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17hd3da8093d98f1645E","name":"with<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>,closure,()>","decl_file":24,"decl_line":253,"inline":"inlined"}]}]},{"tag":"structure_type","name":"Thread","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::thread::Inner>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread5cname17ha2a67c23f2b39578E","name":"cname","decl_file":100,"decl_line":1228,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread4name17h019597002a87ad40E","name":"name","decl_file":100,"decl_line":1224,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std6thread6Thread6unpark17h84808d2f5a17bfa9E","name":"unpark","decl_file":100,"decl_line":1138,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Inner","byte_size":40,"alignment":8,"children":[{"tag":"member","name":"name","type":"Option<std::ffi::c_str::CString>","alignment":4,"data_member_location":8},{"tag":"member","name":"id","type":"ThreadId","alignment":8,"data_member_location":0},{"tag":"member","name":"state","type":"AtomicUsize","alignment":4,"data_member_location":16},{"tag":"member","name":"lock","type":"Mutex<()>","alignment":4,"data_member_location":20},{"tag":"member","name":"cvar","type":"Condvar","alignment":4,"data_member_location":28}]},{"tag":"structure_type","name":"ThreadId","byte_size":8,"alignment":8,"children":[{"tag":"member","name":"__0","type":"u64","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std6thread8ThreadId3new17h2e14fcac5a06bf88E","name":"new","decl_file":100,"decl_line":1020,"inline":"inlined"}]},{"tag":"structure_type","name":"Builder","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"name","type":"Option<alloc::string::String>","alignment":4,"data_member_location":0},{"tag":"member","name":"stack_size","type":"Option<usize>","alignment":4,"data_member_location":12}]},{"tag":"subprogram","linkage_name":"_ZN3std6thread5sleep17h4420169c821a6e32E","name":"sleep","decl_file":100,"decl_line":771,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std6thread7current17hfc6f4398adfd6936E","name":"current","decl_file":100,"decl_line":627,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std6thread9panicking17hba6c2d9d313c9366E","name":"panicking","decl_file":100,"decl_line":714,"inline":"inlined"}]},{"tag":"namespace","name":"fs","children":[{"tag":"structure_type","name":"FileType","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"FileType","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Permissions","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"FilePermissions","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"File","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"inner","type":"File","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"OpenOptions","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"OpenOptions","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Metadata","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"FileAttr","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"DirEntry","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"DirEntry","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"DirBuilder","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"inner","type":"DirBuilder","alignment":1,"data_member_location":0},{"tag":"member","name":"recursive","type":"bool","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN3std2fs8metadata17h031786dc438945fcE","name":"metadata<&std::path::Path>","decl_file":101,"decl_line":1477,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2fs16symlink_metadata17h81b17b4b5028f5f0E","name":"symlink_metadata<&std::path::Path>","decl_file":101,"decl_line":1511,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2fs12canonicalize17hd868c5f3ca718a4cE","name":"canonicalize<&std::path::Path>","decl_file":101,"decl_line":1744,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2fs9read_link17h4d7680a840be6f7eE","name":"read_link<&std::path::Path>","decl_file":101,"decl_line":1703,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std2fs8read_dir17he44c5911a5f56d6cE","name":"read_dir<&std::path::Path>","decl_file":101,"decl_line":1946,"inline":"inlined"}]},{"tag":"namespace","name":"sync","children":[{"tag":"namespace","name":"mutex","children":[{"tag":"structure_type","name":"Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys_common::mutex::Mutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":4},{"tag":"member","name":"data","type":"UnsafeCell<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$3new17h315e652f1dc45362E","name":"new<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":102,"decl_line":178,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$4lock17hc7d53e4685d0194cE","name":"lock<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":102,"decl_line":228,"inline":"inlined"}]},{"tag":"structure_type","name":"Mutex<()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys_common::mutex::Mutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":4},{"tag":"member","name":"data","type":"UnsafeCell<()>","alignment":1,"data_member_location":5},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$4lock17h0734daff4e1f02a6E","name":"lock<()>","decl_file":102,"decl_line":228,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$3new17h4435298759c0060aE","name":"new<()>","decl_file":102,"decl_line":178,"inline":"inlined"}]},{"tag":"structure_type","name":"MutexGuard<()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__lock","type":"&std::sync::mutex::Mutex<()>","alignment":4,"data_member_location":0},{"tag":"member","name":"__poison","type":"Guard","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sync..mutex..MutexGuard$LT$$u27$mutex$C$$u20$T$GT$$GT$3new17h8676f90a7f98ae60E","name":"new<()>","decl_file":102,"decl_line":423,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN93_$LT$std..sync..mutex..MutexGuard$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17haa8725844287a29bE","name":"drop<()>","decl_file":102,"decl_line":452,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN93_$LT$std..sync..mutex..MutexGuard$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h007f436926299304E","name":"drop<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":102,"decl_line":452,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN102_$LT$std..sync..mutex..MutexGuard$LT$$u27$mutex$C$$u20$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17hf4482449734a4f97E","name":"deref_mut<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":102,"decl_line":444,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN93_$LT$std..sync..mutex..MutexGuard$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h892c83600154dad6E","name":"drop<std::sync::barrier::BarrierState>","decl_file":102,"decl_line":452,"inline":"inlined"},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]},{"tag":"subprogram","linkage_name":"_ZN3std4sync5mutex10guard_lock17h3ebfc5d012690d2bE","name":"guard_lock<()>","decl_file":102,"decl_line":476,"inline":"inlined"},{"tag":"structure_type","name":"MutexGuard<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__lock","type":"&std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"__poison","type":"Guard","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sync..mutex..MutexGuard$LT$$u27$mutex$C$$u20$T$GT$$GT$3new17h0cd6f9a74b0f500cE","name":"new<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","decl_file":102,"decl_line":423,"inline":"inlined"}]},{"tag":"structure_type","name":"Mutex<std::sync::mpsc::sync::State<()>>","byte_size":56,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys_common::mutex::Mutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":4},{"tag":"member","name":"data","type":"UnsafeCell<std::sync::mpsc::sync::State<()>>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Mutex<std::sync::barrier::BarrierState>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys_common::mutex::Mutex>","alignment":4,"data_member_location":0},{"tag":"member","name":"poison","type":"Flag","alignment":1,"data_member_location":4},{"tag":"member","name":"data","type":"UnsafeCell<std::sync::barrier::BarrierState>","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$3new17hb8f3d0094f2ffb79E","name":"new<std::sync::barrier::BarrierState>","decl_file":102,"decl_line":178,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN41_$LT$std..sync..mutex..Mutex$LT$T$GT$$GT$4lock17h7ff66e0f88df2763E","name":"lock<std::sync::barrier::BarrierState>","decl_file":102,"decl_line":228,"inline":"inlined"}]},{"tag":"structure_type","name":"MutexGuard<std::sync::barrier::BarrierState>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__lock","type":"&std::sync::mutex::Mutex<std::sync::barrier::BarrierState>","alignment":4,"data_member_location":0},{"tag":"member","name":"__poison","type":"Guard","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sync..mutex..MutexGuard$LT$$u27$mutex$C$$u20$T$GT$$GT$3new17hb66ecd2ce77aae0cE","name":"new<std::sync::barrier::BarrierState>","decl_file":102,"decl_line":423,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std4sync5mutex10guard_lock17h994f38d2ab0bf5caE","name":"guard_lock<std::sync::barrier::BarrierState>","decl_file":102,"decl_line":476,"inline":"inlined"}]},{"tag":"namespace","name":"once","children":[{"tag":"structure_type","name":"Once","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"state","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<*mut std::sync::once::Waiter>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4sync4once4Once12is_completed17he301a47b04386cf2E","name":"is_completed","decl_file":103,"decl_line":334,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4sync4once4Once9call_once17h01201fcac43ebb03E","name":"call_once<closure>","decl_file":103,"decl_line":223,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"call_once","children":[]}]},{"tag":"structure_type","name":"OnceState","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"poisoned","type":"bool","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"condvar","children":[{"tag":"structure_type","name":"Condvar","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Box<std::sys_common::condvar::Condvar>","alignment":4,"data_member_location":0},{"tag":"member","name":"mutex","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN3std4sync7condvar7Condvar4wait17hc49bf504283534d4E","name":"wait<()>","decl_file":104,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4sync7condvar7Condvar12wait_timeout17ha5cc487c1c969f59E","name":"wait_timeout<()>","decl_file":104,"decl_line":409,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4sync7condvar7Condvar4wait17hb68aa0a1e6079ecfE","name":"wait<std::sync::barrier::BarrierState>","decl_file":104,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4sync7condvar7Condvar3new17hfee4a90b2ec88abaE","name":"new","decl_file":104,"decl_line":139,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"mpsc","children":[{"tag":"namespace","name":"blocking","children":[{"tag":"structure_type","name":"Inner","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"thread","type":"Thread","alignment":4,"data_member_location":0},{"tag":"member","name":"woken","type":"AtomicBool","alignment":1,"data_member_location":4}]},{"tag":"structure_type","name":"SignalToken","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::sync::mpsc::blocking::Inner>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"WaitToken","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Arc<std::sync::mpsc::blocking::Inner>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4sync4mpsc8blocking9WaitToken4wait17h53cf0facd12ae6abE","name":"wait","decl_file":105,"decl_line":79,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std4sync4mpsc8blocking6tokens17h38c7235aaaebdeecE","name":"tokens","decl_file":105,"decl_line":40,"external":true,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN77_$LT$std..sync..mpsc..blocking..SignalToken$u20$as$u20$core..clone..Clone$GT$5clone17h32df1b41a614f6b1E","name":"clone","decl_file":105,"decl_line":27,"inline":"inlined"}]}]},{"tag":"namespace","name":"select","children":[{"tag":"structure_type","name":"Select","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<std::sync::mpsc::select::SelectInner>","alignment":4,"data_member_location":0},{"tag":"member","name":"next_id","type":"Cell<usize>","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN3std4sync4mpsc6select6Select4iter17h31636d2b692f72b3E","name":"iter","decl_file":106,"decl_line":261,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std4sync4mpsc6select6Select5wait217hcc63b6c09886442dE","name":"wait2","decl_file":106,"decl_line":172,"inline":"inlined"}]},{"tag":"structure_type","name":"SelectInner","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"head","type":"*mut std::sync::mpsc::select::Handle<()>","alignment":4,"data_member_location":0},{"tag":"member","name":"tail","type":"*mut std::sync::mpsc::select::Handle<()>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Handle<()>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"id","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"selector","type":"*mut std::sync::mpsc::select::SelectInner","alignment":4,"data_member_location":4},{"tag":"member","name":"next","type":"*mut std::sync::mpsc::select::Handle<()>","alignment":4,"data_member_location":8},{"tag":"member","name":"prev","type":"*mut std::sync::mpsc::select::Handle<()>","alignment":4,"data_member_location":12},{"tag":"member","name":"added","type":"bool","alignment":1,"data_member_location":28},{"tag":"member","name":"packet","type":"&Packet","alignment":4,"data_member_location":16},{"tag":"member","name":"rx","type":"&std::sync::mpsc::Receiver<()>","alignment":4,"data_member_location":24},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..sync..mpsc..select..Handle$LT$$u27$rx$C$$u20$T$GT$$GT$2id17h0c26d5b85fb04884E","name":"id<()>","decl_file":106,"decl_line":267,"inline":"inlined"}]},{"tag":"structure_type","name":"&Packet","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN83_$LT$std..sync..mpsc..select..Packets$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hc13e1ce36269258dE","name":"next","decl_file":106,"decl_line":344,"external":true,"inline":"inlined"}]}]},{"tag":"structure_type","name":"Receiver<()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"UnsafeCell<std::sync::mpsc::Flavor<()>>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Flavor<()>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":132676,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Oneshot","type":"Oneshot","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Stream","type":"Stream","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Shared","type":"Shared","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Sync","type":"Sync","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Oneshot","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sync::mpsc::oneshot::Packet<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Stream","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sync::mpsc::stream::Packet<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Shared","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sync::mpsc::shared::Packet<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Sync","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Arc<std::sync::mpsc::sync::Packet<()>>","alignment":4,"data_member_location":4}]}]},{"tag":"namespace","name":"oneshot","children":[{"tag":"structure_type","name":"Packet<()>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"state","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"data","type":"UnsafeCell<core::option::Option<()>>","alignment":1,"data_member_location":12},{"tag":"member","name":"upgrade","type":"UnsafeCell<std::sync::mpsc::oneshot::MyUpgrade<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"MyUpgrade<()>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":132875,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"NothingSent","type":"NothingSent","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":5,"children":[{"tag":"member","name":"SendUsed","type":"SendUsed","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"GoUp","type":"GoUp","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"NothingSent","byte_size":8,"alignment":4},{"tag":"structure_type","name":"SendUsed","byte_size":8,"alignment":4},{"tag":"structure_type","name":"GoUp","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Receiver<()>","alignment":4,"data_member_location":0}]}]}]},{"tag":"namespace","name":"stream","children":[{"tag":"structure_type","name":"Packet<()>","byte_size":128,"alignment":64,"children":[{"tag":"member","name":"queue","type":"Queue<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition, std::sync::mpsc::stream::ConsumerAddition>","alignment":64,"data_member_location":0}]},{"tag":"structure_type","name":"Message<()>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":132995,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"Data","type":"Data","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"GoUp","type":"GoUp","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Data","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"GoUp","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Receiver<()>","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"ConsumerAddition","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"steals","type":"UnsafeCell<isize>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"ProducerAddition","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"cnt","type":"AtomicIsize","alignment":4,"data_member_location":0},{"tag":"member","name":"to_wake","type":"AtomicUsize","alignment":4,"data_member_location":4},{"tag":"member","name":"port_dropped","type":"AtomicBool","alignment":1,"data_member_location":8}]}]},{"tag":"namespace","name":"spsc_queue","children":[{"tag":"structure_type","name":"Queue<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition, std::sync::mpsc::stream::ConsumerAddition>","byte_size":128,"alignment":64,"children":[{"tag":"member","name":"consumer","type":"CacheAligned<std::sync::mpsc::spsc_queue::Consumer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ConsumerAddition>>","alignment":64,"data_member_location":0},{"tag":"member","name":"producer","type":"CacheAligned<std::sync::mpsc::spsc_queue::Producer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition>>","alignment":64,"data_member_location":64}]},{"tag":"structure_type","name":"Consumer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ConsumerAddition>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"tail","type":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"tail_prev","type":"AtomicPtr<std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"cache_bound","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"cached_nodes","type":"AtomicUsize","alignment":4,"data_member_location":12},{"tag":"member","name":"addition","type":"ConsumerAddition","alignment":4,"data_member_location":16}]},{"tag":"structure_type","name":"Node<std::sync::mpsc::stream::Message<()>>","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"value","type":"Option<std::sync::mpsc::stream::Message<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"cached","type":"bool","alignment":1,"data_member_location":12},{"tag":"member","name":"next","type":"AtomicPtr<std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Producer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition>","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"head","type":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":0},{"tag":"member","name":"first","type":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":4},{"tag":"member","name":"tail_copy","type":"UnsafeCell<*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>>","alignment":4,"data_member_location":8},{"tag":"member","name":"addition","type":"ProducerAddition","alignment":4,"data_member_location":12}]}]},{"tag":"namespace","name":"cache_aligned","children":[{"tag":"structure_type","name":"CacheAligned<std::sync::mpsc::spsc_queue::Consumer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ConsumerAddition>>","byte_size":64,"alignment":64,"children":[{"tag":"member","name":"__0","type":"Consumer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ConsumerAddition>","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"Aligner","alignment":64,"data_member_location":0}]},{"tag":"structure_type","name":"Aligner","byte_size":0,"alignment":64},{"tag":"structure_type","name":"CacheAligned<std::sync::mpsc::spsc_queue::Producer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition>>","byte_size":64,"alignment":64,"children":[{"tag":"member","name":"__0","type":"Producer<std::sync::mpsc::stream::Message<()>, std::sync::mpsc::stream::ProducerAddition>","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"Aligner","alignment":64,"data_member_location":0}]}]},{"tag":"namespace","name":"shared","children":[{"tag":"structure_type","name":"Packet<()>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"queue","type":"Queue<()>","alignment":4,"data_member_location":0},{"tag":"member","name":"cnt","type":"AtomicIsize","alignment":4,"data_member_location":8},{"tag":"member","name":"steals","type":"UnsafeCell<isize>","alignment":4,"data_member_location":12},{"tag":"member","name":"to_wake","type":"AtomicUsize","alignment":4,"data_member_location":16},{"tag":"member","name":"channels","type":"AtomicUsize","alignment":4,"data_member_location":20},{"tag":"member","name":"port_dropped","type":"AtomicBool","alignment":1,"data_member_location":36},{"tag":"member","name":"sender_drain","type":"AtomicIsize","alignment":4,"data_member_location":24},{"tag":"member","name":"select_lock","type":"Mutex<()>","alignment":4,"data_member_location":28}]}]},{"tag":"namespace","name":"mpsc_queue","children":[{"tag":"structure_type","name":"Queue<()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"head","type":"AtomicPtr<std::sync::mpsc::mpsc_queue::Node<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"tail","type":"UnsafeCell<*mut std::sync::mpsc::mpsc_queue::Node<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Node<()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"next","type":"AtomicPtr<std::sync::mpsc::mpsc_queue::Node<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"value","type":"Option","alignment":1,"data_member_location":4}]}]},{"tag":"namespace","name":"sync","children":[{"tag":"structure_type","name":"Packet<()>","byte_size":60,"alignment":4,"children":[{"tag":"member","name":"channels","type":"AtomicUsize","alignment":4,"data_member_location":0},{"tag":"member","name":"lock","type":"Mutex<std::sync::mpsc::sync::State<()>>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"State<()>","byte_size":48,"alignment":4,"children":[{"tag":"member","name":"disconnected","type":"bool","alignment":1,"data_member_location":44},{"tag":"member","name":"queue","type":"Queue","alignment":4,"data_member_location":0},{"tag":"member","name":"blocker","type":"Blocker","alignment":4,"data_member_location":8},{"tag":"member","name":"buf","type":"Buffer<()>","alignment":4,"data_member_location":16},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":36},{"tag":"member","name":"canceled","type":"Option<&mut bool>","alignment":4,"data_member_location":40}]},{"tag":"structure_type","name":"Queue","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"head","type":"*mut std::sync::mpsc::sync::Node","alignment":4,"data_member_location":0},{"tag":"member","name":"tail","type":"*mut std::sync::mpsc::sync::Node","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Node","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"token","type":"Option<std::sync::mpsc::blocking::SignalToken>","alignment":4,"data_member_location":0},{"tag":"member","name":"next","type":"*mut std::sync::mpsc::sync::Node","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Blocker","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":134102,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"BlockedSender","type":"BlockedSender","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"BlockedReceiver","type":"BlockedReceiver","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"NoneBlocked","type":"NoneBlocked","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"BlockedSender","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SignalToken","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"BlockedReceiver","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SignalToken","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NoneBlocked","byte_size":8,"alignment":4}]},{"tag":"structure_type","name":"Buffer<()>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"buf","type":"Vec<core::option::Option<()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":16}]}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"barrier","children":[{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"BarrierState","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"count","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"generation_id","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Barrier","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"lock","type":"Mutex<std::sync::barrier::BarrierState>","alignment":4,"data_member_location":0},{"tag":"member","name":"cvar","type":"Condvar","alignment":4,"data_member_location":16},{"tag":"member","name":"num_threads","type":"usize","alignment":4,"data_member_location":24}]},{"tag":"structure_type","name":"BarrierWaitResult","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"bool","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std4sync7barrier17BarrierWaitResult9is_leader17h4ce19cb5b80c7078E","name":"is_leader","decl_file":107,"decl_line":189,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"rwlock","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"variable","name":"HOOK","type":"AtomicPtr<()>","decl_file":19,"decl_line":86,"location":"03881C1000 // DW_OP_addr 0x101c88","linkage_name":"_ZN3std5alloc4HOOK17ha35d4932a3e15c8bE"},{"tag":"subprogram","low_pc":12587,"high_pc":12589,"linkage_name":"_ZN3std5alloc24default_alloc_error_hook17h908d73e7ce269e1cE","name":"default_alloc_error_hook","decl_file":19,"decl_line":119},{"tag":"subprogram","low_pc":12590,"high_pc":12627,"linkage_name":"rust_oom","name":"rust_oom","decl_file":19,"decl_line":127,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm14abort_internal17had2d0e68a83fe0edE","low_pc":12624,"high_pc":12627,"call_file":19,"call_line":135,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm11ExitSysCall7perform17h446076bfafe1ac52E","low_pc":12624,"high_pc":12627,"call_file":21,"call_line":103}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..sync..atomic..AtomicPtr$LT$T$GT$$GT$4load17h04df2205efa17d68E","low_pc":12597,"high_pc":12606,"call_file":19,"call_line":128,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4sync6atomic11atomic_load17he8a0208e42cf5365E","low_pc":12597,"high_pc":12606,"call_file":20,"call_line":844}]}]},{"tag":"namespace","name":"__default_lib_allocator","children":[{"tag":"subprogram","low_pc":12628,"high_pc":12681,"linkage_name":"__rdl_alloc","name":"__rdl_alloc","decl_file":19,"decl_line":151,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$5alloc17hc4936a69a530f949E","ranges":[[12628,12664],[12666,12680]],"call_file":19,"call_line":153,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc6malloc17h761839d2df454339E","ranges":[[12628,12664],[12666,12680]],"call_file":108,"call_line":345}]}]},{"tag":"subprogram","low_pc":12682,"high_pc":12698,"linkage_name":"__rdl_dealloc","name":"__rdl_dealloc","decl_file":19,"decl_line":157,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$7dealloc17he8c0db396349b1e9E","low_pc":12682,"high_pc":12697,"call_file":19,"call_line":160,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc4free17h26b7a5ac9faee855E","low_pc":12682,"high_pc":12697,"call_file":108,"call_line":357}]}]},{"tag":"subprogram","low_pc":12700,"high_pc":12847,"linkage_name":"__rdl_realloc","name":"__rdl_realloc","decl_file":19,"decl_line":164,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$7realloc17h791ee03b02d46c20E","ranges":[[12700,12783],[12785,12803],[12808,12844]],"call_file":19,"call_line":169,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc7realloc17hac32b750f7f7bbdeE","ranges":[[12700,12783],[12785,12803],[12808,12844]],"call_file":108,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc6malloc17h761839d2df454339E","ranges":[[12732,12759],[12785,12799]],"call_file":22,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc4free17h26b7a5ac9faee855E","low_pc":12830,"high_pc":12844,"call_file":22,"call_line":79},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3min17h70a2d51f6d9f8115E","low_pc":12812,"high_pc":12822,"call_file":22,"call_line":77,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3min17hbf2291d18d0818a4E","low_pc":12812,"high_pc":12822,"call_file":16,"call_line":838,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","low_pc":12816,"high_pc":12821,"call_file":16,"call_line":575}]}]}]}]}]},{"tag":"subprogram","low_pc":12848,"high_pc":12949,"linkage_name":"__rdl_alloc_zeroed","name":"__rdl_alloc_zeroed","decl_file":19,"decl_line":173,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$12alloc_zeroed17h6d6903ea670711beE","low_pc":12848,"high_pc":12945,"call_file":19,"call_line":175,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc6calloc17h3636469b02c88496E","low_pc":12848,"high_pc":12945,"call_file":108,"call_line":351,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8Dlmalloc6malloc17h761839d2df454339E","ranges":[[12848,12888],[12895,12909]],"call_file":22,"call_line":53}]}]}]}]}]},{"tag":"namespace","name":"panicking","children":[{"tag":"variable","name":"HOOK_LOCK","type":"RWLock","decl_file":23,"decl_line":70,"location":"038C1C1000 // DW_OP_addr 0x101c8c","linkage_name":"_ZN3std9panicking9HOOK_LOCK17hf0fd56c53ca8cd4eE"},{"tag":"variable","name":"HOOK","type":"Hook","decl_file":23,"decl_line":71,"location":"03901C1000 // DW_OP_addr 0x101c90","linkage_name":"_ZN3std9panicking4HOOK17h67b2ebd2f94bd9b2E"},{"tag":"structure_type","name":"Hook","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":135846,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":4,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Default","type":"Default","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Custom","type":"Custom","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Default","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Custom","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*mut Fn<(&core::panic::PanicInfo)>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"default_hook","children":[{"tag":"namespace","name":"{{closure}}","children":[{"tag":"variable","name":"FIRST_PANIC","type":"AtomicBool","decl_file":23,"decl_line":208,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std9panicking12default_hook28_$u7b$$u7b$closure$u7d$$u7d$11FIRST_PANIC17h9626b48896d4458aE"}]},{"tag":"subprogram","linkage_name":"_ZN3std9panicking12default_hook28_$u7b$$u7b$closure$u7d$$u7d$17hb4b08cf1193a5cf5E","name":"{{closure}}","decl_file":23,"decl_line":198,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std9panicking12default_hook28_$u7b$$u7b$closure$u7d$$u7d$17hf53b8867c57d7f0dE","name":"{{closure}}","decl_file":23,"decl_line":218,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std9panicking12default_hook28_$u7b$$u7b$closure$u7d$$u7d$17h27bc5d014016bfb0E","name":"{{closure}}","decl_file":23,"decl_line":223,"inline":"inlined"}]},{"tag":"namespace","name":"continue_panic_fmt","children":[{"tag":"structure_type","name":"PanicPayload","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"inner","type":"&core::fmt::Arguments","alignment":4,"data_member_location":0},{"tag":"member","name":"string","type":"Option<alloc::string::String>","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN3std9panicking18continue_panic_fmt12PanicPayload3new17h8b6a2c18d5c0a761E","name":"new","decl_file":23,"decl_line":355,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill17h36bf1622be15f716E","name":"fill","decl_file":23,"decl_line":359,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"fill","children":[{"tag":"subprogram","linkage_name":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill28_$u7b$$u7b$closure$u7d$$u7d$17h0612585e238a7594E","name":"{{closure}}","decl_file":23,"decl_line":363,"inline":"inlined"}]},{"tag":"subprogram","low_pc":13484,"high_pc":13830,"linkage_name":"_ZN103_$LT$std..panicking..continue_panic_fmt..PanicPayload$LT$$u27$a$GT$$u20$as$u20$core..panic..BoxMeUp$GT$9box_me_up17h9b516d218ee6a818E","name":"box_me_up","decl_file":23,"decl_line":372,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill17h36bf1622be15f716E","low_pc":13504,"high_pc":13705,"call_file":23,"call_line":373,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$18get_or_insert_with17h8ad7ae85412cd4c9E","ranges":[[13504,13515],[13522,13639],[13646,13705]],"call_file":23,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill28_$u7b$$u7b$closure$u7d$$u7d$17h0612585e238a7594E","low_pc":13522,"high_pc":13639,"call_file":14,"call_line":824,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String3new17ha36327193e5f3a5fE","low_pc":13522,"high_pc":13536,"call_file":23,"call_line":364},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17h32e4478ccf3b83d4E","low_pc":13536,"high_pc":13619,"call_file":23,"call_line":365}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h575b1021ef6b0055E","low_pc":13646,"high_pc":13681,"call_file":14,"call_line":824,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17hc8e1957d25feb8d3E","low_pc":13656,"high_pc":13681,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h73f3dfdafc70df51E","low_pc":13656,"high_pc":13681,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h81125b9f61d9e8f8E","low_pc":13656,"high_pc":13681,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h32c521ec5670cd01E","low_pc":13656,"high_pc":13681,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hb67e6fc3ca39c235E","low_pc":13656,"high_pc":13681,"call_file":13,"call_line":729,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h62834538e5e7018fE","low_pc":13656,"high_pc":13664,"call_file":13,"call_line":719},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","low_pc":13669,"high_pc":13681,"call_file":13,"call_line":720,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","low_pc":13669,"high_pc":13681,"call_file":12,"call_line":159}]}]}]}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem7replace17hda88f1782fc15c22E","low_pc":13705,"high_pc":13755,"call_file":23,"call_line":373,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem4swap17h08d425ed2f2c996cE","low_pc":13705,"high_pc":13755,"call_file":10,"call_line":670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr23swap_nonoverlapping_one17h935a40d8b085a85bE","low_pc":13705,"high_pc":13755,"call_file":10,"call_line":612,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr4read17h50db8561207ec1daE","ranges":[[13705,13712],[13720,13742]],"call_file":0,"call_line":363}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$3new17h88cb49a123813c16E","ranges":[[13755,13787],[13822,13830]],"call_file":23,"call_line":374,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc15exchange_malloc17hd81a4f1a1ec767d6E","ranges":[[13755,13766],[13822,13830]],"call_file":28,"call_line":108,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","low_pc":13755,"high_pc":13761,"call_file":12,"call_line":188}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN35_$LT$alloc..boxed..Box$LT$T$GT$$GT$8into_raw17h1527315a575f6469E","low_pc":13789,"high_pc":13795,"call_file":23,"call_line":374,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN36_$LT$core..ptr..NonNull$LT$T$GT$$GT$6as_ptr17h069f348455340b37E","low_pc":13789,"high_pc":13795,"call_file":28,"call_line":172}]}]},{"tag":"subprogram","low_pc":13832,"high_pc":14084,"linkage_name":"_ZN103_$LT$std..panicking..continue_panic_fmt..PanicPayload$LT$$u27$a$GT$$u20$as$u20$core..panic..BoxMeUp$GT$3get17h3c4c0f8575a27200E","name":"get","decl_file":23,"decl_line":377,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill17h36bf1622be15f716E","low_pc":13852,"high_pc":14053,"call_file":23,"call_line":378,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$18get_or_insert_with17h8ad7ae85412cd4c9E","ranges":[[13859,13868],[13875,14053]],"call_file":23,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18continue_panic_fmt12PanicPayload4fill28_$u7b$$u7b$closure$u7d$$u7d$17h0612585e238a7594E","low_pc":13875,"high_pc":13992,"call_file":14,"call_line":824,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String3new17ha36327193e5f3a5fE","low_pc":13875,"high_pc":13889,"call_file":23,"call_line":364},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17h32e4478ccf3b83d4E","low_pc":13889,"high_pc":13972,"call_file":23,"call_line":365}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h575b1021ef6b0055E","low_pc":13992,"high_pc":14029,"call_file":14,"call_line":824,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17hc8e1957d25feb8d3E","low_pc":14004,"high_pc":14029,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h73f3dfdafc70df51E","low_pc":14004,"high_pc":14029,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr13drop_in_place17h81125b9f61d9e8f8E","low_pc":14004,"high_pc":14029,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h32c521ec5670cd01E","low_pc":14004,"high_pc":14029,"call_file":0,"call_line":194,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17hb67e6fc3ca39c235E","low_pc":14004,"high_pc":14029,"call_file":13,"call_line":729,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17h62834538e5e7018fE","low_pc":14004,"high_pc":14012,"call_file":13,"call_line":719},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","low_pc":14017,"high_pc":14029,"call_file":13,"call_line":720,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","low_pc":14017,"high_pc":14029,"call_file":12,"call_line":159}]}]}]}]}]}]}]}]}]}]}]}]},{"tag":"namespace","name":"begin_panic","children":[{"tag":"structure_type","name":"PanicPayload<&str>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"Option<&str>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"update_count_then_panic","children":[{"tag":"structure_type","name":"RewrapBox","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Box<Any>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"LOCAL_STDERR","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>","decl_file":24,"decl_line":177,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std9panicking12LOCAL_STDERR7__getit5__KEY17hf7ca88443b1b9e9bE"}]}]},{"tag":"namespace","name":"update_panic_count","children":[{"tag":"namespace","name":"PANIC_COUNT","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::Cell<usize>>","decl_file":24,"decl_line":177,"location":"03981C1000 // DW_OP_addr 0x101c98","linkage_name":"_ZN3std9panicking18update_panic_count11PANIC_COUNT7__getit5__KEY17h7fc3af4226009764E"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std9panicking18update_panic_count28_$u7b$$u7b$closure$u7d$$u7d$17hab314740e97751d3E","name":"{{closure}}","decl_file":23,"decl_line":240,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std9panicking18update_panic_count17h9d2e7c6d20aa74e6E","name":"update_panic_count","decl_file":23,"decl_line":236,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std9panicking9panicking17h5f848b3e537facb3E","name":"panicking","decl_file":23,"decl_line":316,"external":true,"inline":"inlined"},{"tag":"namespace","name":"try","children":[]},{"tag":"subprogram","low_pc":12950,"high_pc":12961,"linkage_name":"rust_begin_unwind","name":"rust_begin_panic","decl_file":23,"decl_line":324,"external":true,"noreturn":true},{"tag":"subprogram","low_pc":12963,"high_pc":13126,"linkage_name":"_ZN3std9panicking18continue_panic_fmt17h832031f04e552fdfE","name":"continue_panic_fmt","decl_file":23,"decl_line":348,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18continue_panic_fmt12PanicPayload3new17h8b6a2c18d5c0a761E","low_pc":13080,"high_pc":13094,"call_file":23,"call_line":391}]},{"tag":"subprogram","low_pc":13128,"high_pc":13482,"linkage_name":"_ZN3std9panicking20rust_panic_with_hook17h864601af53546939E","name":"rust_panic_with_hook","decl_file":23,"decl_line":445,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18update_panic_count17h9d2e7c6d20aa74e6E","ranges":[[13181,13226],[13236,13251]],"call_file":23,"call_line":450,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4with17hd96594cad2d1c6c4E","ranges":[[13181,13226],[13236,13251]],"call_file":23,"call_line":240,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$8try_with17ha986eb6b675f0a35E","ranges":[[13181,13226],[13236,13251]],"call_file":24,"call_line":255,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std9panicking18update_panic_count28_$u7b$$u7b$closure$u7d$$u7d$17hab314740e97751d3E","low_pc":13207,"high_pc":13226,"call_file":24,"call_line":309,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3get17h53823485519654e3E","low_pc":13207,"high_pc":13216,"call_file":23,"call_line":241},{"tag":"inlined_subroutine","abstract_origin":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$3set17h1bd04e28e2963583E","low_pc":13217,"high_pc":13226,"call_file":23,"call_line":242,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN34_$LT$core..cell..Cell$LT$T$GT$$GT$7replace17h4d641de484797b00E","low_pc":13217,"high_pc":13226,"call_file":25,"call_line":399,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem7replace17h52eea3db70e8e218E","low_pc":13217,"high_pc":13226,"call_file":25,"call_line":442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem4swap17hf711740a18b5e7f3E","low_pc":13217,"high_pc":13226,"call_file":10,"call_line":670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr23swap_nonoverlapping_one17h94675b143fa9fa8bE","low_pc":13217,"high_pc":13226,"call_file":10,"call_line":612}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN46_$LT$std..thread..local..LocalKey$LT$T$GT$$GT$4init17hcad70d3ce9d30c83E","low_pc":13244,"high_pc":13251,"call_file":24,"call_line":311,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem7replace17h49452eb8f281725fE","low_pc":13244,"high_pc":13251,"call_file":24,"call_line":277,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3mem4swap17h566a4e0f924002f9E","low_pc":13244,"high_pc":13251,"call_file":10,"call_line":670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr23swap_nonoverlapping_one17hf060cf2b1e9af996E","low_pc":13244,"high_pc":13251,"call_file":10,"call_line":612}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5panic9PanicInfo20internal_constructor17h7f7883a6234f3b51E","low_pc":13271,"high_pc":13326,"call_file":23,"call_line":464},{"tag":"inlined_subroutine","abstract_origin":"_ZN3std10sys_common6rwlock6RWLock4read17hf647c9113ce8cc73E","low_pc":13326,"high_pc":13362,"call_file":23,"call_line":468,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm6rwlock6RWLock4read17h84d7e980e2d60e65E","low_pc":13326,"high_pc":13362,"call_file":89,"call_line":33}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5panic9PanicInfo11set_payload17h9b2665da676a8519E","ranges":[[13404,13406],[13411,13414]],"call_file":23,"call_line":479},{"tag":"inlined_subroutine","abstract_origin":"_ZN3std10sys_common6rwlock6RWLock11read_unlock17hf4c10452374d4c6bE","low_pc":13435,"high_pc":13459,"call_file":23,"call_line":483,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm6rwlock6RWLock11read_unlock17h98fcc9aaafa7b7d6E","low_pc":13435,"high_pc":13459,"call_file":89,"call_line":67}]}]},{"tag":"subprogram","low_pc":14085,"high_pc":14134,"linkage_name":"rust_panic","name":"rust_panic","decl_file":23,"decl_line":522,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std10sys_common4util5abort17h018fa7f4d29effb9E","low_pc":14131,"high_pc":14134,"call_file":23,"call_line":527,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm14abort_internal17had2d0e68a83fe0edE","low_pc":14131,"high_pc":14134,"call_file":93,"call_line":30,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN3std3sys4wasm11ExitSysCall7perform17h446076bfafe1ac52E","low_pc":14131,"high_pc":14134,"call_file":21,"call_line":103}]}]}]},{"tag":"subprogram","linkage_name":"_ZN3std9panicking3try17h47a03387bd82ddaeE","name":"try<i32,closure>","decl_file":23,"decl_line":251,"inline":"inlined"}]},{"tag":"namespace","name":"stdsimd","children":[{"tag":"namespace","name":"arch","children":[{"tag":"namespace","name":"detect","children":[{"tag":"namespace","name":"cache","children":[{"tag":"variable","name":"CACHE","type":"Cache","decl_file":109,"decl_line":68,"linkage_name":"_ZN3std7stdsimd4arch6detect5cache5CACHE17hd597a09deb5095d4E"},{"tag":"structure_type","name":"Cache","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"AtomicU32","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"AtomicU32","alignment":4,"data_member_location":4}]},{"tag":"namespace","name":"{{impl}}","children":[]}]}]}]}]},{"tag":"namespace","name":"collections","children":[{"tag":"namespace","name":"hash","children":[{"tag":"namespace","name":"map","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"new","children":[{"tag":"namespace","name":"KEYS","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::Cell<(u64, u64)>>","decl_file":24,"decl_line":177,"alignment":1,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std11collections4hash3map11RandomState3new4KEYS7__getit5__KEY17h08843913ec0adfa0E"}]}]}]}]},{"tag":"structure_type","name":"DefaultHasher","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"__0","type":"SipHasher13","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std11collections4hash3map13DefaultHasher3new17h63c3d30919bbb0a4E","name":"new","decl_file":110,"decl_line":3215,"external":true,"inline":"inlined"}]}]}]}]},{"tag":"namespace","name":"net","children":[{"tag":"namespace","name":"ip","children":[{"tag":"structure_type","name":"Ipv6Addr","byte_size":16,"alignment":1,"children":[{"tag":"member","name":"inner","type":"in6_addr","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr8segments17h13e78f67580fb245E","name":"segments","decl_file":111,"decl_line":922,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr14is_unspecified17h17bc115d96751b86E","name":"is_unspecified","decl_file":111,"decl_line":952,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr11is_loopback17h52187aa2e0ec38a7E","name":"is_loopback","decl_file":111,"decl_line":972,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr12is_multicast17haede708df1b777c9E","name":"is_multicast","decl_file":111,"decl_line":1184,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr15multicast_scope17hb03890a45cfd0201E","name":"multicast_scope","decl_file":111,"decl_line":1151,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr9is_global17h4cf99c6b745ae21aE","name":"is_global","decl_file":111,"decl_line":1000,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr16is_documentation17h765608aa27f79dccE","name":"is_documentation","decl_file":111,"decl_line":1099,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr3new17h46131b798910f141E","name":"new","decl_file":111,"decl_line":866,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr21is_unicast_link_local17h542c206b9bf3cf6dE","name":"is_unicast_link_local","decl_file":111,"decl_line":1052,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv6Addr15is_unique_local17h79bc5b3ae76d6710E","name":"is_unique_local","decl_file":111,"decl_line":1028,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Ipv4Addr","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"inner","type":"in_addr","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr6octets17hb438485540c61d8cE","name":"octets","decl_file":111,"decl_line":405,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr14is_unspecified17h12236ba6f76db540E","name":"is_unspecified","decl_file":111,"decl_line":427,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr11is_loopback17he93bdb0023e2f3f6E","name":"is_loopback","decl_file":111,"decl_line":447,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr12is_multicast17h41d39199887c3927E","name":"is_multicast","decl_file":111,"decl_line":562,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr16is_documentation17h05aaf809a7d1d725E","name":"is_documentation","decl_file":111,"decl_line":608,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr10is_private17h714ed456a208efa9E","name":"is_private","decl_file":111,"decl_line":476,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr12is_broadcast17h0474261b687eebeeE","name":"is_broadcast","decl_file":111,"decl_line":582,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net2ip8Ipv4Addr3new17h69bc1042ef73400dE","name":"new","decl_file":111,"decl_line":342,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN61_$LT$std..net..ip..Ipv4Addr$u20$as$u20$core..fmt..Display$GT$3fmt17ha41ed86f7153c6efE","name":"fmt","decl_file":111,"decl_line":686,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$std..net..ip..Ipv4Addr$u20$as$u20$core..fmt..Debug$GT$3fmt17h945722bb9ce18b0cE","name":"fmt","decl_file":111,"decl_line":694,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..fmt..Debug$GT$3fmt17he8cc37aa9c6e1475E","name":"fmt","decl_file":111,"decl_line":1306,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$std..net..ip..Ipv4Addr$u20$as$u20$core..cmp..PartialEq$GT$2eq17hf302534f97b6a9cbE","name":"eq","decl_file":111,"decl_line":706,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN57_$LT$std..net..ip..Ipv4Addr$u20$as$u20$core..cmp..Ord$GT$3cmp17h2d7f0975f7cb3e1bE","name":"cmp","decl_file":111,"decl_line":771,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..net..ip..Ipv4Addr$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17h791ec9d09aad1821E","name":"partial_cmp","decl_file":111,"decl_line":744,"external":true,"inline":"inlined"},{"tag":"namespace","name":"fmt","children":[{"tag":"subprogram","linkage_name":"_ZN61_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..fmt..Display$GT$3fmt15find_zero_slice17h2b396143b1c66bfaE","name":"find_zero_slice","decl_file":111,"decl_line":1251,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN61_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..fmt..Display$GT$3fmt12fmt_subslice17hcdb4f4af3fd39aeeE","name":"fmt_subslice","decl_file":111,"decl_line":1281,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN63_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..cmp..PartialEq$GT$2eq17hd8da2bfef0173afeE","name":"eq","decl_file":111,"decl_line":1318,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17h2f35b5cf5190f52fE","name":"partial_cmp","decl_file":111,"decl_line":1355,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$std..net..ip..Ipv6Addr$u20$as$u20$core..convert..From$LT$$u5b$u16$u3b$$u20$_$u5d$$GT$$GT$4from17h9227dbb270cbbdabE","name":"from","decl_file":111,"decl_line":1426,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"IpAddr","byte_size":20,"alignment":4,"children":[{"tag":"variant_part","discr":144935,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"V4","type":"V4","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"V6","type":"V6","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"V4","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ipv4Addr","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"V6","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ipv6Addr","alignment":1,"data_member_location":1}]}]}]},{"tag":"namespace","name":"addr","children":[{"tag":"structure_type","name":"SocketAddrV6","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"inner","type":"sockaddr_in6","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV62ip17h3db52fda68e167d3E","name":"ip","decl_file":112,"decl_line":404,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV64port17habf2b8a9eb40d84bE","name":"port","decl_file":112,"decl_line":437,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV63new17hd1b8fc4b388b952bE","name":"new","decl_file":112,"decl_line":379,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV66set_ip17hc516183141715fb1E","name":"set_ip","decl_file":112,"decl_line":422,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV68set_port17hf82d1b2e859d0558E","name":"set_port","decl_file":112,"decl_line":453,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"SocketAddrV4","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"sockaddr_in","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV44port17he14ca751806b7f0eE","name":"port","decl_file":112,"decl_line":340,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV43new17h0a33bd318eb8cc3aE","name":"new","decl_file":112,"decl_line":285,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV46set_ip17h91aba2f767539609E","name":"set_ip","decl_file":112,"decl_line":325,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr12SocketAddrV48set_port17hce9fed216991ba5bE","name":"set_port","decl_file":112,"decl_line":356,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..net..addr..SocketAddrV4$u20$as$u20$core..fmt..Display$GT$3fmt17he3d4f8bc35ccefabE","name":"fmt","decl_file":112,"decl_line":609,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..net..addr..SocketAddrV4$u20$as$u20$core..fmt..Debug$GT$3fmt17h424d61ce10a4623aE","name":"fmt","decl_file":112,"decl_line":616,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..net..addr..SocketAddrV6$u20$as$u20$core..fmt..Display$GT$3fmt17h4065bd1c2415c141E","name":"fmt","decl_file":112,"decl_line":623,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..net..addr..SocketAddrV6$u20$as$u20$core..fmt..Debug$GT$3fmt17h8711585adea21ca0E","name":"fmt","decl_file":112,"decl_line":630,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..net..addr..SocketAddr$u20$as$u20$std..net..addr..ToSocketAddrs$GT$15to_socket_addrs17h661ce0828ecb4693E","name":"to_socket_addrs","decl_file":112,"decl_line":815,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$std..net..addr..SocketAddrV4$u20$as$u20$std..net..addr..ToSocketAddrs$GT$15to_socket_addrs17hca8986d70010b7e3E","name":"to_socket_addrs","decl_file":112,"decl_line":823,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$$LP$std..net..ip..Ipv4Addr$C$$u20$u16$RP$$u20$as$u20$std..net..addr..ToSocketAddrs$GT$15to_socket_addrs17hf84f3ae2dece6c47E","name":"to_socket_addrs","decl_file":112,"decl_line":851,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$std..net..addr..SocketAddrV6$u20$as$u20$std..net..addr..ToSocketAddrs$GT$15to_socket_addrs17h5a2a8b6f7a141e28E","name":"to_socket_addrs","decl_file":112,"decl_line":831,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$$LP$std..net..ip..Ipv6Addr$C$$u20$u16$RP$$u20$as$u20$std..net..addr..ToSocketAddrs$GT$15to_socket_addrs17hf2dc4fca56192d93E","name":"to_socket_addrs","decl_file":112,"decl_line":860,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"SocketAddr","byte_size":32,"alignment":4,"children":[{"tag":"variant_part","discr":150126,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"V4","type":"V4","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"V6","type":"V6","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"V4","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddrV4","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"V6","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SocketAddrV6","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr10SocketAddr4port17hc565de17256356beE","name":"port","decl_file":112,"decl_line":190,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4addr10SocketAddr3new17hea9531731e156c24E","name":"new","decl_file":112,"decl_line":133,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"tcp","children":[{"tag":"structure_type","name":"TcpListener","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"TcpListener","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"TcpStream","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"TcpStream","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN40_$LT$u16$u20$as$u20$std..net..NetInt$GT$7from_be17h35d9d3b642a96badE","name":"from_be","decl_file":113,"decl_line":105,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN40_$LT$u16$u20$as$u20$std..net..NetInt$GT$5to_be17h1512c7cf19c64e1aE","name":"to_be","decl_file":113,"decl_line":106,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3net4ntoh17h2e3a3df50e4a2119E","name":"ntoh<u16>","decl_file":113,"decl_line":112,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net4hton17h1dbfd6f14b9731ffE","name":"hton<u16>","decl_file":113,"decl_line":111,"inline":"inlined"},{"tag":"namespace","name":"parser","children":[{"tag":"structure_type","name":"Parser","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"s","type":"&[u8]","alignment":4,"data_member_location":0},{"tag":"member","name":"pos","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser3new17h7b77f890106206b7E","name":"new","decl_file":114,"decl_line":28,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h8fe364bc0b28123eE","name":"read_atomically<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17hbb8df0a6903b2291E","name":"read_till_eof<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser6is_eof17h9f1216f36e0795d6E","name":"is_eof","decl_file":114,"decl_line":35,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h921a6daf16e48c03E","name":"read_atomically<std::net::ip::Ipv6Addr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17ha5f05092672a2740E","name":"read_till_eof<std::net::ip::Ipv6Addr,closure>","decl_file":114,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h4386d5c74673e1c1E","name":"read_atomically<std::net::addr::SocketAddr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser7read_or17h9ee2fec33f6f5880E","name":"read_or<std::net::addr::SocketAddr>","decl_file":114,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser16read_socket_addr17h7e9e7f7b44414404E","name":"read_socket_addr","decl_file":114,"decl_line":293,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h625c4eb335fa4b5dE","name":"read_atomically<std::net::addr::SocketAddr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17he1157c7087bf651aE","name":"read_till_eof<std::net::addr::SocketAddr,closure>","decl_file":114,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser9read_char17h4230800d234176d3E","name":"read_char","decl_file":114,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h85bf14dfae4f927fE","name":"read_atomically<u8,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_digit17h6dff4deae2273e79E","name":"read_digit","decl_file":114,"decl_line":114,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser16read_number_impl17h0ddd31486dfca5bdE","name":"read_number_impl","decl_file":114,"decl_line":134,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h51713f4bb422ae26E","name":"read_atomically<u32,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h6192b23866a9e1b2E","name":"read_atomically<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_ipv4_addr_impl17h4516d477fec42b16E","name":"read_ipv4_addr_impl","decl_file":114,"decl_line":162,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h6d63a2f8090e0743E","name":"read_atomically<char,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_given_char17h74e95ef9b806bd01E","name":"read_given_char","decl_file":114,"decl_line":104,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser11read_number17hf90fe049751cd43dE","name":"read_number","decl_file":114,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hfe718aed48b4bf38E","name":"read_atomically<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h8582da984d7ce02bE","name":"read_atomically<u16,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hf1d74524e6dc2c45E","name":"read_atomically<std::net::ip::Ipv6Addr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_ipv6_addr_impl17h01cd155405b5b621E","name":"read_ipv6_addr_impl","decl_file":114,"decl_line":181,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hab811604410ae258E","name":"read_atomically<(std::net::ip::Ipv4Addr, char, u16),closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_317h4e3ef709f66973adE","name":"read_seq_3<std::net::ip::Ipv4Addr,char,u16,closure,closure,closure>","decl_file":114,"decl_line":72,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hea6fb4233745b067E","name":"read_atomically<(std::net::ip::Ipv6Addr, char, u16),closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_317h5edbc1c9befe5422E","name":"read_seq_3<std::net::ip::Ipv6Addr,char,u16,closure,closure,closure>","decl_file":114,"decl_line":72,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h7728c6a8845074d5E","name":"read_atomically<(char, std::net::ip::Ipv6Addr, char),closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_317h6e29f735a14d4f11E","name":"read_seq_3<char,std::net::ip::Ipv6Addr,char,closure,closure,closure>","decl_file":114,"decl_line":72,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hbbe2eed65be83300E","name":"read_atomically<std::net::ip::IpAddr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser7read_or17h9743104f2e83d515E","name":"read_or<std::net::ip::IpAddr>","decl_file":114,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser12read_ip_addr17hc62e075b3673fab8E","name":"read_ip_addr","decl_file":114,"decl_line":256,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17hf0ac3800be29b77dE","name":"read_atomically<std::net::ip::IpAddr,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17h7ef411e400a70aa9E","name":"read_till_eof<std::net::ip::IpAddr,closure>","decl_file":114,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h8d085722cfa990ffE","name":"read_atomically<std::net::addr::SocketAddrV4,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17ha9cf6432150d9f78E","name":"read_till_eof<std::net::addr::SocketAddrV4,closure>","decl_file":114,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_atomically17h44684465cc6151eeE","name":"read_atomically<std::net::addr::SocketAddrV6,closure>","decl_file":114,"decl_line":40,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof17h5fa9b64eca18429fE","name":"read_till_eof<std::net::addr::SocketAddrV6,closure>","decl_file":114,"decl_line":52,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser71_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..ip..Ipv4Addr$GT$8from_str17h4817b8e4c31a96b8E","name":"from_str","decl_file":114,"decl_line":314,"external":true,"inline":"inlined"},{"tag":"namespace","name":"from_str","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser71_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..ip..Ipv4Addr$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17h354f28ff69035329E","name":"{{closure}}","decl_file":114,"decl_line":315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser71_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..ip..Ipv6Addr$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17he042c17b4c723e7aE","name":"{{closure}}","decl_file":114,"decl_line":326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser75_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..addr..SocketAddr$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17ha76245b3e3961d5cE","name":"{{closure}}","decl_file":114,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser69_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..ip..IpAddr$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17h23770b84c2d1d8b7E","name":"{{closure}}","decl_file":114,"decl_line":304,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser77_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..addr..SocketAddrV4$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17h53b2d9acd89a9c70E","name":"{{closure}}","decl_file":114,"decl_line":337,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser77_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..addr..SocketAddrV6$GT$8from_str28_$u7b$$u7b$closure$u7d$$u7d$17hd34283716a38bfe7E","name":"{{closure}}","decl_file":114,"decl_line":348,"inline":"inlined"}]},{"tag":"namespace","name":"read_till_eof","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17h8c36ee28d55f225eE","name":"{{closure}}<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":55,"inline":"inlined"},{"tag":"namespace","name":"{{closure}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17ha3f5e821437d4379E","name":"{{closure}}<std::net::ip::Ipv4Addr,closure>","decl_file":114,"decl_line":56,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17h4c18161763f5c631E","name":"{{closure}}<std::net::ip::Ipv6Addr,closure>","decl_file":114,"decl_line":56,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17he2de740010f91f85E","name":"{{closure}}<std::net::addr::SocketAddr,closure>","decl_file":114,"decl_line":56,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17h2d82680c1785355aE","name":"{{closure}}<std::net::ip::IpAddr,closure>","decl_file":114,"decl_line":56,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17h2ead964cf06a0067E","name":"{{closure}}<std::net::addr::SocketAddrV4,closure>","decl_file":114,"decl_line":56,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17hb5fe442074b88253E","name":"{{closure}}<std::net::addr::SocketAddrV6,closure>","decl_file":114,"decl_line":56,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17h3caad762af5554c9E","name":"{{closure}}<std::net::ip::Ipv6Addr,closure>","decl_file":114,"decl_line":55,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17he04b2c93e09516ecE","name":"{{closure}}<std::net::addr::SocketAddr,closure>","decl_file":114,"decl_line":55,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17h2d9f682e47608deeE","name":"{{closure}}<std::net::ip::IpAddr,closure>","decl_file":114,"decl_line":55,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17hb84cef0bccc58966E","name":"{{closure}}<std::net::addr::SocketAddrV4,closure>","decl_file":114,"decl_line":55,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser13read_till_eof28_$u7b$$u7b$closure$u7d$$u7d$17h41db34e3e713a95aE","name":"{{closure}}<std::net::addr::SocketAddrV6,closure>","decl_file":114,"decl_line":55,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser71_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..ip..Ipv6Addr$GT$8from_str17h2624199b3f507f08E","name":"from_str","decl_file":114,"decl_line":325,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser75_$LT$impl$u20$core..str..FromStr$u20$for$u20$std..net..addr..SocketAddr$GT$8from_str17h751e34d134138d4fE","name":"from_str","decl_file":114,"decl_line":358,"external":true,"inline":"inlined"},{"tag":"namespace","name":"read_socket_addr","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser16read_socket_addr28_$u7b$$u7b$closure$u7d$$u7d$17h3ffb5a2389b86434E","name":"{{closure}}","decl_file":114,"decl_line":294,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser16read_socket_addr28_$u7b$$u7b$closure$u7d$$u7d$17h6d3f88f5ac32e5a5E","name":"{{closure}}","decl_file":114,"decl_line":295,"inline":"inlined"}]},{"tag":"namespace","name":"read_or","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser7read_or28_$u7b$$u7b$closure$u7d$$u7d$17h7cbbd5ac2ba2bae0E","name":"{{closure}}<std::net::addr::SocketAddr>","decl_file":114,"decl_line":64,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser7read_or28_$u7b$$u7b$closure$u7d$$u7d$17h9bb9a9caabe78feaE","name":"{{closure}}<std::net::ip::IpAddr>","decl_file":114,"decl_line":64,"inline":"inlined"}]},{"tag":"namespace","name":"read_digit","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_digit28_$u7b$$u7b$closure$u7d$$u7d$17ha5607ec473d4d1b6E","name":"{{closure}}","decl_file":114,"decl_line":129,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_digit11parse_digit17h8cfd340fbb5d16edE","name":"parse_digit","decl_file":114,"decl_line":115,"inline":"inlined"},{"tag":"namespace","name":"{{closure}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_digit28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17h9f72cbc2016ebe52E","name":"{{closure}}","decl_file":114,"decl_line":130,"inline":"inlined"}]}]},{"tag":"namespace","name":"read_number","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser11read_number28_$u7b$$u7b$closure$u7d$$u7d$17hdbdd8ed5baf9ab56E","name":"{{closure}}","decl_file":114,"decl_line":159,"inline":"inlined"}]},{"tag":"namespace","name":"read_ipv4_addr","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser14read_ipv4_addr28_$u7b$$u7b$closure$u7d$$u7d$17hfb267b386090e6c5E","name":"{{closure}}","decl_file":114,"decl_line":178,"inline":"inlined"}]},{"tag":"namespace","name":"read_given_char","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser15read_given_char28_$u7b$$u7b$closure$u7d$$u7d$17h82076df4e73fedc7E","name":"{{closure}}","decl_file":114,"decl_line":105,"inline":"inlined"}]},{"tag":"namespace","name":"read_ipv6_addr_impl","children":[{"tag":"namespace","name":"read_groups","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_ipv6_addr_impl11read_groups28_$u7b$$u7b$closure$u7d$$u7d$17h3477f51ba27087c6E","name":"{{closure}}","decl_file":114,"decl_line":195,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_ipv6_addr_impl11read_groups28_$u7b$$u7b$closure$u7d$$u7d$17hc17d77a73a3e6bf0E","name":"{{closure}}","decl_file":114,"decl_line":210,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_ipv6_addr_impl24ipv6_addr_from_head_tail17h709d85b9e669e0bfE","name":"ipv6_addr_from_head_tail","decl_file":114,"decl_line":182,"inline":"inlined"}]},{"tag":"namespace","name":"read_ipv6_addr","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser14read_ipv6_addr28_$u7b$$u7b$closure$u7d$$u7d$17ha2fea7dadb0abd6fE","name":"{{closure}}","decl_file":114,"decl_line":253,"inline":"inlined"}]},{"tag":"namespace","name":"read_socket_addr_v4","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v428_$u7b$$u7b$closure$u7d$$u7d$17h0613e21e39978e8dE","name":"{{closure}}","decl_file":114,"decl_line":263,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v428_$u7b$$u7b$closure$u7d$$u7d$17h69dfa29f28fabed2E","name":"{{closure}}","decl_file":114,"decl_line":264,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v428_$u7b$$u7b$closure$u7d$$u7d$17hdcd2dac09a345a7eE","name":"{{closure}}","decl_file":114,"decl_line":265,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v428_$u7b$$u7b$closure$u7d$$u7d$17h2d3be31e81207bd0E","name":"{{closure}}","decl_file":114,"decl_line":269,"inline":"inlined"}]},{"tag":"namespace","name":"read_seq_3","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_328_$u7b$$u7b$closure$u7d$$u7d$17hd14b432fcd673547E","name":"{{closure}}<std::net::ip::Ipv4Addr,char,u16,closure,closure,closure>","decl_file":114,"decl_line":81,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_328_$u7b$$u7b$closure$u7d$$u7d$17he1e7d37c867f1fd5E","name":"{{closure}}<char,std::net::ip::Ipv6Addr,char,closure,closure,closure>","decl_file":114,"decl_line":81,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser10read_seq_328_$u7b$$u7b$closure$u7d$$u7d$17h72a2ee2960d21e81E","name":"{{closure}}<std::net::ip::Ipv6Addr,char,u16,closure,closure,closure>","decl_file":114,"decl_line":81,"inline":"inlined"}]},{"tag":"namespace","name":"read_socket_addr_v6","children":[{"tag":"namespace","name":"{{closure}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17hf66744994c86b5e9E","name":"{{closure}}","decl_file":114,"decl_line":277,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17he256c8f242f77105E","name":"{{closure}}","decl_file":114,"decl_line":278,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17hc0f6f04cbac8bfb2E","name":"{{closure}}","decl_file":114,"decl_line":279,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$17he44f6db39278ba2fE","name":"{{closure}}","decl_file":114,"decl_line":276,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$17h8b99869ea092f4c6E","name":"{{closure}}","decl_file":114,"decl_line":282,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$17h7c909d5c91d12754E","name":"{{closure}}","decl_file":114,"decl_line":283,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser19read_socket_addr_v628_$u7b$$u7b$closure$u7d$$u7d$17h70eca7ebb8d29632E","name":"{{closure}}","decl_file":114,"decl_line":287,"inline":"inlined"}]},{"tag":"namespace","name":"read_ip_addr","children":[{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser12read_ip_addr28_$u7b$$u7b$closure$u7d$$u7d$17h40363a5c30d2807aE","name":"{{closure}}","decl_file":114,"decl_line":257,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3net6parser6Parser12read_ip_addr28_$u7b$$u7b$closure$u7d$$u7d$17h491dc831076ced3bE","name":"{{closure}}","decl_file":114,"decl_line":258,"inline":"inlined"}]}]},{"tag":"structure_type","name":"AddrParseError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]}]},{"tag":"namespace","name":"udp","children":[{"tag":"structure_type","name":"UdpSocket","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"UdpSocket","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]}]},{"tag":"namespace","name":"future","children":[{"tag":"namespace","name":"TLS_WAKER","children":[{"tag":"namespace","name":"__getit","children":[{"tag":"variable","name":"__KEY","type":"Key<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>","decl_file":24,"decl_line":177,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN3std6future9TLS_WAKER7__getit5__KEY17h47ae3446081925d5E"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"drop","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$std..future..SetOnDrop$u20$as$u20$core..ops..drop..Drop$GT$4drop28_$u7b$$u7b$closure$u7d$$u7d$17he296911c0c05aab4E","name":"{{closure}}","decl_file":115,"decl_line":61,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"memchr","children":[{"tag":"subprogram","linkage_name":"_ZN3std6memchr6memchr17hf3463dd44552a861E","name":"memchr","decl_file":116,"decl_line":34,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std6memchr7memrchr17h23aedad510ad7997E","name":"memrchr","decl_file":116,"decl_line":54,"inline":"inlined"}]},{"tag":"namespace","name":"env","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..env..VarsOs$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17hcf59bc1f1b7f0f01E","name":"size_hint","decl_file":117,"decl_line":178,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..env..ArgsOs$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h456392867e1c7816E","name":"next","decl_file":117,"decl_line":786,"external":true,"inline":"inlined"},{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN65_$LT$std..env..Args$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17hec97df1f86be5db4E","name":"{{closure}}","decl_file":117,"decl_line":750,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN67_$LT$std..env..ArgsOs$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17h24aed05e43ecbcacE","name":"size_hint","decl_file":117,"decl_line":787,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..env..ArgsOs$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17h90630e4ff8f6f4efE","name":"len","decl_file":117,"decl_line":792,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..env..ArgsOs$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$8is_empty17h5bf1c3f7686d8b73E","name":"is_empty","decl_file":117,"decl_line":793,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$std..env..ArgsOs$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h44192a99342355d1E","name":"next_back","decl_file":117,"decl_line":798,"external":true,"inline":"inlined"},{"tag":"namespace","name":"next_back","children":[{"tag":"subprogram","linkage_name":"_ZN74_$LT$std..env..Args$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back28_$u7b$$u7b$closure$u7d$$u7d$17hdec91d61d948d50fE","name":"{{closure}}","decl_file":117,"decl_line":764,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN3std3env7_var_os17h11c2706286e25393E","name":"_var_os","decl_file":117,"decl_line":239,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3env6var_os17h691e12f8a248773bE","name":"var_os<&std::ffi::os_str::OsStr>","decl_file":117,"decl_line":235,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3env4_var17haba66a2330be4fc8E","name":"_var","decl_file":117,"decl_line":211,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3env3var17h1466c26c188aa61aE","name":"var<&str>","decl_file":117,"decl_line":207,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN3std3env6var_os17h7d35a81b0c1f2ba0E","name":"var_os<&str>","decl_file":117,"decl_line":235,"inline":"inlined"}]},{"tag":"namespace","name":"panic","children":[{"tag":"subprogram","linkage_name":"_ZN3std5panic12catch_unwind17hd4ac97450a5dcbbfE","name":"catch_unwind<closure,i32>","decl_file":118,"decl_line":396,"inline":"inlined"}]},{"tag":"namespace","name":"rt","children":[{"tag":"namespace","name":"lang_start_internal","children":[{"tag":"namespace","name":"{{closure}}","children":[{"tag":"subprogram","linkage_name":"_ZN3std2rt19lang_start_internal28_$u7b$$u7b$closure$u7d$$u7d$28_$u7b$$u7b$closure$u7d$$u7d$17hcd7a5e859dcccfdaE","name":"{{closure}}","decl_file":119,"decl_line":59,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN3std2rt19lang_start_internal28_$u7b$$u7b$closure$u7d$$u7d$17h09d238c84e97c300E","name":"{{closure}}","decl_file":119,"decl_line":58,"inline":"inlined"}]}]}]},{"tag":"pointer_type","type":"Stderr","name":"&mut std::sys::wasm::stdio::Stderr"},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"base_type","name":"i32","encoding":"signed","byte_size":4},{"tag":"pointer_type","type":"Custom","name":"Box<std::io::error::Custom>"},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"usize[]","name":"&[usize; 3]"},{"tag":"array_type","type":"usize","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":3}]},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":11251,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Adaptor<std::io::stdio::StdoutLock>","name":"&mut std::io::Write::write_fmt::Adaptor<std::io::stdio::StdoutLock>"},{"tag":"pointer_type","type":"StdoutLock","name":"&mut std::io::stdio::StdoutLock"},{"tag":"pointer_type","type":"ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>","name":"&std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>"},{"tag":"pointer_type","type":"ReentrantMutex","name":"Box<std::sys::wasm::mutex::ReentrantMutex>"},{"tag":"base_type","name":"isize","encoding":"signed","byte_size":4},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":11270,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Adaptor<std::io::stdio::StderrLock>","name":"&mut std::io::Write::write_fmt::Adaptor<std::io::stdio::StderrLock>"},{"tag":"pointer_type","type":"StderrLock","name":"&mut std::io::stdio::StderrLock"},{"tag":"pointer_type","type":"ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>","name":"&std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":163976,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u8","name":"&u8"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164011,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"OsStr","name":"&std::ffi::os_str::OsStr"},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":96001,"name":"vtable","byte_size":0,"alignment":4},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164091,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"OsString","name":"&std::ffi::os_str::OsString"},{"tag":"variable","name":"vtable","type":"vtable","location":"03E8131000 // DW_OP_addr 0x1013e8"},{"tag":"structure_type","containing_type":31155,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164146,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ChildStderr","name":"&std::process::ChildStderr"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164181,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&str","name":"&&str"},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164240,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ChildStdout","name":"&std::process::ChildStdout"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164275,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"usize","name":"&usize"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164310,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"String","name":"&alloc::string::String"},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164339,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ChildStdin","name":"&std::process::ChildStdin"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164374,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&std::path::Path","name":"&&std::path::Path"},{"tag":"pointer_type","type":"Path","name":"&std::path::Path"},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164412,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Error","name":"&std::io::error::Error"},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164441,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"SystemTime","name":"&std::time::SystemTime"},{"tag":"base_type","name":"u64","encoding":"unsigned","byte_size":8},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164483,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"&[std::ffi::os_str::OsString]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const std::ffi::os_str::OsString","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"OsString","name":"*const std::ffi::os_str::OsString"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":82411,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":31337,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":124963,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":163890,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":125042,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":19867,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":101492,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":48050,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":163767,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":38646,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","name":"*mut alloc::sync::Arc<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>"},{"tag":"pointer_type","type":"ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","name":"*const alloc::sync::ArcInner<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>"},{"tag":"pointer_type","type":"Mutex","name":"Box<std::sys_common::mutex::Mutex>"},{"tag":"structure_type","name":"alloc::boxed::Box<[u8]>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","name":"*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>"},{"tag":"pointer_type","type":"ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","name":"*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>"},{"tag":"pointer_type","type":"Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","name":"*mut alloc::sync::Arc<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>"},{"tag":"pointer_type","type":"ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","name":"*const alloc::sync::ArcInner<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":46260,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":46320,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":46290,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164949,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":164976,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":165003,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"variable","name":"vtable","type":"vtable"},{"tag":"structure_type","containing_type":165030,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":0,"alignment":1},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":105405,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":105424,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":25206,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":25236,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":25266,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":39017,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":164190,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":116352,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165271,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::option::Option<closure>","alignment":4,"data_member_location":0}]},{"tag":"pointer_type","type":"Option","name":"&mut core::option::Option<closure>"},{"tag":"pointer_type","type":"Vec<alloc::boxed::Box<FnBox<()>>>","name":"*mut alloc::vec::Vec<alloc::boxed::Box<FnBox<()>>>"},{"tag":"pointer_type","type":"Box<FnBox<()>>","name":"*const alloc::boxed::Box<FnBox<()>>"},{"tag":"pointer_type","type":"subroutine ","name":"unsafe extern \\\"C\\\" fn(*mut u8)"},{"tag":"subroutine_type","children":[{"tag":"formal_parameter","type":"*mut u8"}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165359,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::io::lazy::Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","alignment":4,"data_member_location":0}]},{"tag":"pointer_type","type":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>","name":"&std::io::lazy::Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>>>>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165413,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::io::lazy::Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"pointer_type","type":"Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>","name":"&std::io::lazy::Lazy<std::sys_common::remutex::ReentrantMutex<core::cell::RefCell<std::io::stdio::Maybe<std::io::stdio::StderrRaw>>>>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165467,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"closure","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&std::io::lazy::Lazy<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","alignment":4,"data_member_location":0}]},{"tag":"pointer_type","type":"Lazy<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>","name":"&std::io::lazy::Lazy<std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>>"},{"tag":"pointer_type","type":"()","name":"*mut ()"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165530,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"subroutine ","name":"fn(&core::panic::PanicInfo)"},{"tag":"subroutine_type","children":[{"tag":"formal_parameter","type":"&core::panic::PanicInfo"}]},{"tag":"pointer_type","type":"PanicInfo","name":"&core::panic::PanicInfo"},{"tag":"pointer_type","type":"Arguments","name":"&core::fmt::Arguments"},{"tag":"structure_type","name":"&[&str]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"&str","name":"*const &str"},{"tag":"structure_type","name":"&[core::fmt::rt::v1::Argument]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::rt::v1::Argument","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"Argument","name":"*const core::fmt::rt::v1::Argument"},{"tag":"base_type","name":"char","encoding":"unsigned_char","byte_size":4},{"tag":"structure_type","name":"&[core::fmt::ArgumentV1]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"ArgumentV1","name":"*const core::fmt::ArgumentV1"},{"tag":"pointer_type","type":"Void","name":"&core::fmt::Void"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::fmt::Void"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"pointer_type","type":"Formatter","name":"&mut core::fmt::Formatter"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":163751,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"03F8131000 // DW_OP_addr 0x1013f8"},{"tag":"structure_type","containing_type":136361,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"030C141000 // DW_OP_addr 0x10140c"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":137075,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":163760,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":137271,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165917,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Option<alloc::string::String>","name":"&core::option::Option<alloc::string::String>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165952,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Option<usize>","name":"&core::option::Option<usize>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":165987,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u64","name":"&u64"},{"tag":"structure_type","name":"(u64, u64)","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"__1","type":"u64","alignment":8,"data_member_location":8}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166052,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"SipHasher13","name":"&core::hash::sip::SipHasher13"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166087,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"JoinPathsError","name":"&std::sys::wasm::os::JoinPathsError"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166122,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Vec<u8>","name":"&alloc::vec::Vec<u8>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166157,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"FromBytesWithNulErrorKind","name":"&std::ffi::c_str::FromBytesWithNulErrorKind"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166192,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"CString","name":"&std::ffi::c_str::CString"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166227,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Utf8Error","name":"&core::str::Utf8Error"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166262,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ReadDir","name":"&std::sys::wasm::fs::ReadDir"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166297,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"OpenOptions","name":"&std::sys::wasm::fs::OpenOptions"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166332,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"FilePermissions","name":"&std::sys::wasm::fs::FilePermissions"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166367,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"FileType","name":"&std::sys::wasm::fs::FileType"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166402,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"DirBuilder","name":"&std::sys::wasm::fs::DirBuilder"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166437,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"bool","name":"&bool"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166472,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ErrorKind","name":"&std::io::error::ErrorKind"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166507,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Box<Error>","name":"&alloc::boxed::Box<Error>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166542,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"i64","name":"&i64"},{"tag":"base_type","name":"i64","encoding":"signed","byte_size":8},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166584,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Ipv6Addr","name":"&std::net::ip::Ipv6Addr"},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":16}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166632,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Ipv4Addr","name":"&std::net::ip::Ipv4Addr"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166667,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"SocketAddrV6","name":"&std::net::addr::SocketAddrV6"},{"tag":"base_type","name":"u16","encoding":"unsigned","byte_size":2},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166709,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"SocketAddrV4","name":"&std::net::addr::SocketAddrV4"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166744,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&std::net::tcp::TcpListener","name":"&&std::net::tcp::TcpListener"},{"tag":"pointer_type","type":"TcpListener","name":"&std::net::tcp::TcpListener"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166788,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"()","name":"&()"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166823,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&std::ffi::os_str::OsStr","name":"&&std::ffi::os_str::OsStr"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166858,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Prefix","name":"&std::path::Prefix"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166893,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"PrefixComponent","name":"&std::path::PrefixComponent"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166928,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Option<&std::path::Path>","name":"&core::option::Option<&std::path::Path>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166963,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ExitStatus","name":"&std::sys::wasm::process::ExitStatus"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":166998,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"ExitCode","name":"&std::sys::wasm::process::ExitCode"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":167033,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Duration","name":"&core::time::Duration"},{"tag":"pointer_type","type":"LocalWaker","name":"*const core::task::wake::LocalWaker"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":167077,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"*const u8","name":"&*const u8"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":167112,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u32","name":"&u32"},{"tag":"pointer_type","type":"ArcInner<std::thread::Inner>","name":"*const alloc::sync::ArcInner<std::thread::Inner>"},{"tag":"pointer_type","type":"Condvar","name":"Box<std::sys_common::condvar::Condvar>"},{"tag":"base_type","name":"i8","encoding":"signed","byte_size":1},{"tag":"pointer_type","type":"ArcInner<std::sync::mpsc::blocking::Inner>","name":"*const alloc::sync::ArcInner<std::sync::mpsc::blocking::Inner>"},{"tag":"pointer_type","type":"Location","name":"&core::panic::Location"},{"tag":"pointer_type","type":"Cell<isize>","name":"&core::cell::Cell<isize>"},{"tag":"pointer_type","type":"Maybe","name":"&mut std::io::stdio::Maybe<std::io::stdio::StderrRaw>"},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":4}]},{"tag":"structure_type","name":"&[u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"subroutine Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>>","name":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>>"},{"tag":"subroutine_type","type":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>>"},{"tag":"pointer_type","type":"UnsafeCell<core::option::Option<core::cell::Cell<usize>>>","name":"&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<usize>>>"},{"tag":"pointer_type","type":"subroutine Cell<usize>","name":"fn() -> core::cell::Cell<usize>"},{"tag":"subroutine_type","type":"Cell<usize>"},{"tag":"pointer_type","type":"Mutex<()>","name":"&std::sync::mutex::Mutex<()>"},{"tag":"array_type","type":"i8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0}]},{"tag":"pointer_type","type":"CStr","name":"&std::ffi::c_str::CStr"},{"tag":"pointer_type","type":"EscapeDefault","name":"&mut core::ascii::EscapeDefault"},{"tag":"pointer_type","type":"usize","name":"&mut usize"},{"tag":"pointer_type","type":"Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>","name":"&std::sync::mutex::Mutex<std::io::buffered::BufReader<std::io::stdio::Maybe<std::io::stdio::StdinRaw>>>"},{"tag":"pointer_type","type":"Maybe","name":"&mut std::io::stdio::Maybe<std::io::stdio::StdoutRaw>"},{"tag":"pointer_type","type":"LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>","name":"&mut std::io::buffered::LineWriter<std::io::stdio::Maybe<std::io::stdio::StdoutRaw>>"},{"tag":"pointer_type","type":"subroutine Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>>","name":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>>"},{"tag":"subroutine_type","type":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>>"},{"tag":"pointer_type","type":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>","name":"&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>>>"},{"tag":"pointer_type","type":"subroutine RefCell<core::option::Option<alloc::boxed::Box<Write>>>","name":"fn() -> core::cell::RefCell<core::option::Option<alloc::boxed::Box<Write>>>"},{"tag":"subroutine_type","type":"RefCell<core::option::Option<alloc::boxed::Box<Write>>>"},{"tag":"pointer_type","type":"Option<alloc::boxed::Box<Write>>","name":"&mut core::option::Option<alloc::boxed::Box<Write>>"},{"tag":"pointer_type","type":"u16","name":"*const u16"},{"tag":"structure_type","name":"(std::net::ip::Ipv4Addr, char, u16)","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ipv4Addr","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"__2","type":"u16","alignment":2,"data_member_location":8}]},{"tag":"structure_type","name":"(char, std::net::ip::Ipv6Addr, char)","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"Ipv6Addr","alignment":1,"data_member_location":4},{"tag":"member","name":"__2","type":"char","alignment":4,"data_member_location":20}]},{"tag":"structure_type","name":"(std::net::ip::Ipv6Addr, char, u16)","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Ipv6Addr","alignment":1,"data_member_location":4},{"tag":"member","name":"__1","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"__2","type":"u16","alignment":2,"data_member_location":20}]},{"tag":"structure_type","name":"(core::option::Option<&std::ffi::os_str::OsStr>, core::option::Option<&std::ffi::os_str::OsStr>)","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Option<&std::ffi::os_str::OsStr>","alignment":4,"data_member_location":0},{"tag":"member","name":"__1","type":"Option<&std::ffi::os_str::OsStr>","alignment":4,"data_member_location":8}]},{"tag":"pointer_type","type":"LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","name":"*const alloc::collections::btree::node::LeafNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>"},{"tag":"pointer_type","type":"InternalNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","name":"*const alloc::collections::btree::node::InternalNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>"},{"tag":"array_type","type":"BoxedNode<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":12}]},{"tag":"array_type","type":"DefaultEnvKey","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":11}]},{"tag":"array_type","type":"Option<std::ffi::os_str::OsString>","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":11}]},{"tag":"pointer_type","type":"Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>","name":"*const alloc::collections::btree::node::Root<std::sys_common::process::DefaultEnvKey, core::option::Option<std::ffi::os_str::OsString>>"},{"tag":"pointer_type","type":"Handle<()>","name":"*mut std::sync::mpsc::select::Handle<()>"},{"tag":"pointer_type","type":"SelectInner","name":"*mut std::sync::mpsc::select::SelectInner"},{"tag":"pointer_type","type":"Receiver<()>","name":"&std::sync::mpsc::Receiver<()>"},{"tag":"pointer_type","type":"ArcInner<std::sync::mpsc::oneshot::Packet<()>>","name":"*const alloc::sync::ArcInner<std::sync::mpsc::oneshot::Packet<()>>"},{"tag":"pointer_type","type":"ArcInner<std::sync::mpsc::stream::Packet<()>>","name":"*const alloc::sync::ArcInner<std::sync::mpsc::stream::Packet<()>>"},{"tag":"pointer_type","type":"Node<std::sync::mpsc::stream::Message<()>>","name":"*mut std::sync::mpsc::spsc_queue::Node<std::sync::mpsc::stream::Message<()>>"},{"tag":"pointer_type","type":"ArcInner<std::sync::mpsc::shared::Packet<()>>","name":"*const alloc::sync::ArcInner<std::sync::mpsc::shared::Packet<()>>"},{"tag":"pointer_type","type":"Node<()>","name":"*mut std::sync::mpsc::mpsc_queue::Node<()>"},{"tag":"pointer_type","type":"ArcInner<std::sync::mpsc::sync::Packet<()>>","name":"*const alloc::sync::ArcInner<std::sync::mpsc::sync::Packet<()>>"},{"tag":"pointer_type","type":"Node","name":"*mut std::sync::mpsc::sync::Node"},{"tag":"pointer_type","type":"Option","name":"*const core::option::Option<()>"},{"tag":"pointer_type","type":"bool","name":"&mut bool"},{"tag":"pointer_type","type":"Mutex<std::sync::barrier::BarrierState>","name":"&std::sync::mutex::Mutex<std::sync::barrier::BarrierState>"},{"tag":"pointer_type","type":"subroutine Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>>","name":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>>"},{"tag":"subroutine_type","type":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>>"},{"tag":"pointer_type","type":"UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>","name":"&core::cell::UnsafeCell<core::option::Option<core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>>>"},{"tag":"pointer_type","type":"subroutine Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>","name":"fn() -> core::cell::Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>"},{"tag":"subroutine_type","type":"Cell<core::option::Option<core::ptr::NonNull<core::task::wake::LocalWaker>>>"},{"tag":"pointer_type","type":"subroutine Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>>","name":"unsafe fn() -> core::option::Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>>"},{"tag":"subroutine_type","type":"Option<&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>>"},{"tag":"pointer_type","type":"UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>","name":"&core::cell::UnsafeCell<core::option::Option<core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>>>"},{"tag":"pointer_type","type":"subroutine RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>","name":"fn() -> core::cell::RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>"},{"tag":"subroutine_type","type":"RefCell<core::option::Option<std::sys_common::thread_info::ThreadInfo>>"},{"tag":"pointer_type","type":"ThreadInfo","name":"&mut std::sys_common::thread_info::ThreadInfo"},{"tag":"pointer_type","type":"Option<std::sys_common::thread_info::ThreadInfo>","name":"&core::option::Option<std::sys_common::thread_info::ThreadInfo>"},{"tag":"pointer_type","type":"Option<std::sys_common::thread_info::ThreadInfo>","name":"&mut core::option::Option<std::sys_common::thread_info::ThreadInfo>"},{"tag":"pointer_type","type":"EscapeDebug","name":"&mut core::char::EscapeDebug"},{"tag":"namespace","name":"dlmalloc","children":[{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Dlmalloc","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8Dlmalloc6malloc17h761839d2df454339E","name":"malloc","decl_file":22,"decl_line":43,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8Dlmalloc4free17h26b7a5ac9faee855E","name":"free","decl_file":22,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8Dlmalloc7realloc17hac32b750f7f7bbdeE","name":"realloc","decl_file":22,"decl_line":67,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8Dlmalloc6calloc17h3636469b02c88496E","name":"calloc","decl_file":22,"decl_line":52,"inline":"inlined"}]},{"tag":"namespace","name":"dlmalloc","children":[{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"smallmap","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"treemap","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"smallbins","type":"*mut dlmalloc::dlmalloc::Chunk[]","alignment":4,"data_member_location":8},{"tag":"member","name":"treebins","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":272},{"tag":"member","name":"dvsize","type":"usize","alignment":4,"data_member_location":400},{"tag":"member","name":"topsize","type":"usize","alignment":4,"data_member_location":404},{"tag":"member","name":"dv","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":408},{"tag":"member","name":"top","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":412},{"tag":"member","name":"footprint","type":"usize","alignment":4,"data_member_location":416},{"tag":"member","name":"max_footprint","type":"usize","alignment":4,"data_member_location":420},{"tag":"member","name":"seg","type":"Segment","alignment":4,"data_member_location":424},{"tag":"member","name":"trim_check","type":"usize","alignment":4,"data_member_location":440},{"tag":"member","name":"least_addr","type":"*mut u8","alignment":4,"data_member_location":444},{"tag":"member","name":"release_checks","type":"usize","alignment":4,"data_member_location":448}]},{"tag":"structure_type","name":"Chunk","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"prev_foot","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"head","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"prev","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":8},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":12}]},{"tag":"structure_type","name":"TreeChunk","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"chunk","type":"Chunk","alignment":4,"data_member_location":0},{"tag":"member","name":"child","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":16},{"tag":"member","name":"parent","type":"*mut dlmalloc::dlmalloc::TreeChunk","alignment":4,"data_member_location":24},{"tag":"member","name":"index","type":"u32","alignment":4,"data_member_location":28}]},{"tag":"structure_type","name":"Segment","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"base","type":"*mut u8","alignment":4,"data_member_location":0},{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Segment","alignment":4,"data_member_location":8},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":12}]}]}]},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::Chunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":66}]},{"tag":"pointer_type","type":"Chunk","name":"*mut dlmalloc::dlmalloc::Chunk"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":32}]},{"tag":"pointer_type","type":"TreeChunk","name":"*mut dlmalloc::dlmalloc::TreeChunk"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":2}]},{"tag":"pointer_type","type":"Segment","name":"*mut dlmalloc::dlmalloc::Segment"},{"tag":"namespace","name":"alloc_system","children":[{"tag":"namespace","name":"platform","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$5alloc17hc4936a69a530f949E","name":"alloc","decl_file":108,"decl_line":343,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$7dealloc17he8c0db396349b1e9E","name":"dealloc","decl_file":108,"decl_line":355,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$7realloc17h791ee03b02d46c20E","name":"realloc","decl_file":108,"decl_line":361,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN12alloc_system8platform75_$LT$impl$u20$core..alloc..GlobalAlloc$u20$for$u20$alloc_system..System$GT$12alloc_zeroed17h6d6903ea670711beE","name":"alloc_zeroed","decl_file":108,"decl_line":349,"inline":"inlined"}]}]}]},{"tag":"pointer_type","type":"Thread","name":"&std::thread::Thread"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"libpanic_abort/lib.rs","stmt_list":88817,"GNU_pubnames":true,"low_pc":0,"ranges":[[14135,14139]],"children":[{"tag":"namespace","name":"panic_abort","children":[{"tag":"namespace","name":"__rust_start_panic","children":[{"tag":"subprogram","linkage_name":"_ZN11panic_abort18__rust_start_panic5abort17he7f53442ebe5f01bE","name":"abort","decl_file":29,"decl_line":66,"noreturn":true,"inline":"inlined"}]},{"tag":"subprogram","low_pc":14135,"high_pc":14139,"linkage_name":"__rust_start_panic","name":"__rust_start_panic","decl_file":29,"decl_line":54,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN11panic_abort18__rust_start_panic5abort17he7f53442ebe5f01bE","low_pc":14135,"high_pc":14139,"call_file":29,"call_line":55}]}]}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"liballoc_system/lib.rs","stmt_list":88915,"GNU_pubnames":true,"children":[{"tag":"namespace","name":"alloc_system","children":[{"tag":"namespace","name":"platform","children":[{"tag":"variable","name":"DLMALLOC","type":"Dlmalloc","external":true,"decl_file":108,"decl_line":338,"location":"03A01C1000 // DW_OP_addr 0x101ca0","linkage_name":"_ZN12alloc_system8platform8DLMALLOC17h0ae377c2541352a9E"}]}]},{"tag":"namespace","name":"dlmalloc","children":[{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Dlmalloc","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"dlmalloc","children":[{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"smallmap","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"treemap","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"smallbins","type":"*mut dlmalloc::dlmalloc::Chunk[]","alignment":4,"data_member_location":8},{"tag":"member","name":"treebins","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":272},{"tag":"member","name":"dvsize","type":"usize","alignment":4,"data_member_location":400},{"tag":"member","name":"topsize","type":"usize","alignment":4,"data_member_location":404},{"tag":"member","name":"dv","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":408},{"tag":"member","name":"top","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":412},{"tag":"member","name":"footprint","type":"usize","alignment":4,"data_member_location":416},{"tag":"member","name":"max_footprint","type":"usize","alignment":4,"data_member_location":420},{"tag":"member","name":"seg","type":"Segment","alignment":4,"data_member_location":424},{"tag":"member","name":"trim_check","type":"usize","alignment":4,"data_member_location":440},{"tag":"member","name":"least_addr","type":"*mut u8","alignment":4,"data_member_location":444},{"tag":"member","name":"release_checks","type":"usize","alignment":4,"data_member_location":448}]},{"tag":"structure_type","name":"Chunk","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"prev_foot","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"head","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"prev","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":8},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":12}]},{"tag":"structure_type","name":"TreeChunk","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"chunk","type":"Chunk","alignment":4,"data_member_location":0},{"tag":"member","name":"child","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":16},{"tag":"member","name":"parent","type":"*mut dlmalloc::dlmalloc::TreeChunk","alignment":4,"data_member_location":24},{"tag":"member","name":"index","type":"u32","alignment":4,"data_member_location":28}]},{"tag":"structure_type","name":"Segment","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"base","type":"*mut u8","alignment":4,"data_member_location":0},{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Segment","alignment":4,"data_member_location":8},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":12}]}]}]},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::Chunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":66}]},{"tag":"pointer_type","type":"Chunk","name":"*mut dlmalloc::dlmalloc::Chunk"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":32}]},{"tag":"pointer_type","type":"TreeChunk","name":"*mut dlmalloc::dlmalloc::TreeChunk"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":2}]},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"pointer_type","type":"Segment","name":"*mut dlmalloc::dlmalloc::Segment"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"rustc/dlmalloc_shim/../../dlmalloc/src/lib.rs","stmt_list":88971,"GNU_pubnames":true,"low_pc":0,"ranges":[[14140,14144],[14145,14161],[14163,17645],[18314,19081],[20723,21105],[19083,19748],[17983,18312],[17647,17981],[19750,20721]],"children":[{"tag":"namespace","name":"dlmalloc","children":[{"tag":"namespace","name":"dlmalloc","children":[{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"smallmap","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"treemap","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"smallbins","type":"*mut dlmalloc::dlmalloc::Chunk[]","alignment":4,"data_member_location":8},{"tag":"member","name":"treebins","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":272},{"tag":"member","name":"dvsize","type":"usize","alignment":4,"data_member_location":400},{"tag":"member","name":"topsize","type":"usize","alignment":4,"data_member_location":404},{"tag":"member","name":"dv","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":408},{"tag":"member","name":"top","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":412},{"tag":"member","name":"footprint","type":"usize","alignment":4,"data_member_location":416},{"tag":"member","name":"max_footprint","type":"usize","alignment":4,"data_member_location":420},{"tag":"member","name":"seg","type":"Segment","alignment":4,"data_member_location":424},{"tag":"member","name":"trim_check","type":"usize","alignment":4,"data_member_location":440},{"tag":"member","name":"least_addr","type":"*mut u8","alignment":4,"data_member_location":444},{"tag":"member","name":"release_checks","type":"usize","alignment":4,"data_member_location":448},{"tag":"subprogram","low_pc":14140,"high_pc":14144,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc16malloc_alignment17he597d306f53d23c3E","name":"malloc_alignment","decl_file":30,"decl_line":115,"external":true},{"tag":"subprogram","low_pc":14145,"high_pc":14161,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc17calloc_must_clear17hcd645abc81ec0196E","name":"calloc_must_clear","decl_file":30,"decl_line":216,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":14145,"high_pc":14160,"call_file":30,"call_line":217}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11pad_request17h59c752db9d950ae8E","name":"pad_request","decl_file":30,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12request2size17h9757285789665e04E","name":"request2size","decl_file":30,"decl_line":200,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","name":"small_index","decl_file":30,"decl_line":162,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","name":"smallbin_at","decl_file":30,"decl_line":923,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc24unlink_first_small_chunk17hdcae8d6191161fa8E","name":"unlink_first_small_chunk","decl_file":30,"decl_line":946,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18compute_tree_index17hefddd036d6ef8042E","name":"compute_tree_index","decl_file":30,"decl_line":934,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13tmalloc_large17h99c4a0746cfc205eE","name":"tmalloc_large","decl_file":30,"decl_line":849,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","name":"treebin_at","decl_file":30,"decl_line":929,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","name":"clear_smallmap","decl_file":30,"decl_line":1049,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc16small_index2size17hcc8427aee054980cE","name":"small_index2size","decl_file":30,"decl_line":166,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13tmalloc_small17hcee63363f30a38a4E","name":"tmalloc_small","decl_file":30,"decl_line":815,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc9sys_alloc17h23e8b4b869dcf207E","name":"sys_alloc","decl_file":30,"decl_line":337,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc10replace_dv17heaaaa11b654c7df1E","name":"replace_dv","decl_file":30,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","name":"insert_small_chunk","decl_file":30,"decl_line":981,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","name":"smallmap_is_marked","decl_file":30,"decl_line":1041,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","name":"is_small","decl_file":30,"decl_line":170,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12insert_chunk17h497045a501f462eaE","name":"insert_chunk","decl_file":30,"decl_line":973,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","name":"mark_smallmap","decl_file":30,"decl_line":1045,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc9init_bins17h8c84f071ec53006bE","name":"init_bins","decl_file":30,"decl_line":687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc8init_top17h20571d084008d426E","name":"init_top","decl_file":30,"decl_line":675,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12align_offset17hf4ca6ffacf16a83aE","name":"align_offset","decl_file":30,"decl_line":178,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc15segment_holding17hd22d05e403f878a0E","name":"segment_holding","decl_file":30,"decl_line":804,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11add_segment17h23b4ea1c5980d641E","name":"add_segment","decl_file":30,"decl_line":742,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13prepend_alloc17h391f5f2dc81d71e1E","name":"prepend_alloc","decl_file":30,"decl_line":695,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","name":"unlink_chunk","decl_file":30,"decl_line":1065,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","name":"unlink_small_chunk","decl_file":30,"decl_line":1073,"inline":"inlined"},{"tag":"subprogram","low_pc":14163,"high_pc":17645,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc6malloc17h8889efdb6bcbea85E","name":"malloc","decl_file":30,"decl_line":220,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[14294,14296],[14311,14317],[14335,14340]],"call_file":30,"call_line":236,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[14294,14296],[14311,14317],[14335,14340]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[14294,14296],[14311,14317],[14335,14340]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[14294,14296],[14311,14317],[14335,14340]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[14294,14296],[14311,14317],[14335,14340]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc24unlink_first_small_chunk17hdcae8d6191161fa8E","ranges":[[14325,14335],[14340,14364],[14724,14737]],"call_file":30,"call_line":238,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","low_pc":14724,"high_pc":14737,"call_file":30,"call_line":955}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_inuse_and_pinuse17ha967c9a4a5a44c0dE","ranges":[[14738,14740],[14749,14771]],"call_file":30,"call_line":240,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":14753,"high_pc":14758,"call_file":30,"call_line":1670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":14753,"high_pc":14758,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc16small_index2size17hcc8427aee054980cE","low_pc":14740,"high_pc":14749,"call_file":30,"call_line":239},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[14643,14645],[14677,14683],[14694,14699]],"call_file":30,"call_line":253,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[14643,14645],[14677,14683],[14694,14699]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[14643,14645],[14677,14683],[14694,14699]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[14643,14645],[14677,14683],[14694,14699]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[14643,14645],[14677,14683],[14694,14699]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc24unlink_first_small_chunk17hdcae8d6191161fa8E","ranges":[[14687,14694],[14699,14723],[15459,15472]],"call_file":30,"call_line":256,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","low_pc":15459,"high_pc":15472,"call_file":30,"call_line":955}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":15480,"high_pc":15490,"call_file":30,"call_line":262},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15490,"high_pc":15497,"call_file":30,"call_line":263,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15490,"high_pc":15497,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":15511,"high_pc":15525,"call_file":30,"call_line":264,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":15515,"high_pc":15525,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15515,"high_pc":15520,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15515,"high_pc":15520,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10replace_dv17heaaaa11b654c7df1E","ranges":[[15525,15600],[15700,15765]],"call_file":30,"call_line":265,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[15541,15559],[15570,15600],[15700,15746]],"call_file":30,"call_line":967,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[15541,15543],[15552,15559]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[15541,15543],[15552,15559]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[15541,15543],[15552,15559]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[15541,15543],[15552,15559]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[15541,15543],[15552,15559]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":15570,"high_pc":15588,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":15700,"high_pc":15710,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":15543,"high_pc":15552,"call_file":30,"call_line":982}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc16small_index2size17hcc8427aee054980cE","low_pc":15497,"high_pc":15502,"call_file":30,"call_line":257},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num21_$LT$impl$u20$u32$GT$14trailing_zeros17h39a966dd36d6cca4E","low_pc":14672,"high_pc":14677,"call_file":30,"call_line":252},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9least_bit17h76b823ef1ac1c017E","low_pc":14668,"high_pc":14672,"call_file":30,"call_line":251},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9left_bits17h7d43f4655895cf43E","low_pc":14652,"high_pc":14663,"call_file":30,"call_line":250},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13tmalloc_small17hcee63363f30a38a4E","ranges":[[14785,14834],[16225,16570]],"call_file":30,"call_line":272,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","ranges":[[14785,14787],[14798,14804]],"call_file":30,"call_line":818,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","ranges":[[14785,14787],[14798,14804]],"call_file":30,"call_line":931,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","ranges":[[14785,14787],[14798,14804]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","ranges":[[14785,14787],[14798,14804]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","ranges":[[14785,14787],[14798,14804]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":14807,"high_pc":14815,"call_file":30,"call_line":820},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9TreeChunk14leftmost_child17h728d34272c7e1636E","ranges":[[14824,14834],[16261,16285]],"call_file":30,"call_line":823},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":16225,"high_pc":16233,"call_file":30,"call_line":827},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_inuse_and_pinuse17ha967c9a4a5a44c0dE","ranges":[[16320,16322],[16331,16355]],"call_file":30,"call_line":839,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":16335,"high_pc":16340,"call_file":30,"call_line":1670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16335,"high_pc":16340,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":16356,"high_pc":16373,"call_file":30,"call_line":842},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":16373,"high_pc":16391,"call_file":30,"call_line":843,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":16381,"high_pc":16391,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":16381,"high_pc":16386,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16381,"high_pc":16386,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10replace_dv17heaaaa11b654c7df1E","low_pc":16391,"high_pc":16558,"call_file":30,"call_line":844,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[16414,16432],[16443,16533]],"call_file":30,"call_line":967,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[16414,16416],[16425,16432]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[16414,16416],[16425,16432]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[16414,16416],[16425,16432]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[16414,16416],[16425,16432]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[16414,16416],[16425,16432]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":16443,"high_pc":16461,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":16481,"high_pc":16491,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":16416,"high_pc":16425,"call_file":30,"call_line":982}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":16565,"high_pc":16570,"call_file":30,"call_line":846,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16565,"high_pc":16570,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num21_$LT$impl$u20$u32$GT$14trailing_zeros17h39a966dd36d6cca4E","low_pc":14795,"high_pc":14798,"call_file":30,"call_line":817},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9least_bit17h76b823ef1ac1c017E","low_pc":14787,"high_pc":14795,"call_file":30,"call_line":816}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12request2size17h9757285789665e04E","low_pc":14259,"high_pc":14277,"call_file":30,"call_line":225,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11pad_request17h59c752db9d950ae8E","low_pc":14259,"high_pc":14267,"call_file":30,"call_line":204,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":14259,"high_pc":14267,"call_file":30,"call_line":159}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":14277,"high_pc":14282,"call_file":30,"call_line":226},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11pad_request17h59c752db9d950ae8E","low_pc":14376,"high_pc":14388,"call_file":30,"call_line":284,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":14376,"high_pc":14388,"call_file":30,"call_line":159}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13tmalloc_large17h99c4a0746cfc205eE","ranges":[[14398,14620],[14852,15019],[15406,15458],[15601,15699],[15965,15979],[16104,16164]],"call_file":30,"call_line":286,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18compute_tree_index17hefddd036d6ef8042E","low_pc":14398,"high_pc":14456,"call_file":30,"call_line":852,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$13leading_zeros17h5aea5f8e194e57aeE","low_pc":14432,"high_pc":14435,"call_file":30,"call_line":941}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","low_pc":14464,"high_pc":14476,"call_file":30,"call_line":853,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","low_pc":14464,"high_pc":14476,"call_file":30,"call_line":931,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","low_pc":14464,"high_pc":14476,"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","low_pc":14464,"high_pc":14476,"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","low_pc":14464,"high_pc":14476,"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc24leftshift_for_tree_index17h6d4885a7618d11b1E","ranges":[[14494,14502],[14503,14508]],"call_file":30,"call_line":857},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":14516,"high_pc":14528,"call_file":30,"call_line":861},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9left_bits17h7d43f4655895cf43E","low_pc":14868,"high_pc":14877,"call_file":30,"call_line":886},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","ranges":[[14885,14887],[14898,14904]],"call_file":30,"call_line":890,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","ranges":[[14885,14887],[14898,14904]],"call_file":30,"call_line":931,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","ranges":[[14885,14887],[14898,14904]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","ranges":[[14885,14887],[14898,14904]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","ranges":[[14885,14887],[14898,14904]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num21_$LT$impl$u20$u32$GT$14trailing_zeros17h39a966dd36d6cca4E","low_pc":14895,"high_pc":14898,"call_file":30,"call_line":889},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9least_bit17h76b823ef1ac1c017E","low_pc":14887,"high_pc":14895,"call_file":30,"call_line":888},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":14913,"high_pc":14923,"call_file":30,"call_line":896},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9TreeChunk14leftmost_child17h728d34272c7e1636E","low_pc":14941,"high_pc":14962,"call_file":30,"call_line":901},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_inuse_and_pinuse17ha967c9a4a5a44c0dE","ranges":[[15423,15425],[15434,15458]],"call_file":30,"call_line":914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15438,"high_pc":15443,"call_file":30,"call_line":1670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15438,"high_pc":15443,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":15601,"high_pc":15618,"call_file":30,"call_line":916},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":15618,"high_pc":15636,"call_file":30,"call_line":917,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":15626,"high_pc":15636,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15626,"high_pc":15631,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15626,"high_pc":15631,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12insert_chunk17h497045a501f462eaE","ranges":[[15636,15699],[15965,15979],[16104,16154]],"call_file":30,"call_line":918,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":15636,"high_pc":15642,"call_file":30,"call_line":974},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[15644,15699],[16104,16154]],"call_file":30,"call_line":975,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[15644,15646],[15655,15662]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[15644,15646],[15655,15662]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[15644,15646],[15655,15662]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[15644,15646],[15655,15662]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[15644,15646],[15655,15662]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":15662,"high_pc":15680,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":16104,"high_pc":16114,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":15646,"high_pc":15655,"call_file":30,"call_line":982}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":16155,"high_pc":16164,"call_file":30,"call_line":920,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16155,"high_pc":16164,"call_file":30,"call_line":1702}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15078,"high_pc":15083,"call_file":30,"call_line":323,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15078,"high_pc":15083,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":15099,"high_pc":15109,"call_file":30,"call_line":326},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":15109,"high_pc":15114,"call_file":30,"call_line":328,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15109,"high_pc":15114,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_inuse_and_pinuse17ha967c9a4a5a44c0dE","low_pc":15158,"high_pc":15192,"call_file":30,"call_line":310,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15168,"high_pc":15177,"call_file":30,"call_line":1670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15168,"high_pc":15177,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15347,"high_pc":15352,"call_file":30,"call_line":301,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15347,"high_pc":15352,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":15357,"high_pc":15377,"call_file":30,"call_line":304,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":15367,"high_pc":15377,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15367,"high_pc":15372,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15367,"high_pc":15372,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":15377,"high_pc":15391,"call_file":30,"call_line":305},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":15399,"high_pc":15404,"call_file":30,"call_line":312,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15399,"high_pc":15404,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc9sys_alloc17h23e8b4b869dcf207E","ranges":[[15197,15328],[15769,15964],[15980,16103],[16620,17320],[17326,17644]],"call_file":30,"call_line":334,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":15197,"high_pc":15208,"call_file":30,"call_line":339},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc3sys5alloc17hbd81c4f7d4a82340E","low_pc":15208,"high_pc":15223,"call_file":30,"call_line":342},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3max17hb9bb2b6f80bf7eacE","low_pc":15260,"high_pc":15270,"call_file":30,"call_line":348,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3max17h3612f62b3bfe1f21E","low_pc":15260,"high_pc":15270,"call_file":16,"call_line":858,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","ranges":[[15260,15262],[15264,15269]],"call_file":16,"call_line":558}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment3top17h90938e835d27d394E","low_pc":15295,"high_pc":15312,"call_file":30,"call_line":366,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15309,"high_pc":15312,"call_file":30,"call_line":1753}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment9is_extern17h24874528bd9070f3E","low_pc":15954,"high_pc":15959,"call_file":30,"call_line":370},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment5holds17h83fadaabb61c9063E","ranges":[[15980,15994],[16620,16622]],"call_file":30,"call_line":372},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8init_top17h20571d084008d426E","ranges":[[16024,16038],[16056,16103]],"call_file":30,"call_line":377,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12align_offset17hf4ca6ffacf16a83aE","low_pc":16024,"high_pc":16032,"call_file":30,"call_line":676,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":16024,"high_pc":16032,"call_file":30,"call_line":179}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":16032,"high_pc":16033,"call_file":30,"call_line":677,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16032,"high_pc":16033,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":16080,"high_pc":16087,"call_file":30,"call_line":683,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16080,"high_pc":16087,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":16056,"high_pc":16061,"call_file":30,"call_line":676,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16056,"high_pc":16061,"call_file":30,"call_line":1702}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3min17h3c558b8aa2faa2ecE","low_pc":16630,"high_pc":16640,"call_file":30,"call_line":379,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3min17hcb95e795dd17e59cE","low_pc":16630,"high_pc":16640,"call_file":16,"call_line":838,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr65_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$$BP$mut$u20$T$GT$2le17h835c248213d3e8e3E","ranges":[[16630,16632],[16634,16639]],"call_file":16,"call_line":575}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment9is_extern17h24874528bd9070f3E","low_pc":16690,"high_pc":16695,"call_file":30,"call_line":385},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11add_segment17h23b4ea1c5980d641E","ranges":[[16703,17058],[17195,17241]],"call_file":30,"call_line":393,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc15segment_holding17hd22d05e403f878a0E","low_pc":16703,"high_pc":16748,"call_file":30,"call_line":747,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment3top17h90938e835d27d394E","low_pc":16721,"high_pc":16729,"call_file":30,"call_line":807,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","ranges":[[16721,16723],[16728,16729]],"call_file":30,"call_line":1753}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8init_top17h20571d084008d426E","ranges":[[16748,16754],[16759,16806]],"call_file":30,"call_line":767,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":16785,"high_pc":16792,"call_file":30,"call_line":683,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16785,"high_pc":16792,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":16834,"high_pc":16837,"call_file":30,"call_line":771},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","ranges":[[16950,16965],[16974,16985]],"call_file":30,"call_line":796,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":16950,"high_pc":16963,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","ranges":[[16963,16965],[16974,16985]],"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":16978,"high_pc":16985,"call_file":30,"call_line":1680}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12insert_chunk17h497045a501f462eaE","ranges":[[16985,17058],[17195,17241]],"call_file":30,"call_line":797,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":16985,"high_pc":16993,"call_file":30,"call_line":974},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[16995,17043],[17195,17241]],"call_file":30,"call_line":975,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[16995,16997],[17006,17013]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[16995,16997],[17006,17013]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[16995,16997],[17006,17013]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[16995,16997],[17006,17013]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[16995,16997],[17006,17013]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":17013,"high_pc":17031,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":17195,"high_pc":17205,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":16997,"high_pc":17006,"call_file":30,"call_line":982}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":16906,"high_pc":16911,"call_file":30,"call_line":760,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16906,"high_pc":16911,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16823,"high_pc":16828,"call_file":30,"call_line":754},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":16818,"high_pc":16821,"call_file":30,"call_line":753},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12align_offset17hf4ca6ffacf16a83aE","low_pc":16808,"high_pc":16818,"call_file":30,"call_line":752,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":16808,"high_pc":16818,"call_file":30,"call_line":179}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13prepend_alloc17h391f5f2dc81d71e1E","ranges":[[17079,17194],[17326,17644]],"call_file":30,"call_line":391,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":17079,"high_pc":17089,"call_file":30,"call_line":704},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk5inuse17h0625b60691a7d515E","low_pc":17133,"high_pc":17146,"call_file":30,"call_line":724},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":17148,"high_pc":17158,"call_file":30,"call_line":725},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[17158,17194],[17422,17454]],"call_file":30,"call_line":726,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":17158,"high_pc":17159,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[17161,17194],[17435,17454]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[17435,17444],[17449,17454]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":17444,"high_pc":17449,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":17462,"high_pc":17469,"call_file":30,"call_line":727,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17462,"high_pc":17469,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":17399,"high_pc":17421,"call_file":30,"call_line":722,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":17409,"high_pc":17421,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":17409,"high_pc":17414,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17409,"high_pc":17414,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","low_pc":17470,"high_pc":17503,"call_file":30,"call_line":730,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":17470,"high_pc":17483,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":17483,"high_pc":17503,"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":17493,"high_pc":17503,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":17493,"high_pc":17498,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17493,"high_pc":17498,"call_file":30,"call_line":1694}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12insert_chunk17h497045a501f462eaE","low_pc":17503,"high_pc":17638,"call_file":30,"call_line":731,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":17503,"high_pc":17515,"call_file":30,"call_line":974},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[17517,17572],[17588,17638]],"call_file":30,"call_line":975,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[17517,17519],[17528,17535]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[17517,17519],[17528,17535]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[17517,17519],[17528,17535]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[17517,17519],[17528,17535]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[17517,17519],[17528,17535]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":17535,"high_pc":17553,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":17588,"high_pc":17598,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":17519,"high_pc":17528,"call_file":30,"call_line":982}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":17639,"high_pc":17644,"call_file":30,"call_line":735,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17639,"high_pc":17644,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":17089,"high_pc":17096,"call_file":30,"call_line":702,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17089,"high_pc":17096,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc9init_bins17h8c84f071ec53006bE","low_pc":15847,"high_pc":15893,"call_file":30,"call_line":358,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17h8f0b51703ca53793E","low_pc":15879,"high_pc":15893,"call_file":30,"call_line":688,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u32$GT$2lt17h7e12d4f9e603d863E","low_pc":15879,"high_pc":15890,"call_file":32,"call_line":222}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8init_top17h20571d084008d426E","ranges":[[15893,15899],[15904,15953]],"call_file":30,"call_line":360,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":15930,"high_pc":15937,"call_file":30,"call_line":683,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":15930,"high_pc":15937,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":17285,"high_pc":17290,"call_file":30,"call_line":402,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17285,"high_pc":17290,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","low_pc":17305,"high_pc":17315,"call_file":30,"call_line":405},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":17315,"high_pc":17320,"call_file":30,"call_line":406,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":17315,"high_pc":17320,"call_file":30,"call_line":1702}]}]}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc17try_realloc_chunk17h273b881c08fe9cbaE","name":"try_realloc_chunk","decl_file":30,"decl_line":436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11mmap_resize17h5c2799b15566a8d0E","name":"mmap_resize","decl_file":30,"decl_line":508,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12overhead_for17he42573cd7417f254E","name":"overhead_for","decl_file":30,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","low_pc":18314,"high_pc":19081,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc7realloc17hea4186aa846d601cE","name":"realloc","decl_file":30,"decl_line":416,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12request2size17h9757285789665e04E","low_pc":18333,"high_pc":18349,"call_file":30,"call_line":420,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11pad_request17h59c752db9d950ae8E","low_pc":18333,"high_pc":18341,"call_file":30,"call_line":204,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":18333,"high_pc":18341,"call_file":30,"call_line":159}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc17try_realloc_chunk17h273b881c08fe9cbaE","ranges":[[18349,18394],[18399,18710],[18783,19072]],"call_file":30,"call_line":422,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":18349,"high_pc":18366,"call_file":30,"call_line":439},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":18366,"high_pc":18391,"call_file":30,"call_line":442},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6cinuse17h05c4d1126a28049cE","low_pc":18435,"high_pc":18445,"call_file":30,"call_line":486},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":18447,"high_pc":18452,"call_file":30,"call_line":487},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[18471,18512],[18926,18958]],"call_file":30,"call_line":492,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":18471,"high_pc":18477,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[18479,18512],[18939,18958]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[18939,18948],[18953,18958]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":18948,"high_pc":18953,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18968,"high_pc":19007,"call_file":30,"call_line":495,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18987,"high_pc":18992,"call_file":30,"call_line":1664,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18987,"high_pc":18992,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":19008,"high_pc":19027,"call_file":30,"call_line":498},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":19034,"high_pc":19060,"call_file":30,"call_line":499,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19042,"high_pc":19047,"call_file":30,"call_line":1664,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19042,"high_pc":19047,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19027,"high_pc":19034,"call_file":30,"call_line":497,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19027,"high_pc":19034,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11mmap_resize17h5c2799b15566a8d0E","low_pc":18513,"high_pc":18531,"call_file":30,"call_line":443,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":18513,"high_pc":18519,"call_file":30,"call_line":513}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18558,"high_pc":18574,"call_file":30,"call_line":448},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18581,"high_pc":18602,"call_file":30,"call_line":449},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18574,"high_pc":18581,"call_file":30,"call_line":447,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18574,"high_pc":18581,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18633,"high_pc":18649,"call_file":30,"call_line":460},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18649,"high_pc":18654,"call_file":30,"call_line":459,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18649,"high_pc":18654,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18799,"high_pc":18843,"call_file":30,"call_line":481,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18815,"high_pc":18820,"call_file":30,"call_line":1664,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18815,"high_pc":18820,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":18844,"high_pc":18860,"call_file":30,"call_line":474},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","ranges":[[18867,18875],[18880,18887]],"call_file":30,"call_line":475,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":18880,"high_pc":18887,"call_file":30,"call_line":1680}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":18887,"high_pc":18900,"call_file":30,"call_line":476},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18875,"high_pc":18880,"call_file":30,"call_line":473,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18875,"high_pc":18880,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":18860,"high_pc":18867,"call_file":30,"call_line":472,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":18860,"high_pc":18867,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3min17h1547d72f3d3a8d1eE","ranges":[[18730,18732],[18753,18761]],"call_file":30,"call_line":430,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3min17h15d1c25e5d6b240dE","ranges":[[18730,18732],[18753,18761]],"call_file":16,"call_line":838,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","low_pc":18753,"high_pc":18760,"call_file":16,"call_line":575}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":18732,"high_pc":18746,"call_file":30,"call_line":429},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12overhead_for17he42573cd7417f254E","low_pc":18746,"high_pc":18752,"call_file":30,"call_line":429,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":18746,"high_pc":18751,"call_file":30,"call_line":209}]}]},{"tag":"subprogram","low_pc":20723,"high_pc":21105,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc8memalign17h9fee01359b021c63E","name":"memalign","decl_file":30,"decl_line":553,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8from_mem17h5087eb4030617debE","low_pc":20789,"high_pc":20796,"call_file":30,"call_line":568,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20789,"high_pc":20796,"call_file":30,"call_line":1706}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":20815,"high_pc":20830,"call_file":30,"call_line":583},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":20870,"high_pc":20875,"call_file":30,"call_line":586},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":20878,"high_pc":20915,"call_file":30,"call_line":591,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":20897,"high_pc":20902,"call_file":30,"call_line":1664,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20897,"high_pc":20902,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":20915,"high_pc":20947,"call_file":30,"call_line":592},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20844,"high_pc":20851,"call_file":30,"call_line":579},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8from_mem17h5087eb4030617debE","low_pc":20843,"high_pc":20844,"call_file":30,"call_line":575,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20843,"high_pc":20844,"call_file":30,"call_line":1706}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":20994,"high_pc":21006,"call_file":30,"call_line":599},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":21009,"high_pc":21016,"call_file":30,"call_line":600},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":21024,"high_pc":21043,"call_file":30,"call_line":604},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","low_pc":21059,"high_pc":21081,"call_file":30,"call_line":605,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":21063,"high_pc":21068,"call_file":30,"call_line":1664,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":21063,"high_pc":21068,"call_file":30,"call_line":1694}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":21043,"high_pc":21048,"call_file":30,"call_line":603,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":21043,"high_pc":21048,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","low_pc":21094,"high_pc":21101,"call_file":30,"call_line":610,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":21094,"high_pc":21101,"call_file":30,"call_line":1702}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12request2size17h9757285789665e04E","low_pc":20758,"high_pc":20772,"call_file":30,"call_line":562,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11pad_request17h59c752db9d950ae8E","low_pc":20758,"high_pc":20766,"call_file":30,"call_line":204,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","low_pc":20758,"high_pc":20766,"call_file":30,"call_line":159}]}]}]},{"tag":"subprogram","low_pc":19083,"high_pc":19748,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13dispose_chunk17h3d6008ece82a48cdE","name":"dispose_chunk","decl_file":30,"decl_line":619,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19083,"high_pc":19093,"call_file":30,"call_line":620,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19083,"high_pc":19093,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6pinuse17h6b40df78c340a4ccE","low_pc":19093,"high_pc":19119,"call_file":30,"call_line":621},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":19121,"high_pc":19126,"call_file":30,"call_line":623},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[19163,19204],[19263,19295]],"call_file":30,"call_line":634,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":19163,"high_pc":19169,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[19171,19204],[19276,19295]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[19276,19285],[19290,19295]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":19285,"high_pc":19290,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","low_pc":19226,"high_pc":19261,"call_file":30,"call_line":637,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":19226,"high_pc":19244,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":19244,"high_pc":19261,"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":19254,"high_pc":19261,"call_file":30,"call_line":1680}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12minus_offset17h4de8cd08cd30e1baE","low_pc":19153,"high_pc":19158,"call_file":30,"call_line":630,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19153,"high_pc":19158,"call_file":30,"call_line":1698}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6cinuse17h05c4d1126a28049cE","low_pc":19296,"high_pc":19310,"call_file":30,"call_line":642},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":19334,"high_pc":19339,"call_file":30,"call_line":660},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[19346,19387],[19526,19538],[19560,19579]],"call_file":30,"call_line":662,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":19346,"high_pc":19352,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[19354,19387],[19560,19579]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[19560,19569],[19574,19579]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":19569,"high_pc":19574,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":19580,"high_pc":19600,"call_file":30,"call_line":663,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":19590,"high_pc":19600,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19590,"high_pc":19595,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19590,"high_pc":19595,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","low_pc":19388,"high_pc":19423,"call_file":30,"call_line":670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":19388,"high_pc":19401,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":19401,"high_pc":19423,"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":19411,"high_pc":19423,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19411,"high_pc":19416,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19411,"high_pc":19416,"call_file":30,"call_line":1694}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":19504,"high_pc":19524,"call_file":30,"call_line":657,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":19514,"high_pc":19524,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19514,"high_pc":19519,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19514,"high_pc":19519,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12insert_chunk17h497045a501f462eaE","ranges":[[19624,19699],[19701,19747]],"call_file":30,"call_line":672,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":19624,"high_pc":19636,"call_file":30,"call_line":974},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[19638,19686],[19701,19747]],"call_file":30,"call_line":975,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[19638,19640],[19649,19656]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[19638,19640],[19649,19656]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[19638,19640],[19649,19656]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[19638,19640],[19649,19656]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[19638,19640],[19649,19656]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":19656,"high_pc":19674,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":19701,"high_pc":19711,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":19640,"high_pc":19649,"call_file":30,"call_line":982}]}]}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc17treemap_is_marked17h76aaa6b3282d203aE","name":"treemap_is_marked","decl_file":30,"decl_line":1053,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc12mark_treemap17h911ceb625cf58fccE","name":"mark_treemap","decl_file":30,"decl_line":1057,"inline":"inlined"},{"tag":"subprogram","low_pc":17983,"high_pc":18312,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_large_chunk17h991a64a8d2ebe70cE","name":"insert_large_chunk","decl_file":30,"decl_line":998,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18compute_tree_index17hefddd036d6ef8042E","low_pc":17983,"high_pc":18044,"call_file":30,"call_line":999,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$13leading_zeros17h5aea5f8e194e57aeE","low_pc":18018,"high_pc":18021,"call_file":30,"call_line":941}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc17treemap_is_marked17h76aaa6b3282d203aE","low_pc":18078,"high_pc":18106,"call_file":30,"call_line":1005},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","ranges":[[18114,18122],[18225,18233]],"call_file":30,"call_line":1015},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc24leftshift_for_tree_index17h6d4885a7618d11b1E","ranges":[[18170,18178],[18179,18184]],"call_file":30,"call_line":1013},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12mark_treemap17h911ceb625cf58fccE","low_pc":18134,"high_pc":18147,"call_file":30,"call_line":1006},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","low_pc":18064,"high_pc":18078,"call_file":30,"call_line":1000,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","low_pc":18064,"high_pc":18078,"call_file":30,"call_line":931,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","low_pc":18064,"high_pc":18078,"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","low_pc":18064,"high_pc":18078,"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","low_pc":18064,"high_pc":18078,"call_file":0,"call_line":1938}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc13clear_treemap17hecfaadaad658a154E","name":"clear_treemap","decl_file":30,"decl_line":1061,"inline":"inlined"},{"tag":"subprogram","low_pc":17647,"high_pc":17981,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_large_chunk17h61f1d0e5215701e0E","name":"unlink_large_chunk","decl_file":30,"decl_line":1088,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9TreeChunk4next17h89899420d85f647aE","low_pc":17657,"high_pc":17670,"call_file":30,"call_line":1091},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc9TreeChunk4prev17he46b5a421cc2bb87E","low_pc":17677,"high_pc":17682,"call_file":30,"call_line":1092},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc10treebin_at17h58b6324d988e6b74E","ranges":[[17821,17827],[17834,17840]],"call_file":30,"call_line":1122,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","ranges":[[17821,17827],[17834,17840]],"call_file":30,"call_line":931,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","ranges":[[17821,17827],[17834,17840]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","ranges":[[17821,17827],[17834,17840]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","ranges":[[17821,17827],[17834,17840]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13clear_treemap17hecfaadaad658a154E","ranges":[[17958,17967],[17975,17980]],"call_file":30,"call_line":1126}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc11should_trim17hcfe13c2b013de77fE","name":"should_trim","decl_file":30,"decl_line":1228,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc8sys_trim17ha61c3ad311f02ae6E","name":"sys_trim","decl_file":30,"decl_line":1232,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc23release_unused_segments17h13ba5a04f8b39dabE","name":"release_unused_segments","decl_file":30,"decl_line":1285,"inline":"inlined"},{"tag":"subprogram","low_pc":19750,"high_pc":20721,"linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc4free17hddb1953a0e5b9830E","name":"free","decl_file":30,"decl_line":1151,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8from_mem17h5087eb4030617debE","low_pc":19750,"high_pc":19760,"call_file":30,"call_line":1154,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19750,"high_pc":19760,"call_file":30,"call_line":1706}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":19760,"high_pc":19773,"call_file":30,"call_line":1155},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19773,"high_pc":19778,"call_file":30,"call_line":1156,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19773,"high_pc":19778,"call_file":30,"call_line":1694}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6pinuse17h6b40df78c340a4ccE","low_pc":19778,"high_pc":19787,"call_file":30,"call_line":1157},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","low_pc":19789,"high_pc":19794,"call_file":30,"call_line":1160},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[19831,19872],[19934,19966]],"call_file":30,"call_line":1172,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":19831,"high_pc":19837,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[19839,19872],[19947,19966]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[19947,19956],[19961,19966]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":19956,"high_pc":19961,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","low_pc":19894,"high_pc":19932,"call_file":30,"call_line":1175,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":19894,"high_pc":19912,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":19912,"high_pc":19932,"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":19922,"high_pc":19932,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":19922,"high_pc":19927,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19922,"high_pc":19927,"call_file":30,"call_line":1694}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12minus_offset17h4de8cd08cd30e1baE","low_pc":19821,"high_pc":19826,"call_file":30,"call_line":1168,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":19821,"high_pc":19826,"call_file":30,"call_line":1698}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk6cinuse17h05c4d1126a28049cE","low_pc":19967,"high_pc":19995,"call_file":30,"call_line":1181},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","low_pc":20019,"high_pc":20024,"call_file":30,"call_line":1202},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc12unlink_chunk17hbf90af258f171a24E","ranges":[[20031,20072],[20378,20410]],"call_file":30,"call_line":1204,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":20031,"high_pc":20037,"call_file":30,"call_line":1066},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18unlink_small_chunk17hc011bd01452e2400E","ranges":[[20039,20072],[20391,20410]],"call_file":30,"call_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc14clear_smallmap17h7d1484e843072b39E","ranges":[[20391,20400],[20405,20410]],"call_file":30,"call_line":1081},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":20400,"high_pc":20405,"call_file":30,"call_line":1076}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":20411,"high_pc":20431,"call_file":30,"call_line":1205,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":20421,"high_pc":20431,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":20421,"high_pc":20426,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20421,"high_pc":20426,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","low_pc":20073,"high_pc":20108,"call_file":30,"call_line":1212,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","low_pc":20073,"high_pc":20086,"call_file":30,"call_line":1684},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":20086,"high_pc":20108,"call_file":30,"call_line":1685,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":20096,"high_pc":20108,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":20096,"high_pc":20101,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20096,"high_pc":20101,"call_file":30,"call_line":1694}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11should_trim17hcfe13c2b013de77fE","low_pc":20180,"high_pc":20191,"call_file":30,"call_line":1191},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8sys_trim17ha61c3ad311f02ae6E","ranges":[[20193,20327],[20461,20487]],"call_file":30,"call_line":1192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc15segment_holding17hd22d05e403f878a0E","low_pc":20225,"high_pc":20274,"call_file":30,"call_line":1239,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc7Segment3top17h90938e835d27d394E","low_pc":20249,"high_pc":20257,"call_file":30,"call_line":807,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","ranges":[[20249,20251],[20256,20257]],"call_file":30,"call_line":1753}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc23release_unused_segments17h13ba5a04f8b39dabE","ranges":[[20274,20327],[20461,20469]],"call_file":30,"call_line":1263}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","low_pc":20356,"high_pc":20376,"call_file":30,"call_line":1199,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","low_pc":20366,"high_pc":20376,"call_file":30,"call_line":1680,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","low_pc":20366,"high_pc":20371,"call_file":30,"call_line":1689,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","low_pc":20366,"high_pc":20371,"call_file":30,"call_line":1694}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc8is_small17h1694ff25bc0afe65E","low_pc":20489,"high_pc":20505,"call_file":30,"call_line":1215},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18insert_small_chunk17haa186229e095bfa9E","ranges":[[20507,20562],[20650,20700]],"call_file":30,"call_line":1216,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11smallbin_at17hbd59d73f009e2f02E","ranges":[[20507,20509],[20518,20525]],"call_file":30,"call_line":983,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","ranges":[[20507,20509],[20518,20525]],"call_file":30,"call_line":925,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","ranges":[[20507,20509],[20518,20525]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","ranges":[[20507,20509],[20518,20525]],"call_file":9,"call_line":2442,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","ranges":[[20507,20509],[20518,20525]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc18smallmap_is_marked17h9fa211d4e3d3560bE","low_pc":20525,"high_pc":20543,"call_file":30,"call_line":986},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc13mark_smallmap17h7cc0cadd135c1915E","low_pc":20650,"high_pc":20660,"call_file":30,"call_line":987},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc11small_index17he1e4de4989df8ca9E","low_pc":20509,"high_pc":20518,"call_file":30,"call_line":982}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN8dlmalloc8dlmalloc8Dlmalloc23release_unused_segments17h13ba5a04f8b39dabE","ranges":[[20596,20649],[20708,20719]],"call_file":30,"call_line":1223}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8Dlmalloc3new17h2f81d1d705292979E","name":"new","decl_file":30,"decl_line":110,"inline":"inlined"}]},{"tag":"structure_type","name":"Chunk","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"prev_foot","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"head","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"prev","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":8},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Chunk","alignment":4,"data_member_location":12},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk7mmapped17h7e94712027194190E","name":"mmapped","decl_file":30,"decl_line":1658,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk4size17h21492fe61333ae58E","name":"size","decl_file":30,"decl_line":1630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk20set_inuse_and_pinuse17ha967c9a4a5a44c0dE","name":"set_inuse_and_pinuse","decl_file":30,"decl_line":1668,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk11plus_offset17hf17badf57858ed4cE","name":"plus_offset","decl_file":30,"decl_line":1693,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk34set_size_and_pinuse_of_inuse_chunk17h24a55a200686bec5E","name":"set_size_and_pinuse_of_inuse_chunk","decl_file":30,"decl_line":1674,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk6to_mem17h3d68c7e88d1da68dE","name":"to_mem","decl_file":30,"decl_line":1701,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk33set_size_and_pinuse_of_free_chunk17h5e34163e4f841a8eE","name":"set_size_and_pinuse_of_free_chunk","decl_file":30,"decl_line":1678,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk8set_foot17h3e07918a0020faebE","name":"set_foot","decl_file":30,"decl_line":1688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk12clear_pinuse17h40528abe53d34ecdE","name":"clear_pinuse","decl_file":30,"decl_line":1650,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk20set_free_with_pinuse17h8e5920dc0cd2f03bE","name":"set_free_with_pinuse","decl_file":30,"decl_line":1683,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk5inuse17h0625b60691a7d515E","name":"inuse","decl_file":30,"decl_line":1654,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk6cinuse17h05c4d1126a28049cE","name":"cinuse","decl_file":30,"decl_line":1642,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk9set_inuse17h1f5ae01d2d06bbffE","name":"set_inuse","decl_file":30,"decl_line":1662,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk8from_mem17h5087eb4030617debE","name":"from_mem","decl_file":30,"decl_line":1705,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk6pinuse17h6b40df78c340a4ccE","name":"pinuse","decl_file":30,"decl_line":1646,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc5Chunk12minus_offset17h4de8cd08cd30e1baE","name":"minus_offset","decl_file":30,"decl_line":1697,"inline":"inlined"}]},{"tag":"structure_type","name":"TreeChunk","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"chunk","type":"Chunk","alignment":4,"data_member_location":0},{"tag":"member","name":"child","type":"*mut dlmalloc::dlmalloc::TreeChunk[]","alignment":4,"data_member_location":16},{"tag":"member","name":"parent","type":"*mut dlmalloc::dlmalloc::TreeChunk","alignment":4,"data_member_location":24},{"tag":"member","name":"index","type":"u32","alignment":4,"data_member_location":28},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc9TreeChunk14leftmost_child17h728d34272c7e1636E","name":"leftmost_child","decl_file":30,"decl_line":1711,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc9TreeChunk4next17h89899420d85f647aE","name":"next","decl_file":30,"decl_line":1724,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc9TreeChunk4prev17he46b5a421cc2bb87E","name":"prev","decl_file":30,"decl_line":1728,"inline":"inlined"}]},{"tag":"structure_type","name":"Segment","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"base","type":"*mut u8","alignment":4,"data_member_location":0},{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"next","type":"*mut dlmalloc::dlmalloc::Segment","alignment":4,"data_member_location":8},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":12},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc7Segment3top17h90938e835d27d394E","name":"top","decl_file":30,"decl_line":1752,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc7Segment9is_extern17h24874528bd9070f3E","name":"is_extern","decl_file":30,"decl_line":1736,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc7Segment5holds17h83fadaabb61c9063E","name":"holds","decl_file":30,"decl_line":1748,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc8align_up17hffae6dbaccabcf7cE","name":"align_up","decl_file":30,"decl_line":87,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc24leftshift_for_tree_index17h6d4885a7618d11b1E","name":"leftshift_for_tree_index","decl_file":30,"decl_line":100,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc9left_bits17h7d43f4655895cf43E","name":"left_bits","decl_file":30,"decl_line":92,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN8dlmalloc8dlmalloc9least_bit17h76b823ef1ac1c017E","name":"least_bit","decl_file":30,"decl_line":96,"inline":"inlined"}]},{"tag":"namespace","name":"sys","children":[{"tag":"subprogram","linkage_name":"_ZN8dlmalloc3sys5alloc17hbd81c4f7d4a82340E","name":"alloc","decl_file":31,"decl_line":8,"inline":"inlined"}]},{"tag":"structure_type","name":"Dlmalloc","byte_size":452,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Dlmalloc","alignment":4,"data_member_location":0}]}]},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::Chunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":66}]},{"tag":"pointer_type","type":"Chunk","name":"*mut dlmalloc::dlmalloc::Chunk"},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":32}]},{"tag":"pointer_type","type":"TreeChunk","name":"*mut dlmalloc::dlmalloc::TreeChunk"},{"tag":"array_type","type":"*mut dlmalloc::dlmalloc::TreeChunk","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":2}]},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"pointer_type","type":"Segment","name":"*mut dlmalloc::dlmalloc::Segment"},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"ptr","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h548ea89de552659bE","name":"offset<*mut dlmalloc::dlmalloc::Chunk>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h42bfa6cba9a28da6E","name":"add<*mut dlmalloc::dlmalloc::Chunk>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17hacb47c72537f0a7cE","name":"offset<*mut dlmalloc::dlmalloc::TreeChunk>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h93a01ee3f1a0c7f0E","name":"add<*mut dlmalloc::dlmalloc::TreeChunk>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h88f4d5a3df2cf746E","name":"offset<u8>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr65_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$$BP$mut$u20$T$GT$2le17h835c248213d3e8e3E","name":"le<u8>","decl_file":0,"decl_line":2657,"inline":"inlined"}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hf9b25b7693d28375E","name":"get_unchecked_mut<*mut dlmalloc::dlmalloc::Chunk>","decl_file":9,"decl_line":2441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h21c9cd2aad3225fbE","name":"get_unchecked_mut<*mut dlmalloc::dlmalloc::Chunk,usize>","decl_file":9,"decl_line":360,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hb7b5fedd03810e0dE","name":"get_unchecked_mut<*mut dlmalloc::dlmalloc::TreeChunk>","decl_file":9,"decl_line":2441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h08ff891c9a61a94eE","name":"get_unchecked_mut<*mut dlmalloc::dlmalloc::TreeChunk,usize>","decl_file":9,"decl_line":360,"inline":"inlined"}]}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$13leading_zeros17h5aea5f8e194e57aeE","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$14trailing_zeros17h39a966dd36d6cca4E","name":"trailing_zeros","decl_file":8,"decl_line":2279,"inline":"inlined"}]}]},{"tag":"namespace","name":"cmp","children":[{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u32$GT$2lt17h7e12d4f9e603d863E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","name":"le","decl_file":16,"decl_line":952,"inline":"inlined"}]}]},{"tag":"namespace","name":"Ord","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3max17h3612f62b3bfe1f21E","name":"max<usize>","decl_file":16,"decl_line":556,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3min17hcb95e795dd17e59cE","name":"min<*mut u8>","decl_file":16,"decl_line":573,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3min17h15d1c25e5d6b240dE","name":"min<usize>","decl_file":16,"decl_line":573,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3max17hb9bb2b6f80bf7eacE","name":"max<usize>","decl_file":16,"decl_line":857,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3min17h3c558b8aa2faa2ecE","name":"min<*mut u8>","decl_file":16,"decl_line":837,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3min17h1547d72f3d3a8d1eE","name":"min<usize>","decl_file":16,"decl_line":837,"inline":"inlined"}]},{"tag":"namespace","name":"iter","children":[{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17h8f0b51703ca53793E","name":"next<u32>","decl_file":32,"decl_line":221,"inline":"inlined"}]}]}]}]}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"liballoc/lib.rs","stmt_list":95161,"GNU_pubnames":true,"low_pc":0,"ranges":[[21106,21126],[21127,21129],[21131,21299],[21300,21317],[21674,21790],[21791,21846],[22014,22023],[22024,22039],[22041,22451],[21319,21673],[21848,21999],[22000,22013]],"children":[{"tag":"variable","name":"vtable","type":"vtable","location":"031C141000 // DW_OP_addr 0x10141c"},{"tag":"structure_type","containing_type":177621,"name":"vtable","byte_size":0,"alignment":4},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"Write","children":[{"tag":"namespace","name":"write_fmt","children":[{"tag":"structure_type","name":"Adapter<alloc::string::String>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut alloc::string::String","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":21300,"high_pc":21317,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h6d2bfe10d6e97d6fE","name":"write_char<alloc::string::String>","decl_file":15,"decl_line":217,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$10write_char17h5ae3f38b5c88c7ebE","low_pc":21306,"high_pc":21316,"call_file":15,"call_line":218}]},{"tag":"subprogram","low_pc":21674,"high_pc":21790,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_fmt17h1dd7eb7ab025d2aeE","name":"write_fmt<alloc::string::String>","decl_file":15,"decl_line":221,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17hfe23b3304d11bc37E","ranges":[[21694,21696],[21701,21776]],"call_file":15,"call_line":222}]},{"tag":"subprogram","low_pc":21791,"high_pc":21846,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h25f27d7f84e3ceb2E","name":"write_str<alloc::string::String>","decl_file":15,"decl_line":213,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$9write_str17h5482869985281e48E","low_pc":21799,"high_pc":21845,"call_file":15,"call_line":214,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String8push_str17h524abcd6952f7a86E","low_pc":21799,"high_pc":21845,"call_file":11,"call_line":2284,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17he7f0add5ae7e4bbaE","low_pc":21799,"high_pc":21845,"call_file":11,"call_line":808,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h9ef05981805ec3daE","low_pc":21799,"high_pc":21845,"call_file":4,"call_line":1329,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17he4f62155a7318ccaE","ranges":[[21809,21811],[21821,21824]],"call_file":4,"call_line":1893},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h19519c4a4ab2f22bE","ranges":[[21824,21826],[21831,21832]],"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h8f9396079bdae898E","ranges":[[21824,21826],[21831,21832]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hd266cebf36132e5fE","ranges":[[21824,21826],[21831,21832]],"call_file":9,"call_line":2575,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h7792ff42e8153a3eE","ranges":[[21824,21826],[21831,21832]],"call_file":9,"call_line":2491,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h3dd77ef306043551E","ranges":[[21824,21826],[21831,21832]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17hbccffcf9c29789fbE","low_pc":21826,"high_pc":21831,"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hcd98bce7ac4d70c5E","low_pc":21826,"high_pc":21831,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17hec19785b88c8a9aaE","low_pc":21832,"high_pc":21845,"call_file":4,"call_line":1894},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h983a9eae7f13977bE","low_pc":21811,"high_pc":21816,"call_file":4,"call_line":1892}]}]}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17hfe23b3304d11bc37E","name":"write_fmt<alloc::string::String>","decl_file":15,"decl_line":204,"inline":"inlined"}]},{"tag":"namespace","name":"rt","children":[{"tag":"namespace","name":"v1","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Alignment","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Left","const_value":0},{"tag":"enumerator","name":"Right","const_value":1},{"tag":"enumerator","name":"Center","const_value":2},{"tag":"enumerator","name":"Unknown","const_value":3}]},{"tag":"structure_type","name":"Argument","byte_size":36,"alignment":4,"children":[{"tag":"member","name":"position","type":"Position","alignment":4,"data_member_location":0},{"tag":"member","name":"format","type":"FormatSpec","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Position","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":178042,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Next","type":"Next","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"At","type":"At","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Next","byte_size":8,"alignment":4},{"tag":"structure_type","name":"At","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"FormatSpec","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":24},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"precision","type":"Count","alignment":4,"data_member_location":8},{"tag":"member","name":"width","type":"Count","alignment":4,"data_member_location":16}]},{"tag":"structure_type","name":"Count","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":178180,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Is","type":"Is","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Param","type":"Param","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"NextParam","type":"NextParam","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Implied","type":"Implied","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Is","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Param","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NextParam","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Implied","byte_size":8,"alignment":4}]}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN45_$LT$$LP$$RP$$u20$as$u20$core..fmt..Debug$GT$3fmt17h9e2b8e470868e824E","name":"fmt","decl_file":15,"decl_line":2106,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN48_$LT$$u5b$T$u5d$$u20$as$u20$core..fmt..Debug$GT$3fmt17h78e7a4972a4d88a5E","name":"fmt<u8>","decl_file":15,"decl_line":2098,"inline":"inlined"},{"tag":"subprogram","low_pc":21106,"high_pc":21126,"linkage_name":"_ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Display$GT$3fmt17h22bd0f72336def80E","name":"fmt<str>","decl_file":15,"decl_line":1914},{"tag":"namespace","name":"estimated_capacity","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments18estimated_capacity28_$u7b$$u7b$closure$u7d$$u7d$17hfdcc34c3d75a0f4dE","name":"{{closure}}","decl_file":15,"decl_line":381,"inline":"inlined"}]}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17hcf9174035eb5e775E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"}]}]},{"tag":"namespace","name":"builders","children":[{"tag":"structure_type","name":"DebugList","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"DebugInner","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17h8cdb2b6db7ceaf6dE","name":"entries<&u8,core::slice::Iter<u8>>","decl_file":39,"decl_line":421,"inline":"inlined"}]},{"tag":"structure_type","name":"DebugInner","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":4},{"tag":"member","name":"has_fields","type":"bool","alignment":1,"data_member_location":5}]}]},{"tag":"structure_type","name":"Formatter","byte_size":52,"alignment":4,"children":[{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":48},{"tag":"member","name":"width","type":"Option<usize>","alignment":4,"data_member_location":8},{"tag":"member","name":"precision","type":"Option<usize>","alignment":4,"data_member_location":16},{"tag":"member","name":"buf","type":"&mut Write","alignment":4,"data_member_location":24},{"tag":"member","name":"curarg","type":"Iter<core::fmt::ArgumentV1>","alignment":4,"data_member_location":32},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":40}]},{"tag":"structure_type","name":"&mut Write","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"structure_type","name":"ArgumentV1","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&core::fmt::Void","alignment":4,"data_member_location":0},{"tag":"member","name":"formatter","type":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Void","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_priv","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"_oibit_remover","type":"PhantomData<*mut Fn<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Arguments","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"pieces","type":"&[&str]","alignment":4,"data_member_location":0},{"tag":"member","name":"fmt","type":"Option<&[core::fmt::rt::v1::Argument]>","alignment":4,"data_member_location":8},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":16},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","name":"new_v1_formatted","decl_file":15,"decl_line":362,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments18estimated_capacity17h504ef990eb6e7b1bE","name":"estimated_capacity","decl_file":15,"decl_line":379,"inline":"inlined"}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"Unique<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<u8>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Unique<alloc::collections::btree::node::LeafNode<(), ()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const alloc::collections::btree::node::LeafNode<(), ()>>","alignment":4,"data_member_location":0},{"tag":"member","name":"_marker","type":"PhantomData<alloc::collections::btree::node::LeafNode<(), ()>>","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hbbd366b776892ce5E","name":"offset<u8>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h3dd77ef306043551E","name":"offset<u8>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h7792ff42e8153a3eE","name":"add<u8>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hd15de3d39b6fbfceE","name":"offset<&str>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hb78fdc71f9134ea3E","name":"add<&str>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hcfa7a5b6a81f7ee8E","name":"add<u8>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h1f4de4851ead491aE","name":"offset<u16>","decl_file":0,"decl_line":1079,"inline":"inlined"}]},{"tag":"subprogram","low_pc":21127,"high_pc":21129,"linkage_name":"_ZN4core3ptr13drop_in_place17h51f515a46490fc8fE","name":"drop_in_place<&u8>","decl_file":0,"decl_line":194},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb9d6c9e37d224ea3E","name":"drop_in_place<alloc::borrow::Cow<str>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h1a5de772f20e9a29E","name":"drop_in_place<alloc::raw_vec::RawVec<u8, alloc::alloc::Global>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h49ceec2c8054ef77E","name":"drop_in_place<alloc::vec::Vec<u8>>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17hb5e8b0922a36a5e4E","name":"drop_in_place<alloc::string::String>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h8ee707d88b5c61edE","name":"read<alloc::string::String>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hb0901fbde70aea10E","name":"swap_nonoverlapping_one<alloc::string::String>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17hae0e813171ae5155E","name":"write<u8>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h5bdd74375a409e23E","name":"drop_in_place<alloc::vec::SetLenOnDrop>","decl_file":0,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr4read17h5eb284eee9432ee9E","name":"read<alloc::raw_vec::RawVec<u8, alloc::alloc::Global>>","decl_file":0,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13drop_in_place17h2ede98b84aa2e458E","name":"drop_in_place<alloc::vec::Drain<u8>>","decl_file":0,"decl_line":194,"inline":"inlined"}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<*const alloc::collections::btree::node::LeafNode<(), ()>>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const alloc::collections::btree::node::LeafNode<(), ()>","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<alloc::collections::btree::node::LeafNode<(), ()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<*mut Fn<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&core::fmt::ArgumentV1>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&&str>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&u16>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"mem","children":[{"tag":"union_type","name":"MaybeUninit<u16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"uninit","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"value","type":"ManuallyDrop<u16>","alignment":2,"data_member_location":0}]},{"tag":"structure_type","name":"ManuallyDrop<u16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"value","type":"u16","alignment":2,"data_member_location":0}]},{"tag":"union_type","name":"MaybeUninit<[(); 11]>","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"uninit","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"value","type":"ManuallyDrop<[(); 11]>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ManuallyDrop<[(); 11]>","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"value","type":"()[]","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hfdaa2a6c2928e6a6E","name":"swap<alloc::string::String>","decl_file":10,"decl_line":610,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3mem7replace17h99146475e9786832E","name":"replace<alloc::string::String>","decl_file":10,"decl_line":669,"inline":"inlined"}]},{"tag":"namespace","name":"str","children":[{"tag":"structure_type","name":"Utf8Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"valid_up_to","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"error_len","type":"Option<u8>","alignment":1,"data_member_location":4}]},{"tag":"namespace","name":"traits","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"index","children":[]},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$5index17h269b7abc6966044bE","name":"index","decl_file":3,"decl_line":1940,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeTo$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hff9ba3639eb88e1aE","name":"index","decl_file":3,"decl_line":1707,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$3get17h41d6422e30080ed7E","name":"get","decl_file":3,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index17h6802cbf05d4f9b72E","name":"index","decl_file":3,"decl_line":1987,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeFrom$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hc500bce2e9274891E","name":"index","decl_file":3,"decl_line":1737,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$3get17hfaab8eba00b01ee1E","name":"get","decl_file":3,"decl_line":1959,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$13get_unchecked17ha395a38e6c0c4df4E","name":"get_unchecked","decl_file":3,"decl_line":1975,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3str15next_code_point17hf2fc475d11984804E","name":"next_code_point<core::slice::Iter<u8>>","decl_file":3,"decl_line":502,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h31769beda6688264E","name":"next","decl_file":3,"decl_line":570,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$core..str..CharIndices$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h9250e4d66959239aE","name":"next","decl_file":3,"decl_line":668,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","name":"is_char_boundary","decl_file":3,"decl_line":2187,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5chars17h17846ad5a6c66389E","name":"chars","decl_file":3,"decl_line":2631,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h67d22cbee9db1bcaE","name":"next_back","decl_file":3,"decl_line":609,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17ha60de47000ba59aeE","name":"size_hint","decl_file":3,"decl_line":591,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","name":"unwrap_or_0","decl_file":3,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","name":"utf8_acc_cont_byte","decl_file":3,"decl_line":483,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str23next_code_point_reverse17h6dddcd4b3ca4ca6bE","name":"next_code_point_reverse<core::slice::Iter<u8>>","decl_file":3,"decl_line":535,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str17utf8_is_cont_byte17h6c0ed45c25029789E","name":"utf8_is_cont_byte","decl_file":3,"decl_line":488,"inline":"inlined"},{"tag":"namespace","name":"pattern","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN80_$LT$$RF$$u27$b$u20$str$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17h6d184be00a8bbcbcE","name":"into_searcher","decl_file":46,"decl_line":720,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<u8>","byte_size":2,"alignment":1,"children":[{"tag":"variant_part","discr":179879,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":2,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]}]},{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":179954,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h57cfdd601d38a585E","name":"expect<usize>","decl_file":14,"decl_line":319,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&[core::fmt::rt::v1::Argument]>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":180042,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[core::fmt::rt::v1::Argument]","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&str>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":180116,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17h08d6e4f7570e819cE","name":"unwrap_or_else<&str,closure>","decl_file":14,"decl_line":393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17h5376b5109a11a7f5E","name":"unwrap_or_else<&str,closure>","decl_file":14,"decl_line":393,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<char>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":180216,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hc448ede1815f6a2eE","name":"map<char,core::char::EscapeDebug,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h1df3b6e9c7d038faE","name":"map<char,core::char::EscapeDefault,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h82ebf7142960d05fE","name":"map<char,core::char::EscapeUnicode,&mut closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::char::EscapeDebug>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":180332,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDebug","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h4fab859629043f99E","name":"as_mut<core::char::EscapeDebug>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut core::char::EscapeDebug>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":180419,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::char::EscapeDebug","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17he306a441499cce3dE","name":"and_then<&mut core::char::EscapeDebug,char,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::char::EscapeDefault>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":180506,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":4,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDefault","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17h2cc14f57a4824507E","name":"as_mut<core::char::EscapeDefault>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut core::char::EscapeDefault>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":180593,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::char::EscapeDefault","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17hcf4345553489a6d1E","name":"and_then<&mut core::char::EscapeDefault,char,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::char::EscapeUnicode>","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":180680,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":12,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeUnicode","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6as_mut17ha08474a7e3492c17E","name":"as_mut<core::char::EscapeUnicode>","decl_file":14,"decl_line":266,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&mut core::char::EscapeUnicode>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":180770,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::char::EscapeUnicode","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17haf394de51beabadfE","name":"and_then<&mut core::char::EscapeUnicode,char,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"cloned","children":[{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned28_$u7b$$u7b$closure$u7d$$u7d$17h0a61d41556d3daaaE","name":"{{closure}}<u16>","decl_file":14,"decl_line":902,"inline":"inlined"}]}]},{"tag":"structure_type","name":"Option<&u16>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":180882,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&u16","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hb8508bde9273b157E","name":"map<&u16,u16,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned17h0edd25663e7eed0eE","name":"cloned<u16>","decl_file":14,"decl_line":901,"inline":"inlined"}]}]},{"tag":"namespace","name":"char","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"EscapeUnicodeState","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Done","const_value":0},{"tag":"enumerator","name":"RightBrace","const_value":1},{"tag":"enumerator","name":"Value","const_value":2},{"tag":"enumerator","name":"LeftBrace","const_value":3},{"tag":"enumerator","name":"Type","const_value":4},{"tag":"enumerator","name":"Backslash","const_value":5}]},{"tag":"namespace","name":"methods","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$16escape_debug_ext17h1a540b8ae47edbc9E","name":"escape_debug_ext","decl_file":18,"decl_line":196,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$20is_grapheme_extended17h4b971a495728c8c1E","name":"is_grapheme_extended","decl_file":18,"decl_line":713,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_unicode17h0dce6bdf98b58dc9E","name":"escape_unicode","decl_file":18,"decl_line":173,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_default17hd5995f842e3202cbE","name":"escape_default","decl_file":18,"decl_line":302,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","name":"len_utf8","decl_file":18,"decl_line":361,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","name":"encode_utf8","decl_file":18,"decl_line":438,"inline":"inlined"}]}]},{"tag":"structure_type","name":"EscapeDebug","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeDefault","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"EscapeDefault","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"state","type":"EscapeDefaultState","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"EscapeDefaultState","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":181162,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Done","type":"Done","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Char","type":"Char","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Backslash","type":"Backslash","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Unicode","type":"Unicode","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Done","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Char","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Backslash","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Unicode","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeUnicode","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"EscapeUnicode","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"c","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"state","type":"EscapeUnicodeState","alignment":1,"data_member_location":8},{"tag":"member","name":"hex_digit_idx","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"namespace","name":"decode","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..char..decode..DecodeUtf16$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h94faeed34b78af74E","name":"next<core::iter::Cloned<core::slice::Iter<u16>>>","decl_file":120,"decl_line":90,"inline":"inlined"}]},{"tag":"structure_type","name":"DecodeUtf16Error","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"code","type":"u16","alignment":2,"data_member_location":0}]}]}]},{"tag":"namespace","name":"result","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Result","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Ok","const_value":0},{"tag":"enumerator","name":"Err","const_value":1},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h871f9ef4048c622aE","name":"expect<(),core::fmt::Error>","decl_file":6,"decl_line":832,"inline":"inlined"}]},{"tag":"subprogram","low_pc":21131,"high_pc":21299,"linkage_name":"_ZN4core6result13unwrap_failed17h6434edfa6b9333a4E","name":"unwrap_failed<core::fmt::Error>","decl_file":6,"decl_line":1008,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[21187,21210],[21221,21250],[21270,21280]],"call_file":7,"call_line":26}]},{"tag":"structure_type","name":"Result<(), alloc::collections::CollectionAllocErr>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":181462,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Err","type":"Err","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Err","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"CollectionAllocErr","alignment":1,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17h269e79f2d8a38d0cE","name":"unwrap_or_else<(),alloc::collections::CollectionAllocErr,closure>","decl_file":6,"decl_line":771,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN137_$LT$core..result..Result$LT$V$C$$u20$E$GT$$u20$as$u20$core..iter..traits..FromIterator$LT$core..result..Result$LT$A$C$$u20$E$GT$$GT$$GT$9from_iter17h2d74cc2397c2ec1fE","name":"from_iter<char,core::char::decode::DecodeUtf16Error,alloc::string::String,core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>>","decl_file":6,"decl_line":1218,"inline":"inlined"},{"tag":"namespace","name":"from_iter","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN228_$LT$$LT$core..result..Result$LT$V$C$$u20$E$GT$$u20$as$u20$core..iter..traits..FromIterator$LT$core..result..Result$LT$A$C$$u20$E$GT$$GT$$GT$..from_iter..Adapter$LT$Iter$C$$u20$E$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha2f20656d162e84bE","name":"next<char,core::char::decode::DecodeUtf16Error,core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>>","decl_file":6,"decl_line":1231,"inline":"inlined"}]}]}]},{"tag":"structure_type","name":"Result<alloc::string::String, core::char::decode::DecodeUtf16Error>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":181605,"children":[{"tag":"member","type":"u16","alignment":2,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Ok","type":"Ok","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Err","type":"Err","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Ok","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Err","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"DecodeUtf16Error","alignment":2,"data_member_location":2}]},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$7map_err17h7eb7a2f2616a1a66E","name":"map_err<alloc::string::String,core::char::decode::DecodeUtf16Error,alloc::string::FromUtf16Error,closure>","decl_file":6,"decl_line":527,"inline":"inlined"}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h41c6479677c1d524E","name":"next<u8>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hd266cebf36132e5fE","name":"get_unchecked_mut<u8>","decl_file":9,"decl_line":2490,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h8f9396079bdae898E","name":"get_unchecked_mut<u8>","decl_file":9,"decl_line":2574,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h19519c4a4ab2f22bE","name":"get_unchecked_mut<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":360,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17hec19785b88c8a9aaE","name":"copy_from_slice<u8>","decl_file":9,"decl_line":1957,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17he4d01d66fabbaac0E","name":"iter<&str>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h284d7acb6d7ca5ccE","name":"next<&str>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold17hd36deb97bff060c0E","name":"fold<&str,usize,closure>","decl_file":9,"decl_line":2899,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$16clone_from_slice17h4cc4a230cbaac689E","name":"clone_from_slice<u8>","decl_file":9,"decl_line":1888,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hc7c1aa2677e788a5E","name":"get_unchecked<u8>","decl_file":9,"decl_line":2485,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hc158230dda8ddfe0E","name":"index<u8>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hd584e3c914175df6E","name":"index<u8>","decl_file":9,"decl_line":2579,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h06b99fda118e031aE","name":"index<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h1feaec11232a56a9E","name":"get<u8>","decl_file":9,"decl_line":2414,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17hba5c6c6b0391e414E","name":"get<u8,usize>","decl_file":9,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h85252bb6f780e04aE","name":"get_unchecked<u8>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h01a4d6a9827ca407E","name":"iter<u8>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h99c9d64bf510cd21E","name":"next_back<u8>","decl_file":9,"decl_line":2951,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h708fd3740f909fb5E","name":"next<u16>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h238c0dc3c8f2e692E","name":"iter<u16>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17h2228f61c4f6b9053E","name":"len<u8>","decl_file":9,"decl_line":2811,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<core::fmt::ArgumentV1>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&core::fmt::ArgumentV1>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Iter<u8>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u8","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h11b4c500beb26938E","name":"post_inc_start<u8>","decl_file":9,"decl_line":2781,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$11pre_dec_end17ha6881006915ca40aE","name":"pre_dec_end<u8>","decl_file":9,"decl_line":2797,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<&str>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const &str","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&&str>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hd5b68f4c8b2cb3c9E","name":"post_inc_start<&str>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<u16>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u16","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u16","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u16>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h491330c9f611fbf5E","name":"post_inc_start<u16>","decl_file":9,"decl_line":2781,"inline":"inlined"}]}]},{"tag":"namespace","name":"cmp","children":[{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"}]}]},{"tag":"namespace","name":"Ord","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3max17hbf30017324da2d59E","name":"max<usize>","decl_file":16,"decl_line":556,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3max17hf23ba106b3c80562E","name":"max<usize>","decl_file":16,"decl_line":857,"inline":"inlined"}]},{"tag":"namespace","name":"iter","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold17h09d4ff759d167a50E","name":"fold<usize,core::slice::Iter<&str>,closure,usize,fn(usize, usize) -> usize>","decl_file":52,"decl_line":1409,"inline":"inlined"},{"tag":"namespace","name":"fold","children":[{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold28_$u7b$$u7b$closure$u7d$$u7d$17ha63ee0d5f9d8a295E","name":"{{closure}}<usize,core::slice::Iter<&str>,closure,usize,fn(usize, usize) -> usize>","decl_file":52,"decl_line":1413,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4find17h03fb64153429ef58E","name":"find<core::str::Chars,closure>","decl_file":52,"decl_line":444,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..SkipWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hed30ce4994a27235E","name":"next<core::iter::Rev<core::str::Chars>,closure>","decl_file":52,"decl_line":2076,"inline":"inlined"},{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..SkipWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h828657fb77374180E","name":"{{closure}}<core::iter::Rev<core::str::Chars>,closure>","decl_file":52,"decl_line":2079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..SkipWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17he8cc416e35d99cf8E","name":"{{closure}}<core::str::Chars,closure>","decl_file":52,"decl_line":2079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h40268b80de547381E","name":"{{closure}}<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h08bc8545ded64046E","name":"{{closure}}<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDefault>","decl_file":52,"decl_line":2687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h48b2b05cdbc8ffbfE","name":"{{closure}}<core::iter::Map<core::str::Chars, closure>,core::char::EscapeUnicode>","decl_file":52,"decl_line":2687,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..SkipWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h83b50c46c9a77ae4E","name":"next<core::str::Chars,closure>","decl_file":52,"decl_line":2076,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17heae4aa4405f3dabfE","name":"next<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDebug>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h270f57e6e6c979d8E","name":"next<core::str::Chars,core::char::EscapeDebug,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hedd938d58053cd43E","name":"next<core::char::EscapeDebug,core::str::Chars,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h50ea118d1c07168dE","name":"next<core::iter::Map<core::str::Chars, closure>,core::char::EscapeDefault>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf6f84f6d3b5037fdE","name":"next<core::str::Chars,core::char::EscapeDefault,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h24352876cd8fa4fdE","name":"next<core::char::EscapeDefault,core::str::Chars,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..iter..FlattenCompat$LT$I$C$$u20$U$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h4655dec285f8ea1bE","name":"next<core::iter::Map<core::str::Chars, closure>,core::char::EscapeUnicode>","decl_file":52,"decl_line":2681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN97_$LT$core..iter..FlatMap$LT$I$C$$u20$U$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hd39fe2607de170f9E","name":"next<core::str::Chars,core::char::EscapeUnicode,closure>","decl_file":52,"decl_line":2523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h58260012aa4115d4E","name":"next<core::char::EscapeUnicode,core::str::Chars,closure>","decl_file":52,"decl_line":1393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h00866a9a15d169ccE","name":"next<core::slice::Iter<u16>,u16>","decl_file":52,"decl_line":523,"inline":"inlined"}]},{"tag":"namespace","name":"traits","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN49_$LT$usize$u20$as$u20$core..iter..traits..Sum$GT$3sum17h66ff8666be35a433E","name":"sum<core::iter::Map<core::slice::Iter<&str>, closure>>","decl_file":53,"decl_line":778,"inline":"inlined"}]},{"tag":"namespace","name":"DoubleEndedIterator","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter6traits19DoubleEndedIterator9try_rfold17h41e2d0c417f978a8E","name":"try_rfold<core::str::Chars,(),closure,core::iter::LoopState<(), char>>","decl_file":53,"decl_line":464,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter6traits19DoubleEndedIterator5rfind17h69d1de3ad9cd4a18E","name":"rfind<core::str::Chars,closure>","decl_file":53,"decl_line":577,"inline":"inlined"},{"tag":"namespace","name":"rfind","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter6traits19DoubleEndedIterator5rfind28_$u7b$$u7b$closure$u7d$$u7d$17h5d96ecdf5a9070fbE","name":"{{closure}}<core::str::Chars,closure>","decl_file":53,"decl_line":581,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"iterator","children":[{"tag":"namespace","name":"Iterator","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3sum17hf7f7f14ca1bb8f84E","name":"sum<core::iter::Map<core::slice::Iter<&str>, closure>,usize>","decl_file":36,"decl_line":2319,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator8try_fold17hecda33806f0cb572E","name":"try_fold<core::str::Chars,(),closure,core::iter::LoopState<(), char>>","decl_file":36,"decl_line":1578,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each17hc15e046a80e31512E","name":"try_for_each<core::str::Chars,closure,core::iter::LoopState<(), char>>","decl_file":36,"decl_line":1617,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4find17hf34646b85bb29e05E","name":"find<core::str::Chars,closure>","decl_file":36,"decl_line":1839,"inline":"inlined"},{"tag":"namespace","name":"find","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4find28_$u7b$$u7b$closure$u7d$$u7d$17hb3dd01bfe648db11E","name":"{{closure}}<core::str::Chars,closure>","decl_file":36,"decl_line":1843,"inline":"inlined"}]},{"tag":"namespace","name":"try_for_each","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each28_$u7b$$u7b$closure$u7d$$u7d$17h62df94a950b303f5E","name":"{{closure}}<core::str::Chars,closure,core::iter::LoopState<(), char>>","decl_file":36,"decl_line":1620,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator7collect17h092fe94eb44a6d24E","name":"collect<core::iter::FlatMap<core::str::Chars, core::char::EscapeDefault, closure>,alloc::string::String>","decl_file":36,"decl_line":1475,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator7collect17h1e8a119b7ccebfedE","name":"collect<core::iter::FlatMap<core::str::Chars, core::char::EscapeUnicode, closure>,alloc::string::String>","decl_file":36,"decl_line":1475,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator7collect17hcc8142cb80946cd3E","name":"collect<core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>,core::result::Result<alloc::string::String, core::char::decode::DecodeUtf16Error>>","decl_file":36,"decl_line":1475,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h7842ed1fd0e46380E","name":"next<core::result::{{impl}}::from_iter::Adapter<core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>, core::char::decode::DecodeUtf16Error>>","decl_file":36,"decl_line":2623,"inline":"inlined"}]}]},{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hee78d6d2c321cc14E","name":"next<usize>","decl_file":32,"decl_line":221,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"arith","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Add$GT$3add17h72a67337577eb51cE","name":"add","decl_file":34,"decl_line":110,"inline":"inlined"}]}]},{"tag":"namespace","name":"function","children":[{"tag":"namespace","name":"FnMut","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5FnMut8call_mut17h4bbebfd33a486d36E","name":"call_mut<fn(usize, usize) -> usize,(usize, usize)>","decl_file":50,"decl_line":156,"inline":"inlined"}]},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17hb97ac00ff0e12510E","name":"call_once<(char),closure>","decl_file":50,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17hc974f0dfe1ce7594E","name":"call_once<(char),closure>","decl_file":50,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5impls80_$LT$impl$u20$core..ops..function..FnOnce$LT$A$GT$$u20$for$u20$$RF$mut$u20$F$GT$9call_once17hed00b817409e48ebE","name":"call_once<(char),closure>","decl_file":50,"decl_line":285,"inline":"inlined"}]}]}]}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_mul17hcf1db6cc43b48612E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_mul17h848f1b83517064d7E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"}]}]},{"tag":"namespace","name":"clone","children":[{"tag":"namespace","name":"Clone","children":[{"tag":"subprogram","linkage_name":"_ZN4core5clone5Clone10clone_from17h1170b581fbfc41c2E","name":"clone_from<u8>","decl_file":47,"decl_line":130,"inline":"inlined"}]},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls52_$LT$impl$u20$core..clone..Clone$u20$for$u20$u16$GT$5clone17h11830ab7db8b5d5dE","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"}]}]}]}]},{"tag":"pointer_type","type":"String","name":"&mut alloc::string::String"},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"string","children":[{"tag":"structure_type","name":"String","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"vec","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String8push_str17h524abcd6952f7a86E","name":"push_str","decl_file":11,"decl_line":807,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String13with_capacity17h3ad6923bd9e8befbE","name":"with_capacity","decl_file":11,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String7reserve17hee500a215266f044E","name":"reserve","decl_file":11,"decl_line":875,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String3new17ha36327193e5f3a5fE","name":"new","decl_file":11,"decl_line":384,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String19from_utf8_unchecked17h098f222982cf20a0E","name":"from_utf8_unchecked","decl_file":11,"decl_line":731,"inline":"inlined"},{"tag":"subprogram","low_pc":21319,"high_pc":21673,"linkage_name":"_ZN5alloc6string6String4push17h282a1665f9952b5fE","name":"push","decl_file":11,"decl_line":1067,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","ranges":[[21339,21351],[21430,21442]],"call_file":11,"call_line":1068},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$4push17h4ae90db2a0ef5570E","low_pc":21351,"high_pc":21422,"call_file":11,"call_line":1069,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17ha98c0225583635f7E","low_pc":21358,"high_pc":21365,"call_file":4,"call_line":998},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17hbccffcf9c29789fbE","low_pc":21378,"high_pc":21394,"call_file":4,"call_line":1002,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hcd98bce7ac4d70c5E","low_pc":21389,"high_pc":21394,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h7792ff42e8153a3eE","low_pc":21394,"high_pc":21397,"call_file":4,"call_line":1002,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h3dd77ef306043551E","low_pc":21394,"high_pc":21397,"call_file":0,"call_line":1938}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr5write17hae0e813171ae5155E","low_pc":21397,"high_pc":21402,"call_file":4,"call_line":1003}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","low_pc":21442,"high_pc":21612,"call_file":11,"call_line":1070},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17he7f0add5ae7e4bbaE","low_pc":21613,"high_pc":21660,"call_file":11,"call_line":1070,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h9ef05981805ec3daE","low_pc":21613,"high_pc":21660,"call_file":4,"call_line":1329,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17he4f62155a7318ccaE","ranges":[[21623,21625],[21635,21638]],"call_file":4,"call_line":1893},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h19519c4a4ab2f22bE","ranges":[[21638,21640],[21645,21646]],"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h8f9396079bdae898E","ranges":[[21638,21640],[21645,21646]],"call_file":9,"call_line":363,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17hd266cebf36132e5fE","ranges":[[21638,21640],[21645,21646]],"call_file":9,"call_line":2575,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h7792ff42e8153a3eE","ranges":[[21638,21640],[21645,21646]],"call_file":9,"call_line":2491,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h3dd77ef306043551E","ranges":[[21638,21640],[21645,21646]],"call_file":0,"call_line":1938}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17hbccffcf9c29789fbE","low_pc":21640,"high_pc":21645,"call_file":4,"call_line":1894,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hcd98bce7ac4d70c5E","low_pc":21640,"high_pc":21645,"call_file":4,"call_line":1689}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17hec19785b88c8a9aaE","low_pc":21646,"high_pc":21660,"call_file":4,"call_line":1894},{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h983a9eae7f13977bE","low_pc":21625,"high_pc":21630,"call_file":4,"call_line":1892}]}]}]},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String3len17h4a775f27be010a3eE","name":"len","decl_file":11,"decl_line":1377,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String14into_boxed_str17h441fb8ab47b349b7E","name":"into_boxed_str","decl_file":11,"decl_line":1590,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc6string6String10into_bytes17h52b2e4e832df4c22E","name":"into_bytes","decl_file":11,"decl_line":751,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$10write_char17h5ae3f38b5c88c7ebE","name":"write_char","decl_file":11,"decl_line":2289,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$alloc..string..String$u20$as$u20$core..fmt..Write$GT$9write_str17h5482869985281e48E","name":"write_str","decl_file":11,"decl_line":2283,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$alloc..string..String$u20$as$u20$core..ops..index..Index$LT$core..ops..range..RangeFull$GT$$GT$5index17h2ab774163840a2c7E","name":"index","decl_file":11,"decl_line":1971,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..string..String$u20$as$u20$core..iter..traits..Extend$LT$char$GT$$GT$6extend17h7d316502ea5e06c2E","name":"extend<core::char::EscapeDebug>","decl_file":11,"decl_line":1742,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..string..String$u20$as$u20$core..iter..traits..Extend$LT$char$GT$$GT$6extend17h1d8da9cd30316d8dE","name":"extend<core::iter::FlatMap<core::str::Chars, core::char::EscapeDebug, closure>>","decl_file":11,"decl_line":1742,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$alloc..string..String$u20$as$u20$core..iter..traits..FromIterator$LT$char$GT$$GT$9from_iter17h64f686bce2b1ec6aE","name":"from_iter<core::iter::FlatMap<core::str::Chars, core::char::EscapeDefault, closure>>","decl_file":11,"decl_line":1697,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..string..String$u20$as$u20$core..iter..traits..Extend$LT$char$GT$$GT$6extend17he71d2e6d425b4ac8E","name":"extend<core::iter::FlatMap<core::str::Chars, core::char::EscapeDefault, closure>>","decl_file":11,"decl_line":1742,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$alloc..string..String$u20$as$u20$core..iter..traits..FromIterator$LT$char$GT$$GT$9from_iter17h064ed5dca0706da6E","name":"from_iter<core::iter::FlatMap<core::str::Chars, core::char::EscapeUnicode, closure>>","decl_file":11,"decl_line":1697,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..string..String$u20$as$u20$core..iter..traits..Extend$LT$char$GT$$GT$6extend17hf3c18c66139e998fE","name":"extend<core::iter::FlatMap<core::str::Chars, core::char::EscapeUnicode, closure>>","decl_file":11,"decl_line":1742,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$alloc..string..String$u20$as$u20$core..iter..traits..FromIterator$LT$char$GT$$GT$9from_iter17hbd9e66e40cce5cdeE","name":"from_iter<&mut core::result::{{impl}}::from_iter::Adapter<core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>, core::char::decode::DecodeUtf16Error>>","decl_file":11,"decl_line":1697,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..string..String$u20$as$u20$core..iter..traits..Extend$LT$char$GT$$GT$6extend17he99ef6cdd038b531E","name":"extend<&mut core::result::{{impl}}::from_iter::Adapter<core::char::decode::DecodeUtf16<core::iter::Cloned<core::slice::Iter<u16>>>, core::char::decode::DecodeUtf16Error>>","decl_file":11,"decl_line":1742,"inline":"inlined"}]},{"tag":"structure_type","name":"FromUtf8Error","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"bytes","type":"Vec<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"error","type":"Utf8Error","alignment":4,"data_member_location":12}]}]},{"tag":"namespace","name":"vec","children":[{"tag":"structure_type","name":"Vec<u8>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"RawVec<u8, alloc::alloc::Global>","alignment":4,"data_member_location":0},{"tag":"member","name":"len","type":"usize","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17extend_from_slice17he7f0add5ae7e4bbaE","name":"extend_from_slice<u8>","decl_file":4,"decl_line":1328,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7set_len17he4f62155a7318ccaE","name":"set_len<u8>","decl_file":4,"decl_line":796,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$3len17h983a9eae7f13977bE","name":"len<u8>","decl_file":4,"decl_line":1168,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13with_capacity17h0fcf663fa1cf463cE","name":"with_capacity<u8>","decl_file":4,"decl_line":366,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17h163527729f34baecE","name":"reserve<u8>","decl_file":4,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$8truncate17h764e0e6834513e6bE","name":"truncate<u8>","decl_file":4,"decl_line":698,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$11try_reserve17hdf90b6abaa111bc6E","name":"try_reserve<u8>","decl_file":4,"decl_line":531,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$17try_reserve_exact17h3226a24d1f9c9be5E","name":"try_reserve_exact<u8>","decl_file":4,"decl_line":571,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$4push17h4ae90db2a0ef5570E","name":"push<u8>","decl_file":4,"decl_line":995,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$8as_slice17h0b0e5d62721f4db3E","name":"as_slice<u8>","decl_file":4,"decl_line":730,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13shrink_to_fit17h155a64eb3e66d8dfE","name":"shrink_to_fit<u8>","decl_file":4,"decl_line":590,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$16into_boxed_slice17h3473c338115e499dE","name":"into_boxed_slice<u8>","decl_file":4,"decl_line":646,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$5drain17hcfab551337dfc561E","name":"drain<u8,core::ops::range::Range<usize>>","decl_file":4,"decl_line":1094,"inline":"inlined"},{"tag":"subprogram","low_pc":21848,"high_pc":21999,"abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$7reserve17h163527729f34baecE","children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17h8b74556b72c20709E","ranges":[[21848,21858],[21865,21997]],"call_file":4,"call_line":470,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h745f6c8736aeea0fE","ranges":[[21848,21858],[21865,21971],[21980,21997]],"call_file":13,"call_line":502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17ha98c0225583635f7E","low_pc":21848,"high_pc":21858,"call_file":13,"call_line":661},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":21865,"high_pc":21868,"call_file":13,"call_line":661},{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h632c86e24689150dE","low_pc":21887,"high_pc":21908,"call_file":13,"call_line":668,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3max17hf23ba106b3c80562E","low_pc":21894,"high_pc":21908,"call_file":13,"call_line":440,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3max17hbf30017324da2d59E","low_pc":21894,"high_pc":21908,"call_file":16,"call_line":858,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","ranges":[[21894,21896],[21898,21903]],"call_file":16,"call_line":558}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7realloc17h126027d72628d920E","low_pc":21925,"high_pc":21937,"call_file":13,"call_line":677,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc7realloc17h61188e90de5f7cdaE","low_pc":21925,"high_pc":21937,"call_file":12,"call_line":169}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17h1b32f98fc464f104E","low_pc":21945,"high_pc":21955,"call_file":13,"call_line":679,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","low_pc":21945,"high_pc":21955,"call_file":12,"call_line":154}]}]}]}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN68_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17hd4d264ffb6c78cd5E","name":"deref<u8>","decl_file":4,"decl_line":1676,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN61_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17he6236c0d9eb44252E","name":"fmt<u8>","decl_file":4,"decl_line":2130,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN139_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$alloc..vec..SpecExtend$LT$$RF$$u27$a$u20$T$C$$u20$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$$GT$11spec_extend17h9ef05981805ec3daE","name":"spec_extend<u8>","decl_file":4,"decl_line":1888,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..deref..DerefMut$GT$9deref_mut17hbccffcf9c29789fbE","name":"deref_mut<u8>","decl_file":4,"decl_line":1687,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN95_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..iter..traits..Extend$LT$$RF$$u27$a$u20$T$GT$$GT$6extend17h717018f12891a353E","name":"extend<u8,&[u8]>","decl_file":4,"decl_line":2040,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..ops..index..Index$LT$I$GT$$GT$5index17h8349294eba8d73e4E","name":"index<u8,core::ops::range::RangeFull>","decl_file":4,"decl_line":1652,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hed8ebc45fca94bd0E","name":"clone<u8>","decl_file":4,"decl_line":1614,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN80_$LT$alloc..vec..SetLenOnDrop$LT$$u27$a$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17hbeea29b3c8effdacE","name":"drop","decl_file":4,"decl_line":1457,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..clone..Clone$GT$10clone_from17h842b512a4c09765aE","name":"clone_from<u8>","decl_file":4,"decl_line":1627,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN82_$LT$alloc..vec..Drain$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h2bd27cee417dc4a5E","name":"drop<u8>","decl_file":4,"decl_line":2479,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$alloc..vec..Vec$LT$T$GT$$u20$as$u20$core..convert..From$LT$$RF$$u27$a$u20$$u5b$T$u5d$$GT$$GT$4from17h0369b79f0a756ee5E","name":"from<u8>","decl_file":4,"decl_line":2166,"inline":"inlined"}]}]},{"tag":"namespace","name":"raw_vec","children":[{"tag":"structure_type","name":"RawVec<u8, alloc::alloc::Global>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<u8>","alignment":4,"data_member_location":0},{"tag":"member","name":"cap","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"a","type":"Global","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3ptr17hcd98bce7ac4d70c5E","name":"ptr<u8,alloc::alloc::Global>","decl_file":13,"decl_line":207,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in17h77563f87339e0cddE","name":"allocate_in<u8,alloc::alloc::Global>","decl_file":13,"decl_line":90,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$13with_capacity17ha0d22379dcf42a9dE","name":"with_capacity<u8>","decl_file":13,"decl_line":149,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$16reserve_internal17h745f6c8736aeea0fE","name":"reserve_internal<u8,alloc::alloc::Global>","decl_file":13,"decl_line":644,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$7reserve17h8b74556b72c20709E","name":"reserve<u8,alloc::alloc::Global>","decl_file":13,"decl_line":501,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14dealloc_buffer17h1b50420b48e196afE","name":"dealloc_buffer<u8,alloc::alloc::Global>","decl_file":13,"decl_line":716,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$18amortized_new_size17h632c86e24689150dE","name":"amortized_new_size<u8,alloc::alloc::Global>","decl_file":13,"decl_line":432,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$14current_layout17hd4ba8985db04c35bE","name":"current_layout<u8,alloc::alloc::Global>","decl_file":13,"decl_line":233,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$3cap17ha98c0225583635f7E","name":"cap<u8,alloc::alloc::Global>","decl_file":13,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11try_reserve17ha3a2179bcd2bbff7E","name":"try_reserve<u8,alloc::alloc::Global>","decl_file":13,"decl_line":444,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$17try_reserve_exact17h89469e3b7a9a7048E","name":"try_reserve_exact<u8,alloc::alloc::Global>","decl_file":13,"decl_line":395,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$13shrink_to_fit17h33e533275a07b0d7E","name":"shrink_to_fit<u8,alloc::alloc::Global>","decl_file":13,"decl_line":577,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"allocate_in","children":[{"tag":"subprogram","low_pc":22014,"high_pc":22023,"linkage_name":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in28_$u7b$$u7b$closure$u7d$$u7d$17h0eea8e6ea1e88040E","name":"{{closure}}<u8,alloc::alloc::Global>","decl_file":13,"decl_line":95}]},{"tag":"subprogram","linkage_name":"_ZN82_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$u20$as$u20$core..ops..drop..Drop$GT$4drop17h44c5c3a0d3a45f2cE","name":"drop<u8,alloc::alloc::Global>","decl_file":13,"decl_line":728,"inline":"inlined"}]},{"tag":"subprogram","low_pc":22024,"high_pc":22039,"linkage_name":"_ZN5alloc7raw_vec17capacity_overflow17h11aa78a4247f8164E","name":"capacity_overflow","decl_file":13,"decl_line":756,"external":true,"noreturn":true}]},{"tag":"namespace","name":"alloc","children":[{"tag":"structure_type","name":"Global","byte_size":0,"alignment":1},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","name":"alloc","decl_file":12,"decl_line":77,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17h1b32f98fc464f104E","name":"alloc","decl_file":12,"decl_line":153,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7dealloc17hbca15eebd4396dadE","name":"dealloc","decl_file":12,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$7realloc17h126027d72628d920E","name":"realloc","decl_file":12,"decl_line":163,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc7dealloc17h2fcbc54b88dd0c9bE","name":"dealloc","decl_file":12,"decl_line":95,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5alloc7realloc17h61188e90de5f7cdaE","name":"realloc","decl_file":12,"decl_line":113,"inline":"inlined"},{"tag":"subprogram","low_pc":22000,"high_pc":22013,"linkage_name":"_ZN5alloc5alloc18handle_alloc_error17ha3f7604094647600E","name":"handle_alloc_error","decl_file":12,"decl_line":224,"external":true,"noreturn":true}]},{"tag":"namespace","name":"collections","children":[{"tag":"namespace","name":"btree","children":[{"tag":"namespace","name":"node","children":[{"tag":"variable","name":"EMPTY_ROOT_NODE","type":"LeafNode<(), ()>","external":true,"decl_file":57,"decl_line":113,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN5alloc11collections5btree4node15EMPTY_ROOT_NODE17h9fe886512df84030E"},{"tag":"structure_type","name":"LeafNode<(), ()>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"parent","type":"*const alloc::collections::btree::node::InternalNode<(), ()>","alignment":4,"data_member_location":0},{"tag":"member","name":"parent_idx","type":"MaybeUninit<u16>","alignment":2,"data_member_location":4},{"tag":"member","name":"len","type":"u16","alignment":2,"data_member_location":6},{"tag":"member","name":"keys","type":"MaybeUninit<[(); 11]>","alignment":1,"data_member_location":8},{"tag":"member","name":"vals","type":"MaybeUninit<[(); 11]>","alignment":1,"data_member_location":8}]},{"tag":"structure_type","name":"InternalNode<(), ()>","byte_size":56,"alignment":4,"children":[{"tag":"member","name":"data","type":"LeafNode<(), ()>","alignment":4,"data_member_location":0},{"tag":"member","name":"edges","type":"BoxedNode<(), ()>[]","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"BoxedNode<(), ()>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"Unique<alloc::collections::btree::node::LeafNode<(), ()>>","alignment":4,"data_member_location":0}]}]}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"CollectionAllocErr","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"CapacityOverflow","const_value":0},{"tag":"enumerator","name":"AllocErr","const_value":1}]},{"tag":"namespace","name":"vec_deque","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"wrap_copy","children":[]}]}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"boxed","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"borrow","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN85_$LT$alloc..borrow..Cow$LT$$u27$a$C$$u20$B$GT$$u20$as$u20$core..ops..deref..Deref$GT$5deref17h0dd73616a67b55a8E","name":"deref<str>","decl_file":60,"decl_line":303,"inline":"inlined"}]},{"tag":"structure_type","name":"Cow<str>","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":191545,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Borrowed","type":"Borrowed","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Owned","type":"Owned","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Borrowed","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Owned","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"String","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN50_$LT$alloc..borrow..Cow$LT$$u27$a$C$$u20$B$GT$$GT$10into_owned17h00c59544c001c563E","name":"into_owned<str>","decl_file":60,"decl_line":289,"inline":"inlined"}]}]},{"tag":"namespace","name":"str","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str83_$LT$impl$u20$core..borrow..Borrow$LT$str$GT$$u20$for$u20$alloc..string..String$GT$6borrow17h870b51831f3f1c49E","name":"borrow","decl_file":59,"decl_line":198,"inline":"inlined"},{"tag":"namespace","name":"to_lowercase","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12to_lowercase19map_uppercase_sigma17h91f7a1cf028603d4E","name":"map_uppercase_sigma","decl_file":59,"decl_line":390,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12to_lowercase26case_ignoreable_then_cased17h605b03091639f40eE","name":"case_ignoreable_then_cased<core::iter::Rev<core::str::Chars>>","decl_file":59,"decl_line":399,"inline":"inlined"},{"tag":"namespace","name":"case_ignoreable_then_cased","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12to_lowercase26case_ignoreable_then_cased28_$u7b$$u7b$closure$u7d$$u7d$17hf3a2c7bee78605c5E","name":"{{closure}}<core::iter::Rev<core::str::Chars>>","decl_file":59,"decl_line":401,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12to_lowercase26case_ignoreable_then_cased28_$u7b$$u7b$closure$u7d$$u7d$17h5f41968bbcfb57ffE","name":"{{closure}}<core::str::Chars>","decl_file":59,"decl_line":401,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12to_lowercase26case_ignoreable_then_cased17h5b9d7e343785b0b6E","name":"case_ignoreable_then_cased<core::str::Chars>","decl_file":59,"decl_line":399,"inline":"inlined"}]},{"tag":"namespace","name":"escape_debug","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$12escape_debug28_$u7b$$u7b$closure$u7d$$u7d$17ha2dac27c7b89a53dE","name":"{{closure}}","decl_file":59,"decl_line":471,"inline":"inlined"}]},{"tag":"namespace","name":"escape_default","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$14escape_default28_$u7b$$u7b$closure$u7d$$u7d$17had98be510917cd04E","name":"{{closure}}","decl_file":59,"decl_line":482,"inline":"inlined"}]},{"tag":"namespace","name":"escape_unicode","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$14escape_unicode28_$u7b$$u7b$closure$u7d$$u7d$17h0d68d9d64035a7cbE","name":"{{closure}}","decl_file":59,"decl_line":492,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN5alloc3str21_$LT$impl$u20$str$GT$11into_string17h9cb49302be25c1f6E","name":"into_string","decl_file":59,"decl_line":512,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc3str56_$LT$impl$u20$alloc..borrow..ToOwned$u20$for$u20$str$GT$8to_owned17haaef7e841f840852E","name":"to_owned","decl_file":59,"decl_line":207,"inline":"inlined"}]}]},{"tag":"namespace","name":"fmt","children":[{"tag":"subprogram","low_pc":22041,"high_pc":22451,"linkage_name":"_ZN5alloc3fmt6format17hea00a15b98a5c19fE","name":"format","decl_file":33,"decl_line":566,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments18estimated_capacity17h504ef990eb6e7b1bE","ranges":[[22061,22193],[22212,22216],[22425,22442]],"call_file":33,"call_line":567,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17he4d01d66fabbaac0E","low_pc":22081,"high_pc":22082,"call_file":15,"call_line":380,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hb78fdc71f9134ea3E","low_pc":22081,"high_pc":22082,"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hd15de3d39b6fbfceE","low_pc":22081,"high_pc":22082,"call_file":0,"call_line":1300}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter8iterator8Iterator3sum17hf7f7f14ca1bb8f84E","low_pc":22082,"high_pc":22134,"call_file":15,"call_line":380,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$usize$u20$as$u20$core..iter..traits..Sum$GT$3sum17h66ff8666be35a433E","low_pc":22082,"high_pc":22134,"call_file":36,"call_line":2323,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold17h09d4ff759d167a50E","low_pc":22082,"high_pc":22134,"call_file":53,"call_line":779,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold17hd36deb97bff060c0E","low_pc":22082,"high_pc":22134,"call_file":52,"call_line":1413,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h284d7acb6d7ca5ccE","ranges":[[22082,22098],[22110,22134]],"call_file":9,"call_line":2905,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hd5b68f4c8b2cb3c9E","low_pc":22087,"high_pc":22098,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hd15de3d39b6fbfceE","low_pc":22087,"high_pc":22098,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN84_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold28_$u7b$$u7b$closure$u7d$$u7d$17ha63ee0d5f9d8a295E","low_pc":22098,"high_pc":22110,"call_file":9,"call_line":2906,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments18estimated_capacity28_$u7b$$u7b$closure$u7d$$u7d$17hfdcc34c3d75a0f4dE","low_pc":22098,"high_pc":22105,"call_file":52,"call_line":1413},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ops8function5FnMut8call_mut17h4bbebfd33a486d36E","low_pc":22105,"high_pc":22110,"call_file":52,"call_line":1413,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Add$GT$3add17h72a67337577eb51cE","low_pc":22105,"high_pc":22110,"call_file":50,"call_line":156}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_mul17h848f1b83517064d7E","low_pc":22181,"high_pc":22193,"call_file":15,"call_line":394,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_mul17hcf1db6cc43b48612E","low_pc":22181,"high_pc":22193,"call_file":8,"call_line":2570}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc6string6String13with_capacity17h3ad6923bd9e8befbE","ranges":[[22217,22224],[22238,22294],[22443,22451]],"call_file":33,"call_line":568,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN33_$LT$alloc..vec..Vec$LT$T$GT$$GT$13with_capacity17h0fcf663fa1cf463cE","ranges":[[22217,22224],[22238,22263],[22443,22451]],"call_file":11,"call_line":428,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN40_$LT$alloc..raw_vec..RawVec$LT$T$GT$$GT$13with_capacity17ha0d22379dcf42a9dE","ranges":[[22217,22224],[22238,22263],[22443,22451]],"call_file":4,"call_line":368,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$alloc..raw_vec..RawVec$LT$T$C$$u20$A$GT$$GT$11allocate_in17h77563f87339e0cddE","ranges":[[22217,22224],[22238,22263],[22443,22451]],"call_file":13,"call_line":150,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$14unwrap_or_else17h269e79f2d8a38d0cE","ranges":[[22217,22224],[22443,22451]],"call_file":13,"call_line":95},{"tag":"inlined_subroutine","abstract_origin":"_ZN59_$LT$alloc..alloc..Global$u20$as$u20$core..alloc..Alloc$GT$5alloc17h1b32f98fc464f104E","low_pc":22238,"high_pc":22248,"call_file":13,"call_line":106,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN5alloc5alloc5alloc17h22cc6bfd411351eaE","low_pc":22238,"high_pc":22248,"call_file":12,"call_line":154}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17hfe23b3304d11bc37E","low_pc":22294,"high_pc":22376,"call_file":33,"call_line":569},{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$6expect17h871f9ef4048c622aE","ranges":[[22376,22378],[22417,22424]],"call_file":33,"call_line":569}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc5slice64_$LT$impl$u20$alloc..borrow..ToOwned$u20$for$u20$$u5b$T$u5d$$GT$10clone_into17hfb280a9cb38df97aE","name":"clone_into<u8>","decl_file":58,"decl_line":637,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$6repeat17hf5c2691496c532eaE","name":"repeat<u8>","decl_file":58,"decl_line":425,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$6to_vec17h8c8b7717520792b1E","name":"to_vec<u8>","decl_file":58,"decl_line":367,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN5alloc5slice64_$LT$impl$u20$alloc..borrow..ToOwned$u20$for$u20$$u5b$T$u5d$$GT$8to_owned17hddda7ccb68664f1cE","name":"to_owned<u8>","decl_file":58,"decl_line":628,"inline":"inlined"}]},{"tag":"namespace","name":"hack","children":[{"tag":"subprogram","linkage_name":"_ZN5alloc5slice4hack6to_vec17h462914a5b9c26704E","name":"to_vec<u8>","decl_file":58,"decl_line":166,"inline":"inlined"}]}]}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":198652,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u8","name":"&u8"},{"tag":"pointer_type","type":"InternalNode<(), ()>","name":"*const alloc::collections::btree::node::InternalNode<(), ()>"},{"tag":"array_type","type":"BoxedNode<(), ()>","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":12}]},{"tag":"pointer_type","type":"LeafNode<(), ()>","name":"*const alloc::collections::btree::node::LeafNode<(), ()>"},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"base_type","name":"u16","encoding":"unsigned","byte_size":2},{"tag":"array_type","type":"()","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":11}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":198752,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Vec<u8>","name":"&alloc::vec::Vec<u8>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":198787,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Utf8Error","name":"&core::str::Utf8Error"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":198822,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"()","name":"&()"},{"tag":"pointer_type","type":"Formatter","name":"&mut core::fmt::Formatter"},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"char","encoding":"unsigned_char","byte_size":4},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"usize[]","name":"&[usize; 3]"},{"tag":"array_type","type":"usize","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":3}]},{"tag":"pointer_type","type":"ArgumentV1","name":"*const core::fmt::ArgumentV1"},{"tag":"pointer_type","type":"Void","name":"&core::fmt::Void"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::fmt::Void"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"structure_type","name":"&[core::fmt::ArgumentV1]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"structure_type","name":"&[&str]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"&str","name":"*const &str"},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"&[core::fmt::rt::v1::Argument]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::rt::v1::Argument","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"Argument","name":"*const core::fmt::rt::v1::Argument"},{"tag":"pointer_type","type":"EscapeDebug","name":"&mut core::char::EscapeDebug"},{"tag":"pointer_type","type":"EscapeDefault","name":"&mut core::char::EscapeDefault"},{"tag":"pointer_type","type":"EscapeUnicode","name":"&mut core::char::EscapeUnicode"},{"tag":"pointer_type","type":"u16","name":"*const u16"},{"tag":"pointer_type","type":"u16","name":"&u16"}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"libcore/lib.rs","stmt_list":106522,"GNU_pubnames":true,"low_pc":0,"ranges":[[22452,22454],[27187,27362],[27699,27712],[27713,27720],[27721,27728],[27750,27780],[27781,27793],[27794,27801],[27802,27809],[22775,22892],[22456,22612],[23055,23143],[28439,29150],[22614,22774],[22894,23054],[29675,29801],[29803,30694],[24368,25659],[31318,31952],[27811,28437],[31954,32445],[32447,32712],[32713,32826],[32827,32844],[32845,32860],[32861,32977],[32978,32990],[26015,27185],[32992,34332],[34334,34710],[23145,24366],[34711,34725],[30696,31316],[29152,29480],[34727,35104],[29482,29674],[35106,35367],[27364,27698],[25661,26013],[35368,35401],[35402,35417],[35419,35824],[35826,36321],[36322,36340],[27729,27749],[36342,36565]],"children":[{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"flt2dec","children":[{"tag":"namespace","name":"strategy","children":[{"tag":"namespace","name":"dragon","children":[{"tag":"variable","name":"POW10","type":"u32[]","decl_file":121,"decl_line":24,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon5POW1017h32a4a1d9e17af96eE"},{"tag":"variable","name":"TWOPOW10","type":"u32[]","decl_file":121,"decl_line":26,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon8TWOPOW1017h062e50cf32393ba8E"},{"tag":"variable","name":"POW10TO16","type":"u32[]","decl_file":121,"decl_line":30,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon9POW10TO1617h9fed828ce675e5a9E"},{"tag":"variable","name":"POW10TO32","type":"u32[]","decl_file":121,"decl_line":31,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon9POW10TO3217h7f5259f4ef8104e3E"},{"tag":"variable","name":"POW10TO64","type":"u32[]","decl_file":121,"decl_line":32,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon9POW10TO6417he0b1a2a2ddcadf07E"},{"tag":"variable","name":"POW10TO128","type":"u32[]","decl_file":121,"decl_line":33,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon10POW10TO12817hb86bb0271d43d2b4E"},{"tag":"variable","name":"POW10TO256","type":"u32[]","decl_file":121,"decl_line":36,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon10POW10TO25617hf5a477420c71e967E"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon15div_rem_upto_1617hff2e5217b4229f33E","name":"div_rem_upto_16","decl_file":121,"decl_line":65,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy6dragon10div_2pow1017h2914329aba979351E","name":"div_2pow10","decl_file":121,"decl_line":54,"inline":"inlined"}]},{"tag":"namespace","name":"grisu","children":[{"tag":"variable","name":"CACHED_POW10","type":"(u64, i16, i16)[]","external":true,"decl_file":122,"decl_line":37,"alignment":1,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu12CACHED_POW1017h2712564e9d6e309fE"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu12cached_power17h6a4c52c724c5581aE","name":"cached_power","decl_file":122,"decl_line":125,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu22max_pow10_no_more_than17h9e12a05acdb9d38eE","name":"max_pow10_no_more_than","decl_file":122,"decl_line":137,"external":true,"inline":"inlined"},{"tag":"namespace","name":"format_shortest_opt","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu19format_shortest_opt14round_and_weed17h43160ad774b307abE","name":"round_and_weed","decl_file":122,"decl_line":338,"inline":"inlined"}]},{"tag":"namespace","name":"format_exact_opt","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu16format_exact_opt14possibly_round17hcbd108cb3210421bE","name":"possibly_round","decl_file":122,"decl_line":588,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu12format_exact17hc16d97932096791aE","name":"format_exact","decl_file":122,"decl_line":687,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8strategy5grisu15format_shortest17h29867720d3d8a9ffE","name":"format_shortest","decl_file":122,"decl_line":430,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"decoder","children":[{"tag":"structure_type","name":"Decoded","byte_size":32,"alignment":8,"children":[{"tag":"member","name":"mant","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"minus","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"plus","type":"u64","alignment":8,"data_member_location":16},{"tag":"member","name":"exp","type":"i16","alignment":2,"data_member_location":24},{"tag":"member","name":"inclusive","type":"bool","alignment":1,"data_member_location":26}]},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec7decoder6decode17h1976bcbced48270eE","name":"decode<f32>","decl_file":123,"decl_line":69,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec7decoder6decode17h5c857c63b583c2b2E","name":"decode<f64>","decl_file":123,"decl_line":69,"inline":"inlined"}]},{"tag":"namespace","name":"estimator","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec9estimator23estimate_scaling_factor17h1ffd327aa2dd1085E","name":"estimate_scaling_factor","decl_file":124,"decl_line":18,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"round_up","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec8round_up28_$u7b$$u7b$closure$u7d$$u7d$17h6b158437da98f3beE","name":"{{closure}}","decl_file":125,"decl_line":156,"inline":"inlined"}]},{"tag":"structure_type","name":"Part","byte_size":12,"alignment":4,"children":[{"tag":"variant_part","discr":210339,"children":[{"tag":"member","type":"u16","alignment":2,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Zero","type":"Zero","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Num","type":"Num","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Copy","type":"Copy","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Zero","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Num","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"u16","alignment":2,"data_member_location":2}]},{"tag":"structure_type","name":"Copy","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[u8]","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec4Part3len17hb8606975139d464eE","name":"len","decl_file":125,"decl_line":186,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Formatted","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"sign","type":"&[u8]","alignment":4,"data_member_location":0},{"tag":"member","name":"parts","type":"&[core::num::flt2dec::Part]","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec9Formatted3len17h169f2e878e82e195E","name":"len","decl_file":125,"decl_line":235,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec18to_exact_fixed_str17hb97271bea65897afE","name":"to_exact_fixed_str<f32,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16) -> (usize, i16)>","decl_file":125,"decl_line":605,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec14determine_sign17h3dba3bea311be263E","name":"determine_sign","decl_file":125,"decl_line":385,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec20estimate_max_buf_len17h7d7c8d8c9fb56e37E","name":"estimate_max_buf_len","decl_file":125,"decl_line":530,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec17digits_to_dec_str17haef9514ef007b909E","name":"digits_to_dec_str","decl_file":125,"decl_line":269,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec18to_exact_fixed_str17hda688cfddefa3249E","name":"to_exact_fixed_str<f64,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16) -> (usize, i16)>","decl_file":125,"decl_line":605,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec15to_shortest_str17h37bfc8870215cd65E","name":"to_shortest_str<f64,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8]) -> (usize, i16)>","decl_file":125,"decl_line":415,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec15to_shortest_str17he008de4daaed34c5E","name":"to_shortest_str<f32,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8]) -> (usize, i16)>","decl_file":125,"decl_line":415,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec16to_exact_exp_str17hb08018698e3247e5E","name":"to_exact_exp_str<f32,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16) -> (usize, i16)>","decl_file":125,"decl_line":549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec16to_exact_exp_str17h673b2718278f23b2E","name":"to_exact_exp_str<f64,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16) -> (usize, i16)>","decl_file":125,"decl_line":549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec19to_shortest_exp_str17h9551753b1b3527a4E","name":"to_shortest_exp_str<f32,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8]) -> (usize, i16)>","decl_file":125,"decl_line":470,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7flt2dec19to_shortest_exp_str17haffa96196eb9f634E","name":"to_shortest_exp_str<f64,fn(&core::num::flt2dec::decoder::Decoded, &mut [u8]) -> (usize, i16)>","decl_file":125,"decl_line":470,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN82_$LT$core..num..flt2dec..Formatted$LT$$u27$a$GT$$u20$as$u20$core..clone..Clone$GT$5clone17h742b15faf72e81b1E","name":"clone","decl_file":125,"decl_line":225,"inline":"inlined"}]}]},{"tag":"variable","name":"ASCII_LOWERCASE_MAP","type":"u8[]","external":true,"decl_file":8,"decl_line":4936,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num19ASCII_LOWERCASE_MAP17h4e2b1b3022c03903E"},{"tag":"variable","name":"ASCII_UPPERCASE_MAP","type":"u8[]","external":true,"decl_file":8,"decl_line":4975,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num19ASCII_UPPERCASE_MAP17h42856fd02f380717E"},{"tag":"variable","name":"ASCII_CHARACTER_CLASS","type":"AsciiCharacterClass[]","external":true,"decl_file":8,"decl_line":5027,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN4core3num21ASCII_CHARACTER_CLASS17ha1c456745d20b316E"},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"AsciiCharacterClass","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"C","const_value":0},{"tag":"enumerator","name":"Cw","const_value":1},{"tag":"enumerator","name":"W","const_value":2},{"tag":"enumerator","name":"D","const_value":3},{"tag":"enumerator","name":"L","const_value":4},{"tag":"enumerator","name":"Lx","const_value":5},{"tag":"enumerator","name":"U","const_value":6},{"tag":"enumerator","name":"Ux","const_value":7},{"tag":"enumerator","name":"P","const_value":8}]},{"tag":"namespace","name":"dec2flt","children":[{"tag":"namespace","name":"parse","children":[{"tag":"structure_type","name":"Decimal","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"integral","type":"&[u8]","alignment":4,"data_member_location":8},{"tag":"member","name":"fractional","type":"&[u8]","alignment":4,"data_member_location":16},{"tag":"member","name":"exp","type":"i64","alignment":8,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN4core3num7dec2flt5parse10eat_digits17h842961da2cf0b4dfE","name":"eat_digits","decl_file":126,"decl_line":92,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"FloatErrorKind","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Empty","const_value":0},{"tag":"enumerator","name":"Invalid","const_value":1}]},{"tag":"namespace","name":"algorithm","children":[]},{"tag":"namespace","name":"num","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num7dec2flt3num8get_bits17h41fb645c1f523766E","name":"get_bits","decl_file":127,"decl_line":86,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7dec2flt3num21compare_with_half_ulp17ha6e2fab15a2265a6E","name":"compare_with_half_ulp","decl_file":127,"decl_line":21,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num7dec2flt3num18from_str_unchecked17h64b1d422978abd84E","name":"from_str_unchecked<&[u8]>","decl_file":127,"decl_line":49,"inline":"inlined"}]},{"tag":"namespace","name":"rawfp","children":[{"tag":"structure_type","name":"Unpacked","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"sig","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"k","type":"i16","alignment":2,"data_member_location":8}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN59_$LT$f32$u20$as$u20$core..num..dec2flt..rawfp..RawFloat$GT$14integer_decode17ha5a2b2386a99e8eeE","name":"integer_decode","decl_file":128,"decl_line":172,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$f64$u20$as$u20$core..num..dec2flt..rawfp..RawFloat$GT$14integer_decode17hf1e7c921e5636b12E","name":"integer_decode","decl_file":128,"decl_line":219,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$f32$u20$as$u20$core..num..dec2flt..rawfp..RawFloat$GT$8classify17h43eabd209b1cee2dE","name":"classify","decl_file":128,"decl_line":201,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN59_$LT$f64$u20$as$u20$core..num..dec2flt..rawfp..RawFloat$GT$8classify17h246610f02bed331fE","name":"classify","decl_file":128,"decl_line":248,"external":true,"inline":"inlined"}]}]},{"tag":"structure_type","name":"ParseFloatError","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"kind","type":"FloatErrorKind","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core3num7dec2flt15ParseFloatError13__description17hb34113c7f5ebd73bE","name":"__description","decl_file":129,"decl_line":175,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..num..dec2flt..FloatErrorKind$u20$as$u20$core..fmt..Debug$GT$3fmt17hb6241190b8104137E","name":"fmt","decl_file":129,"decl_line":163,"external":true,"inline":"inlined"}]}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"IntErrorKind","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Empty","const_value":0},{"tag":"enumerator","name":"InvalidDigit","const_value":1},{"tag":"enumerator","name":"Overflow","const_value":2},{"tag":"enumerator","name":"Underflow","const_value":3}]},{"tag":"structure_type","name":"NonZeroUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"NonZero<usize>","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$13leading_zeros17hfd479c54b9990532E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_add17h66ca9d048dce6ceeE","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_add17h86938748225cc551E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_sub17h4a98596a1d4e53a4E","name":"overflowing_sub","decl_file":8,"decl_line":3193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_sub17hd263f9a3880ab409E","name":"checked_sub","decl_file":8,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$11is_negative17h4f326f9c42449b91E","name":"is_negative","decl_file":8,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$3abs17h16de4760d29ac2a0E","name":"abs","decl_file":8,"decl_line":1839,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_sub17h9cd6f7fbda80d79eE","name":"overflowing_sub","decl_file":8,"decl_line":3193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_sub17h5aa66de5d4ebae0dE","name":"checked_sub","decl_file":8,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$14saturating_sub17h3215fa45ee659babE","name":"saturating_sub","decl_file":8,"decl_line":2805,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$15overflowing_mul17h9f3021ed756c1e86E","name":"overflowing_mul","decl_file":8,"decl_line":1402,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$11checked_mul17hc22ebddf3262c1d1E","name":"checked_mul","decl_file":8,"decl_line":643,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i16$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h2a0764a686eb2205E","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$15overflowing_add17h734bd3371cfd61e6E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$11checked_add17h18fd9030eab62e40E","name":"checked_add","decl_file":8,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i16$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h76c818670bb874aaE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$15overflowing_sub17h68eabcb9665eec8cE","name":"overflowing_sub","decl_file":8,"decl_line":1375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i16$GT$11checked_sub17h0b6f097b1b1321a0E","name":"checked_sub","decl_file":8,"decl_line":621,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i16$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_sub17h4f57a6e8aa77d2d1E","name":"checked_sub","decl_file":8,"decl_line":4677,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_mul17hcf1db6cc43b48612E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_mul17h848f1b83517064d7E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$usize$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h9fd1a62f0c01283dE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$15overflowing_add17hdff24069b684c048E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num23_$LT$impl$u20$usize$GT$11checked_add17ha11c8a50db2b24c6E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$usize$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h11a932a3d692fdddE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$15overflowing_mul17h2180c9d2a146a53eE","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$11checked_mul17hba8fe66b5657b9c9E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$u128$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h06a08223c0be54deE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$u128$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h475621395fe43ea0E","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$15overflowing_add17h7a016696c662fe58E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$11checked_add17h8741d6c7d5774c71E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$15overflowing_mul17hd48b21410cf0a910E","name":"overflowing_mul","decl_file":8,"decl_line":1402,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$11checked_mul17h9ebc390d2a977dcaE","name":"checked_mul","decl_file":8,"decl_line":643,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i64$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h83191e619cb730dfE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$15overflowing_add17h8423313cc7fb3a41E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$11checked_add17h1b64a28525eb4c16E","name":"checked_add","decl_file":8,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i64$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h27ad37c4bdd7b8efE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$15overflowing_sub17hc4fdfc62c7759287E","name":"overflowing_sub","decl_file":8,"decl_line":1375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$11checked_sub17h0eef30abb0f24b50E","name":"checked_sub","decl_file":8,"decl_line":621,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i64$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_sub17hd99800acfca0e6d4E","name":"checked_sub","decl_file":8,"decl_line":4677,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$15overflowing_mul17hed805e7cb47ed895E","name":"overflowing_mul","decl_file":8,"decl_line":1402,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$11checked_mul17hba17edf9ad15561eE","name":"checked_mul","decl_file":8,"decl_line":643,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i32$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h4d1bf25303f4bc8dE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$15overflowing_add17hc6e05ec943b4c298E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$11checked_add17hf027d98f7ea3a888E","name":"checked_add","decl_file":8,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i32$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17hc129e0d210172724E","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$15overflowing_sub17hab3c620f63472742E","name":"overflowing_sub","decl_file":8,"decl_line":1375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$11checked_sub17h4315909abfea1732E","name":"checked_sub","decl_file":8,"decl_line":621,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$i32$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_sub17hb114f37672a45905E","name":"checked_sub","decl_file":8,"decl_line":4677,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$15overflowing_mul17hf8d291fc552f0083E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$11checked_mul17h14a3b4fea51109a5E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u16$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h338de2ce28501de8E","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u16$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17ha4cbc1aeb4591651E","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$15overflowing_add17hd3bfe8f3f2308486E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$11checked_add17h32d80ea9544fb046E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$15overflowing_mul17hc949d585cac1fbf3E","name":"overflowing_mul","decl_file":8,"decl_line":1402,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$11checked_mul17h46fe00eff7b0896cE","name":"checked_mul","decl_file":8,"decl_line":643,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i8$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h5512d6577e14b183E","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$15overflowing_add17h72c595b0c10d4863E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$11checked_add17h95f41599476c4d12E","name":"checked_add","decl_file":8,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i8$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17hd2f81aab59bf121fE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$15overflowing_sub17h7d2ded8fcf1f617eE","name":"overflowing_sub","decl_file":8,"decl_line":1375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$i8$GT$11checked_sub17h512aba8d54be9ad4E","name":"checked_sub","decl_file":8,"decl_line":621,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i8$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_sub17h4ddc992679bd0999E","name":"checked_sub","decl_file":8,"decl_line":4677,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_mul17h17add9cf822e06eeE","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_mul17h4b9627fb17bc2f67E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u64$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17hd525cf28152d8b92E","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u64$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h9cedaa6851cf89a1E","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$15overflowing_mul17hfbf0ada4290bbd1cE","name":"overflowing_mul","decl_file":8,"decl_line":1402,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$11checked_mul17h40e353a9abb83fe6E","name":"checked_mul","decl_file":8,"decl_line":643,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$i128$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17heda01a6fa4abcd1eE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$15overflowing_add17h25711300b3eb5a53E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$11checked_add17h25c0f5b4acd59918E","name":"checked_add","decl_file":8,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$i128$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h2415dfc8c59f358dE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$i128$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_sub17h4f5dece853fe80b9E","name":"checked_sub","decl_file":8,"decl_line":4677,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$15overflowing_sub17h7d0a3066321fdd2eE","name":"overflowing_sub","decl_file":8,"decl_line":1375,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$11checked_sub17h6546321083520ad0E","name":"checked_sub","decl_file":8,"decl_line":621,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$15overflowing_mul17h2d2c660f54ffff20E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$11checked_mul17h130733098b53dda1E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u8$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17hc1846dcbe67c0d2cE","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u8$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17hfab0facf72a11197E","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$15overflowing_add17ha28240ec4206de3aE","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$11checked_add17h56f3194fb9549c4cE","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$20make_ascii_uppercase17h14825b0e392b0f12E","name":"make_ascii_uppercase","decl_file":8,"decl_line":3899,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$18to_ascii_uppercase17hfaf344d5d70c1b91E","name":"to_ascii_uppercase","decl_file":8,"decl_line":3834,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$20make_ascii_lowercase17hc968d1f124673a66E","name":"make_ascii_lowercase","decl_file":8,"decl_line":3924,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$18to_ascii_lowercase17hdfa64afc37fb0729E","name":"to_ascii_lowercase","decl_file":8,"decl_line":3856,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num20_$LT$impl$u20$u8$GT$31one_less_than_next_power_of_two17h4987b5a133f56953E","name":"one_less_than_next_power_of_two","decl_file":8,"decl_line":3566,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u16$GT$31one_less_than_next_power_of_two17hd30cf2f4d3bc2e60E","name":"one_less_than_next_power_of_two","decl_file":8,"decl_line":3566,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$31one_less_than_next_power_of_two17h4770a99ae966f219E","name":"one_less_than_next_power_of_two","decl_file":8,"decl_line":3566,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$15overflowing_add17h9bd1317d1913fe35E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$11checked_add17ha912b22903464836E","name":"checked_add","decl_file":8,"decl_line":2529,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$31one_less_than_next_power_of_two17h057dfa74ee9c6c3fE","name":"one_less_than_next_power_of_two","decl_file":8,"decl_line":3566,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$31one_less_than_next_power_of_two17h7c8bf978d4955332E","name":"one_less_than_next_power_of_two","decl_file":8,"decl_line":3566,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$15overflowing_mul17hce8880e672700c18E","name":"overflowing_mul","decl_file":8,"decl_line":3222,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$11checked_mul17h9cf94b44fdba1505E","name":"checked_mul","decl_file":8,"decl_line":2569,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u32$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_mul17h93f023162ca441a8E","name":"checked_mul","decl_file":8,"decl_line":4673,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$u32$u20$as$u20$core..num..FromStrRadixHelper$GT$11checked_add17h2592f9fb2d3a7b2eE","name":"checked_add","decl_file":8,"decl_line":4681,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$12wrapping_add17h991dedb2a4d93eebE","name":"wrapping_add","decl_file":8,"decl_line":2877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN60_$LT$core..num..NonZeroUsize$u20$as$u20$core..fmt..Debug$GT$3fmt17hcf98d89eb3819b4dE","name":"fmt","decl_file":8,"decl_line":29,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN60_$LT$core..num..IntErrorKind$u20$as$u20$core..fmt..Debug$GT$3fmt17hacfc8efe3002b553E","name":"fmt","decl_file":8,"decl_line":4774,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"bignum","children":[{"tag":"structure_type","name":"Big32x40","byte_size":164,"alignment":4,"children":[{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"base","type":"u32[]","alignment":4,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x409mul_small17hb45a80e21545515bE","name":"mul_small","decl_file":130,"decl_line":256,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x4010mul_digits17hc9d1e975a50a7578E","name":"mul_digits","decl_file":130,"decl_line":346,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x406digits17hc9a30e45b12a67d8E","name":"digits","decl_file":130,"decl_line":154,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x408from_u6417h272b14df92b37048E","name":"from_u64","decl_file":130,"decl_line":138,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x4010from_small17hff7bb4ac8cb5096bE","name":"from_small","decl_file":130,"decl_line":131,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x403add17h4f1ceb4889f62093E","name":"add","decl_file":130,"decl_line":200,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x403sub17hd4a416658481fb8fE","name":"sub","decl_file":130,"decl_line":238,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x4013div_rem_small17h9d9a316ddc61bbf0E","name":"div_rem_small","decl_file":130,"decl_line":385,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x407is_zero17h09d48cb3b0e81a9eE","name":"is_zero","decl_file":130,"decl_line":170,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x407get_bit17hd01873a5c8792319E","name":"get_bit","decl_file":130,"decl_line":160,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x409add_small17hdf309dc87ae055baE","name":"add_small","decl_file":130,"decl_line":219,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN50_$LT$u32$u20$as$u20$core..num..bignum..FullOps$GT$8full_mul17h3defa5ebca3ae6b0E","name":"full_mul","decl_file":130,"decl_line":69,"external":true,"inline":"inlined"},{"tag":"namespace","name":"mul_digits","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x4010mul_digits9mul_inner17h029d0d13dcd18913E","name":"mul_inner","decl_file":130,"decl_line":348,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN50_$LT$u32$u20$as$u20$core..num..bignum..FullOps$GT$12full_mul_add17h021e208f3a78f3b1E","name":"full_mul_add","decl_file":130,"decl_line":76,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..num..bignum..Big32x40$u20$as$u20$core..clone..Clone$GT$5clone17h3a79c418e2cb9c14E","name":"clone","decl_file":130,"decl_line":464,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN50_$LT$u32$u20$as$u20$core..num..bignum..FullOps$GT$8full_add17h892d599945d0ca68E","name":"full_add","decl_file":130,"decl_line":59,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN62_$LT$core..num..bignum..Big32x40$u20$as$u20$core..cmp..Ord$GT$3cmp17h684b87c8439e5a84E","name":"cmp","decl_file":130,"decl_line":454,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$core..num..bignum..Big32x40$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17hae2238673f8d81edE","name":"partial_cmp","decl_file":130,"decl_line":448,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN50_$LT$u32$u20$as$u20$core..num..bignum..FullOps$GT$12full_div_rem17h0b5b81798bdf960eE","name":"full_div_rem","decl_file":130,"decl_line":84,"external":true,"inline":"inlined"},{"tag":"namespace","name":"is_zero","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x407is_zero28_$u7b$$u7b$closure$u7d$$u7d$17hac7854ae4f78d750E","name":"{{closure}}","decl_file":130,"decl_line":171,"inline":"inlined"}]},{"tag":"namespace","name":"bit_length","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum8Big32x4010bit_length28_$u7b$$u7b$closure$u7d$$u7d$17hfd33c3e7cd7b6103E","name":"{{closure}}","decl_file":130,"decl_line":181,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN49_$LT$u8$u20$as$u20$core..num..bignum..FullOps$GT$8full_add17hb1774aac2c8ea90aE","name":"full_add","decl_file":130,"decl_line":59,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$u8$u20$as$u20$core..num..bignum..FullOps$GT$8full_mul17h3732238901be3008E","name":"full_mul","decl_file":130,"decl_line":69,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$u8$u20$as$u20$core..num..bignum..FullOps$GT$12full_mul_add17h9e4ce0c1de57eca8E","name":"full_mul_add","decl_file":130,"decl_line":76,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$u8$u20$as$u20$core..num..bignum..FullOps$GT$12full_div_rem17he0fd878d84ca3551E","name":"full_div_rem","decl_file":130,"decl_line":84,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"tests","children":[{"tag":"structure_type","name":"Big8x3","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"size","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"base","type":"u8[]","alignment":1,"data_member_location":4},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x36digits17heeb6b652d4c9554fE","name":"digits","decl_file":130,"decl_line":154,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x37get_bit17h2f9db3fafd38389dE","name":"get_bit","decl_file":130,"decl_line":160,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x39mul_small17h968a0c673e7ad3beE","name":"mul_small","decl_file":130,"decl_line":256,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x37is_zero17ha711e53fb74de5deE","name":"is_zero","decl_file":130,"decl_line":170,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x33sub17h2bf9543af842e498E","name":"sub","decl_file":130,"decl_line":238,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"is_zero","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x37is_zero28_$u7b$$u7b$closure$u7d$$u7d$17ha636e846453ea85dE","name":"{{closure}}","decl_file":130,"decl_line":171,"inline":"inlined"}]},{"tag":"namespace","name":"bit_length","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num6bignum5tests6Big8x310bit_length28_$u7b$$u7b$closure$u7d$$u7d$17h9db2ad49fc44cfb9E","name":"{{closure}}","decl_file":130,"decl_line":181,"inline":"inlined"}]},{"tag":"namespace","name":"mul_digits","children":[]},{"tag":"subprogram","linkage_name":"_ZN67_$LT$core..num..bignum..tests..Big8x3$u20$as$u20$core..cmp..Ord$GT$3cmp17hbf00607ccfd9f046E","name":"cmp","decl_file":130,"decl_line":454,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$core..num..bignum..tests..Big8x3$u20$as$u20$core..cmp..PartialOrd$GT$11partial_cmp17h404b71fd56e6ec9fE","name":"partial_cmp","decl_file":130,"decl_line":448,"external":true,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"diy_float","children":[{"tag":"structure_type","name":"Fp","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"f","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"e","type":"i16","alignment":2,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core3num9diy_float2Fp12normalize_to17hf6a614149e093eccE","name":"normalize_to","decl_file":131,"decl_line":82,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num9diy_float2Fp9normalize17h255cc4e3341a63a3E","name":"normalize","decl_file":131,"decl_line":49,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num9diy_float2Fp3mul17hc17be63b76290c22E","name":"mul","decl_file":131,"decl_line":32,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"structure_type","name":"TryFromIntError","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"__0","type":"()","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"ParseIntError","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"kind","type":"IntErrorKind","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core3num13ParseIntError13__description17hfe012820a48e377dE","name":"__description","decl_file":8,"decl_line":4788,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3num14from_str_radix17hd8b6d296428c132fE","name":"from_str_radix<u8>","decl_file":8,"decl_line":4688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num14from_str_radix17h8b5f5f95fbcd1935E","name":"from_str_radix<u16>","decl_file":8,"decl_line":4688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num14from_str_radix17hb9f951c21a84742dE","name":"from_str_radix<u32>","decl_file":8,"decl_line":4688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num14from_str_radix17hc682311880f2fdc3E","name":"from_str_radix<u64>","decl_file":8,"decl_line":4688,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num14from_str_radix17h593683bd3c3d6e1aE","name":"from_str_radix<u128>","decl_file":8,"decl_line":4688,"inline":"inlined"}]},{"tag":"namespace","name":"panic","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"internal_constructor","children":[{"tag":"structure_type","name":"NoPayload","byte_size":0,"alignment":1}]},{"tag":"subprogram","linkage_name":"_ZN74_$LT$core..panic..Location$LT$$u27$_$GT$$u20$as$u20$core..fmt..Display$GT$3fmt17ha0749af57f01ee8dE","name":"fmt","decl_file":26,"decl_line":262,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"Location","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"file","type":"&str","alignment":4,"data_member_location":0},{"tag":"member","name":"line","type":"u32","alignment":4,"data_member_location":8},{"tag":"member","name":"col","type":"u32","alignment":4,"data_member_location":12},{"tag":"subprogram","low_pc":27750,"high_pc":27780,"linkage_name":"_ZN4core5panic8Location20internal_constructor17h127dec658a765e1cE","name":"internal_constructor","decl_file":26,"decl_line":189,"external":true},{"tag":"subprogram","low_pc":27781,"high_pc":27793,"linkage_name":"_ZN4core5panic8Location4file17h4940f5d56aa75b32E","name":"file","decl_file":26,"decl_line":211,"external":true},{"tag":"subprogram","low_pc":27794,"high_pc":27801,"linkage_name":"_ZN4core5panic8Location4line17h659c90f0b928bf7dE","name":"line","decl_file":26,"decl_line":233,"external":true},{"tag":"subprogram","low_pc":27802,"high_pc":27809,"linkage_name":"_ZN4core5panic8Location6column17he1556cf9b226bbd4E","name":"column","decl_file":26,"decl_line":255,"external":true}]},{"tag":"structure_type","name":"PanicInfo","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"payload","type":"&Any","alignment":4,"data_member_location":0},{"tag":"member","name":"message","type":"Option<&core::fmt::Arguments>","alignment":4,"data_member_location":8},{"tag":"member","name":"location","type":"Location","alignment":4,"data_member_location":12},{"tag":"subprogram","low_pc":27713,"high_pc":27720,"linkage_name":"_ZN4core5panic9PanicInfo7message17h26ff79e6cf270fb2E","name":"message","decl_file":26,"decl_line":99,"external":true},{"tag":"subprogram","low_pc":27721,"high_pc":27728,"linkage_name":"_ZN4core5panic9PanicInfo8location17h4c8d1af5ccb1970eE","name":"location","decl_file":26,"decl_line":128,"external":true},{"tag":"subprogram","linkage_name":"_ZN4core5panic9PanicInfo20internal_constructor17h7f7883a6234f3b51E","name":"internal_constructor","decl_file":26,"decl_line":58,"inline":"inlined"}]}]},{"tag":"namespace","name":"str","children":[{"tag":"structure_type","name":"SplitTerminator<char>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SplitInternal<char>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"SplitInternal<char>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"matcher","type":"CharSearcher","alignment":4,"data_member_location":8},{"tag":"member","name":"allow_trailing_empty","type":"bool","alignment":1,"data_member_location":36},{"tag":"member","name":"finished","type":"bool","alignment":1,"data_member_location":37}]},{"tag":"namespace","name":"pattern","children":[{"tag":"structure_type","name":"CharSearcher","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"haystack","type":"&str","alignment":4,"data_member_location":0},{"tag":"member","name":"finger","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"finger_back","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"needle","type":"char","alignment":4,"data_member_location":16},{"tag":"member","name":"utf8_size","type":"usize","alignment":4,"data_member_location":20},{"tag":"member","name":"utf8_encoded","type":"u8[]","alignment":1,"data_member_location":24}]},{"tag":"structure_type","name":"CharPredicateSearcher<core::str::IsWhitespace>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"__0","type":"MultiCharEqSearcher<core::str::IsWhitespace>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"MultiCharEqSearcher<core::str::IsWhitespace>","byte_size":20,"alignment":4,"children":[{"tag":"member","name":"char_eq","type":"IsWhitespace","alignment":1,"data_member_location":0},{"tag":"member","name":"haystack","type":"&str","alignment":4,"data_member_location":0},{"tag":"member","name":"char_indices","type":"CharIndices","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"MultiCharEqSearcher<&[char]>","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"char_eq","type":"&[char]","alignment":4,"data_member_location":0},{"tag":"member","name":"haystack","type":"&str","alignment":4,"data_member_location":8},{"tag":"member","name":"char_indices","type":"CharIndices","alignment":4,"data_member_location":16}]},{"tag":"structure_type","name":"StrSearcherImpl","byte_size":48,"alignment":8,"children":[{"tag":"variant_part","discr":233819,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Empty","type":"Empty","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"TwoWay","type":"TwoWay","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"Empty","byte_size":48,"alignment":8,"children":[{"tag":"member","name":"__0","type":"EmptyNeedle","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"TwoWay","byte_size":48,"alignment":8,"children":[{"tag":"member","name":"__0","type":"TwoWaySearcher","alignment":8,"data_member_location":8}]}]},{"tag":"structure_type","name":"EmptyNeedle","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"position","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"is_match_fw","type":"bool","alignment":1,"data_member_location":8},{"tag":"member","name":"is_match_bw","type":"bool","alignment":1,"data_member_location":9}]},{"tag":"structure_type","name":"TwoWaySearcher","byte_size":40,"alignment":8,"children":[{"tag":"member","name":"crit_pos","type":"usize","alignment":4,"data_member_location":8},{"tag":"member","name":"crit_pos_back","type":"usize","alignment":4,"data_member_location":12},{"tag":"member","name":"period","type":"usize","alignment":4,"data_member_location":16},{"tag":"member","name":"byteset","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"position","type":"usize","alignment":4,"data_member_location":20},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":24},{"tag":"member","name":"memory","type":"usize","alignment":4,"data_member_location":28},{"tag":"member","name":"memory_back","type":"usize","alignment":4,"data_member_location":32},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern14TwoWaySearcher14maximal_suffix17h2c54a9d5cb290317E","name":"maximal_suffix","decl_file":46,"decl_line":1290,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern14TwoWaySearcher3new17ha11ede935c3d863aE","name":"new","decl_file":46,"decl_line":1040,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern14TwoWaySearcher14byteset_create17h66c46b4566f6e61eE","name":"byteset_create","decl_file":46,"decl_line":1108,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern14TwoWaySearcher22reverse_maximal_suffix17hdd4a605c7665bb03E","name":"reverse_maximal_suffix","decl_file":46,"decl_line":1336,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"byteset_create","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern14TwoWaySearcher14byteset_create28_$u7b$$u7b$closure$u7d$$u7d$17h478518ba840ec3e7E","name":"{{closure}}","decl_file":46,"decl_line":1109,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN109_$LT$core..str..pattern..MultiCharEqPattern$LT$C$GT$$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17hf9b32837b8b31ef5E","name":"into_searcher<closure>","decl_file":46,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$F$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17hf7b4dced3ab35542E","name":"into_searcher<closure>","decl_file":46,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN125_$LT$core..str..pattern..MultiCharEqSearcher$LT$$u27$a$C$$u20$C$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$4next17h915a4eed023fde07E","name":"next<closure>","decl_file":46,"decl_line":530,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN127_$LT$core..str..pattern..CharPredicateSearcher$LT$$u27$a$C$$u20$F$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$11next_reject17h301ad2e796e7ec1fE","name":"next_reject<closure>","decl_file":46,"decl_line":615,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$F$u20$as$u20$core..str..pattern..MultiCharEq$GT$7matches17h2dfd1ac41ec920c0E","name":"matches<closure>","decl_file":46,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN132_$LT$core..str..pattern..MultiCharEqSearcher$LT$$u27$a$C$$u20$C$GT$$u20$as$u20$core..str..pattern..ReverseSearcher$LT$$u27$a$GT$$GT$9next_back17hf38bcdf1ea4153cfE","name":"next_back<closure>","decl_file":46,"decl_line":550,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN134_$LT$core..str..pattern..CharPredicateSearcher$LT$$u27$a$C$$u20$F$GT$$u20$as$u20$core..str..pattern..ReverseSearcher$LT$$u27$a$GT$$GT$16next_reject_back17h3807caf73c4a0a86E","name":"next_reject_back<closure>","decl_file":46,"decl_line":629,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN125_$LT$core..str..pattern..MultiCharEqSearcher$LT$$u27$a$C$$u20$C$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$4next17hb2bf9da1cc554f58E","name":"next<closure>","decl_file":46,"decl_line":530,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN127_$LT$core..str..pattern..CharPredicateSearcher$LT$$u27$a$C$$u20$F$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$11next_reject17h2bcea41494a6a3f6E","name":"next_reject<closure>","decl_file":46,"decl_line":615,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$F$u20$as$u20$core..str..pattern..MultiCharEq$GT$7matches17hdadf73af88443ecdE","name":"matches<closure>","decl_file":46,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN132_$LT$core..str..pattern..MultiCharEqSearcher$LT$$u27$a$C$$u20$C$GT$$u20$as$u20$core..str..pattern..ReverseSearcher$LT$$u27$a$GT$$GT$9next_back17h9dfb7d9b5282e2a3E","name":"next_back<closure>","decl_file":46,"decl_line":550,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN134_$LT$core..str..pattern..CharPredicateSearcher$LT$$u27$a$C$$u20$F$GT$$u20$as$u20$core..str..pattern..ReverseSearcher$LT$$u27$a$GT$$GT$16next_reject_back17hb4eaff46634dc7e5E","name":"next_reject_back<closure>","decl_file":46,"decl_line":629,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN63_$LT$F$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17ha5fd9a08b5c97edeE","name":"into_searcher<closure>","decl_file":46,"decl_line":577,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$F$u20$as$u20$core..str..pattern..MultiCharEq$GT$7matches17he3de334e933bfa6bE","name":"matches<closure>","decl_file":46,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$char$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17h718420faa7a4ea32E","name":"into_searcher","decl_file":46,"decl_line":436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN109_$LT$core..str..pattern..CharSearcher$LT$$u27$a$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$10next_match17hc227a6b56daee9d8E","name":"next_match","decl_file":46,"decl_line":304,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..str..pattern..MultiCharEqSearcher$LT$$u27$a$C$$u20$C$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17haa1407373c7aaee5E","name":"fmt<&[char]>","decl_file":46,"decl_line":503,"inline":"inlined"}]},{"tag":"structure_type","name":"StrSearcher","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"haystack","type":"&str","alignment":4,"data_member_location":48},{"tag":"member","name":"needle","type":"&str","alignment":4,"data_member_location":56},{"tag":"member","name":"searcher","type":"StrSearcherImpl","alignment":8,"data_member_location":0}]},{"tag":"namespace","name":"Searcher","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern8Searcher11next_reject17h5ed57fc5e005bd7dE","name":"next_reject<core::str::pattern::MultiCharEqSearcher<closure>>","decl_file":46,"decl_line":152,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern8Searcher11next_reject17he6a3fe15f35dbe92E","name":"next_reject<core::str::pattern::MultiCharEqSearcher<closure>>","decl_file":46,"decl_line":152,"inline":"inlined"}]},{"tag":"namespace","name":"ReverseSearcher","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern15ReverseSearcher16next_reject_back17hb37fdd1f85e268eeE","name":"next_reject_back<core::str::pattern::MultiCharEqSearcher<closure>>","decl_file":46,"decl_line":212,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str7pattern15ReverseSearcher16next_reject_back17ha321b7dea0f115acE","name":"next_reject_back<core::str::pattern::MultiCharEqSearcher<closure>>","decl_file":46,"decl_line":212,"inline":"inlined"}]}]},{"tag":"structure_type","name":"IsAsciiWhitespace","byte_size":0,"alignment":1},{"tag":"structure_type","name":"IsNotEmpty","byte_size":0,"alignment":1},{"tag":"structure_type","name":"Split<core::str::IsWhitespace>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"__0","type":"SplitInternal<core::str::IsWhitespace>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"SplitInternal<core::str::IsWhitespace>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"matcher","type":"CharPredicateSearcher<core::str::IsWhitespace>","alignment":4,"data_member_location":8},{"tag":"member","name":"allow_trailing_empty","type":"bool","alignment":1,"data_member_location":28},{"tag":"member","name":"finished","type":"bool","alignment":1,"data_member_location":29}]},{"tag":"structure_type","name":"IsWhitespace","byte_size":0,"alignment":1},{"tag":"structure_type","name":"CharIndices","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"front_offset","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"iter","type":"Chars","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Chars","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"iter","type":"Iter<u8>","alignment":4,"data_member_location":0}]},{"tag":"variable","name":"UTF8_CHAR_WIDTH","type":"u8[]","external":true,"decl_file":3,"decl_line":1550,"location":"0307041000 // DW_OP_addr 0x100407","linkage_name":"_ZN4core3str15UTF8_CHAR_WIDTH17h0edabf5e47262743E"},{"tag":"structure_type","name":"LinesAnyMap","byte_size":0,"alignment":1},{"tag":"structure_type","name":"Lines","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"__0","type":"Map<core::str::SplitTerminator<char>, core::str::LinesAnyMap>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeBytesToStr","byte_size":0,"alignment":1},{"tag":"namespace","name":"traits","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$3get17hfaab8eba00b01ee1E","name":"get","decl_file":3,"decl_line":1959,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index17h6802cbf05d4f9b72E","name":"index","decl_file":3,"decl_line":1987,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeFrom$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hc500bce2e9274891E","name":"index","decl_file":3,"decl_line":1737,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$13get_unchecked17ha395a38e6c0c4df4E","name":"get_unchecked","decl_file":3,"decl_line":1975,"inline":"inlined"},{"tag":"namespace","name":"index","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index28_$u7b$$u7b$closure$u7d$$u7d$17h8aaa9dc446bffd77E","name":"{{closure}}","decl_file":3,"decl_line":1989,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$5index28_$u7b$$u7b$closure$u7d$$u7d$17hab2a1398c145e50eE","name":"{{closure}}","decl_file":3,"decl_line":1942,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits101_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..Range$LT$usize$GT$$GT$5index17h2244722bd389a77aE","name":"index","decl_file":3,"decl_line":1892,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits101_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..Range$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17h98bbdbcaa5d9a8e5E","name":"index","decl_file":3,"decl_line":1669,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits101_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..Range$LT$usize$GT$$GT$3get17h37636b62714debd6E","name":"get","decl_file":3,"decl_line":1860,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits101_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..Range$LT$usize$GT$$GT$13get_unchecked17he6beb4ad135e2370E","name":"get_unchecked","decl_file":3,"decl_line":1880,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$3get17h41d6422e30080ed7E","name":"get","decl_file":3,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$5index17h269b7abc6966044bE","name":"index","decl_file":3,"decl_line":1940,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str6traits103_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeTo$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hff9ba3639eb88e1aE","name":"index","decl_file":3,"decl_line":1707,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","name":"is_char_boundary","decl_file":3,"decl_line":2187,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h31769beda6688264E","name":"next","decl_file":3,"decl_line":570,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$core..str..CharIndices$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h9250e4d66959239aE","name":"next","decl_file":3,"decl_line":668,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$5chars17h17846ad5a6c66389E","name":"chars","decl_file":3,"decl_line":2631,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$12char_indices17h3bfb57c69ee757a6E","name":"char_indices","decl_file":3,"decl_line":2686,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$12trim_matches17h5056684aaeccc8f6E","name":"trim_matches<closure>","decl_file":3,"decl_line":3734,"inline":"inlined"},{"tag":"namespace","name":"trim","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$4trim28_$u7b$$u7b$closure$u7d$$u7d$17h4036b6fd3ca31d4dE","name":"{{closure}}","decl_file":3,"decl_line":3563,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h67d22cbee9db1bcaE","name":"next_back","decl_file":3,"decl_line":609,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN96_$LT$core..str..CharIndices$LT$$u27$a$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h7a7d4be6950f2e74E","name":"next_back","decl_file":3,"decl_line":701,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$13get_unchecked17hb86f0fa8cdf2db9dE","name":"get_unchecked<core::ops::range::Range<usize>>","decl_file":3,"decl_line":2374,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$18trim_start_matches17h3fbcb616145280ecE","name":"trim_start_matches<closure>","decl_file":3,"decl_line":3779,"inline":"inlined"},{"tag":"namespace","name":"trim_start","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$10trim_start28_$u7b$$u7b$closure$u7d$$u7d$17hf0c711de42fe76abE","name":"{{closure}}","decl_file":3,"decl_line":3598,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$16trim_end_matches17hb1864472f1c7680fE","name":"trim_end_matches<closure>","decl_file":3,"decl_line":3822,"inline":"inlined"},{"tag":"namespace","name":"trim_end","children":[{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$8trim_end28_$u7b$$u7b$closure$u7d$$u7d$17h88a76221d06c8199E","name":"{{closure}}","decl_file":3,"decl_line":3633,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$4find17h354f7d14d1a3c003E","name":"find<char>","decl_file":3,"decl_line":2981,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$5count17h6bae085655498417E","name":"count","decl_file":3,"decl_line":580,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$3get17h04a5964722632793E","name":"get<core::ops::range::RangeTo<usize>>","decl_file":3,"decl_line":2308,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str21_$LT$impl$u20$str$GT$8is_empty17hbad2300f624684bdE","name":"is_empty","decl_file":3,"decl_line":2157,"inline":"inlined"},{"tag":"subprogram","low_pc":35106,"high_pc":35367,"linkage_name":"_ZN57_$LT$core..str..Utf8Error$u20$as$u20$core..fmt..Debug$GT$3fmt17hdaac36b077d2ace5E","name":"fmt","decl_file":3,"decl_line":203,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12debug_struct17hf1d54c710f695d74E","low_pc":35126,"high_pc":35176,"call_file":3,"call_line":203,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders16debug_struct_new17h21ca356c25f15cebE","low_pc":35126,"high_pc":35176,"call_file":15,"call_line":1743,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35128,"high_pc":35159,"call_file":39,"call_line":99}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct6finish17h70a13c3215c3f625E","ranges":[[35249,35345],[35357,35366]],"call_file":3,"call_line":203,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h112ff9015b0c4b81E","low_pc":35278,"high_pc":35337,"call_file":39,"call_line":140,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct6finish28_$u7b$$u7b$closure$u7d$$u7d$17h196f6bd8fc374200E","low_pc":35284,"high_pc":35337,"call_file":6,"call_line":647,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct9is_pretty17h73fc38e3f5dd0a47E","ranges":[[35284,35289],[35306,35314]],"call_file":39,"call_line":141,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","low_pc":35306,"high_pc":35314,"call_file":39,"call_line":152}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN67_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h5ba18debac6895dbE","name":"fmt","decl_file":3,"decl_line":469,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"lossy","children":[{"tag":"structure_type","name":"Utf8Lossy","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"bytes","type":"u8[]","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN102_$LT$core..str..lossy..Utf8LossyChunksIter$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next10unsafe_get17h733c33e92d49ab37E","name":"unsafe_get","decl_file":132,"decl_line":65,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN102_$LT$core..str..lossy..Utf8LossyChunksIter$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next8safe_get17h8ea1ebca56037d06E","name":"safe_get","decl_file":132,"decl_line":68,"inline":"inlined"}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3str15utf8_char_width17h2b3309b9e6ca7301E","name":"utf8_char_width","decl_file":3,"decl_line":1572,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str15next_code_point17h1e0c4a51b9b46e12E","name":"next_code_point<core::slice::Iter<u8>>","decl_file":3,"decl_line":502,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","name":"unwrap_or_0","decl_file":3,"decl_line":491,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","name":"utf8_acc_cont_byte","decl_file":3,"decl_line":483,"inline":"inlined"},{"tag":"structure_type","name":"Utf8Error","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"valid_up_to","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"error_len","type":"Option<u8>","alignment":1,"data_member_location":4}]},{"tag":"subprogram","low_pc":29675,"high_pc":29801,"linkage_name":"_ZN4core3str9from_utf817h27be525415e88fc5E","name":"from_utf8","decl_file":3,"decl_line":339,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$11into_result17h3a8e6d30b8d09609E","low_pc":29712,"high_pc":29730,"call_file":3,"call_line":340},{"tag":"inlined_subroutine","abstract_origin":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17h13c539d063a0a363E","low_pc":29767,"high_pc":29781,"call_file":3,"call_line":340}]},{"tag":"subprogram","low_pc":29803,"high_pc":30694,"linkage_name":"_ZN4core3str19run_utf8_validation17hd863825c15eb00b4E","name":"run_utf8_validation","decl_file":3,"decl_line":1432,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$12align_offset17h493a3853f063996bE","low_pc":29895,"high_pc":29900,"call_file":3,"call_line":1521,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr12align_offset17hdcf595db677a1368E","low_pc":29895,"high_pc":29900,"call_file":0,"call_line":1566}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3str25truncate_to_char_boundary17hb0f0ec737f19ee97E","name":"truncate_to_char_boundary","decl_file":3,"decl_line":2073,"inline":"inlined"},{"tag":"subprogram","low_pc":24368,"high_pc":25659,"linkage_name":"_ZN4core3str16slice_error_fail17hb66efea0a13ac342E","name":"slice_error_fail","decl_file":3,"decl_line":2086,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str25truncate_to_char_boundary17hb0f0ec737f19ee97E","low_pc":24407,"high_pc":24509,"call_file":3,"call_line":2088,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","ranges":[[24423,24458],[24472,24499]],"call_file":3,"call_line":2077,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","low_pc":24423,"high_pc":24444,"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","low_pc":24423,"high_pc":24444,"call_file":9,"call_line":288}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","low_pc":24591,"high_pc":24625,"call_file":3,"call_line":2102,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","ranges":[[24607,24612],[24614,24619]],"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","ranges":[[24607,24612],[24614,24619]],"call_file":9,"call_line":288,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","low_pc":24614,"high_pc":24619,"call_file":9,"call_line":2417,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":24614,"high_pc":24619,"call_file":9,"call_line":2437,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":24614,"high_pc":24619,"call_file":0,"call_line":1300}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","ranges":[[24640,24686],[24696,24721]],"call_file":3,"call_line":2105,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","low_pc":24652,"high_pc":24670,"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","low_pc":24652,"high_pc":24670,"call_file":9,"call_line":288}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeFrom$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hc500bce2e9274891E","low_pc":24909,"high_pc":24916,"call_file":3,"call_line":2109,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index17h6802cbf05d4f9b72E","low_pc":24909,"high_pc":24916,"call_file":3,"call_line":1738,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$3get17hfaab8eba00b01ee1E","low_pc":24909,"high_pc":24916,"call_file":3,"call_line":1989,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$13get_unchecked17ha395a38e6c0c4df4E","low_pc":24909,"high_pc":24916,"call_file":3,"call_line":1961,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":24909,"high_pc":24916,"call_file":3,"call_line":1976,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":24909,"high_pc":24916,"call_file":0,"call_line":1300}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h31769beda6688264E","ranges":[[24917,24919],[24924,24953],[24990,25149]],"call_file":3,"call_line":2109,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str15next_code_point17h1e0c4a51b9b46e12E","ranges":[[24917,24919],[24924,24953],[24990,25149]],"call_file":3,"call_line":571,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[24917,24919],[24924,24929]],"call_file":3,"call_line":504},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":24990,"high_pc":25002,"call_file":3,"call_line":513,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":24995,"high_pc":25002,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":24995,"high_pc":25002,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":25002,"high_pc":25015,"call_file":3,"call_line":513},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":25049,"high_pc":25065,"call_file":3,"call_line":518,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":25058,"high_pc":25065,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":25058,"high_pc":25065,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":25065,"high_pc":25075,"call_file":3,"call_line":518},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","low_pc":25076,"high_pc":25086,"call_file":3,"call_line":519},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":25102,"high_pc":25111,"call_file":3,"call_line":524},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":25111,"high_pc":25121,"call_file":3,"call_line":524},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","ranges":[[25122,25127],[25138,25139]],"call_file":3,"call_line":525}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$5chars17h17846ad5a6c66389E","low_pc":24919,"high_pc":24924,"call_file":3,"call_line":2109,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h83d1fcaffa6c4106E","low_pc":24919,"high_pc":24924,"call_file":3,"call_line":2632,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":24919,"high_pc":24924,"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":24919,"high_pc":24924,"call_file":0,"call_line":1300}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","low_pc":25197,"high_pc":25231,"call_file":3,"call_line":2110},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[25315,25341],[25359,25388],[25428,25439]],"call_file":3,"call_line":2111},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h876ce2ec7ad75965E","ranges":[[25149,25154],[25645,25659]],"call_file":3,"call_line":2109},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[24778,24804],[24815,24844],[24874,24885]],"call_file":3,"call_line":2094},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[25509,25535],[25546,25575],[25615,25626]],"call_file":3,"call_line":2098}]},{"tag":"subprogram","linkage_name":"_ZN4core3str23next_code_point_reverse17hd3a3df88bb9e812bE","name":"next_code_point_reverse<core::slice::Iter<u8>>","decl_file":3,"decl_line":535,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3str17utf8_is_cont_byte17h6c0ed45c25029789E","name":"utf8_is_cont_byte","decl_file":3,"decl_line":488,"inline":"inlined"}]},{"tag":"namespace","name":"iter","children":[{"tag":"structure_type","name":"Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"iter","type":"Split<u8, core::str::IsAsciiWhitespace>","alignment":4,"data_member_location":0},{"tag":"member","name":"predicate","type":"IsNotEmpty","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Cloned<core::slice::Iter<u8>>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"it","type":"Iter<u8>","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"Map<core::str::SplitTerminator<char>, core::str::LinesAnyMap>","byte_size":40,"alignment":4,"children":[{"tag":"member","name":"iter","type":"SplitTerminator<char>","alignment":4,"data_member_location":0},{"tag":"member","name":"f","type":"LinesAnyMap","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Filter<core::str::Split<core::str::IsWhitespace>, core::str::IsNotEmpty>","byte_size":32,"alignment":4,"children":[{"tag":"member","name":"iter","type":"Split<core::str::IsWhitespace>","alignment":4,"data_member_location":0},{"tag":"member","name":"predicate","type":"IsNotEmpty","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Map<core::iter::Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>, core::str::UnsafeBytesToStr>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"iter","type":"Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>","alignment":4,"data_member_location":0},{"tag":"member","name":"f","type":"UnsafeBytesToStr","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hd85351a15dbf6f74E","name":"next<core::slice::Iter<u32>>","decl_file":52,"decl_line":1747,"inline":"inlined"},{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h1ec448e55ae3c9daE","name":"{{closure}}<core::slice::Iter<u32>>","decl_file":52,"decl_line":1748,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h9259e4b6bc665f05E","name":"{{closure}}<core::slice::Iter<core::fmt::rt::v1::Argument>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1150,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17hc8a702b52f2aa71eE","name":"{{closure}}<core::slice::Iter<core::fmt::ArgumentV1>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1150,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h41711cbf3b928f39E","name":"{{closure}}<core::slice::Iter<u8>>","decl_file":52,"decl_line":1748,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17hb0cb71d24c4b0dc8E","name":"next<core::slice::IterMut<u32>,core::slice::Iter<u32>>","decl_file":52,"decl_line":1217,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hed29f847838ac54eE","name":"next<core::slice::IterMut<u32>,core::slice::Iter<u32>>","decl_file":52,"decl_line":1087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17hfeeb3e471207417cE","name":"next_back<core::slice::Iter<u32>,u32>","decl_file":52,"decl_line":548,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha98ab7f545a369feE","name":"next<core::iter::Cloned<core::slice::Iter<u32>>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h0c2f62f0dcc1acb2E","name":"next<core::slice::IterMut<u32>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1838dcbc4b843a6aE","name":"next<core::slice::IterMut<u8>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN86_$LT$core..iter..Chain$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hd9ddad550e5de2d6E","name":"next<core::slice::Iter<u8>,core::slice::Iter<u8>>","decl_file":52,"decl_line":859,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h8d98418be78ca1d2E","name":"next<core::ops::range::Range<usize>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter_private..TrustedRandomAccess$GT$13get_unchecked17h142ea7aa577c8077E","name":"get_unchecked<core::slice::Iter<u8>,u8>","decl_file":52,"decl_line":599,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17h3e9d44392f549a5fE","name":"next<core::slice::Iter<core::fmt::rt::v1::Argument>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1149,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17heb85f9030f3304aeE","name":"next<core::slice::Iter<core::fmt::rt::v1::Argument>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17h172b207a47c65f43E","name":"next<core::slice::Iter<core::fmt::ArgumentV1>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1149,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h0eee9070536e9fa1E","name":"next<core::slice::Iter<core::fmt::ArgumentV1>,&mut core::slice::Iter<&str>>","decl_file":52,"decl_line":1087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1c5d159a4850bfd1E","name":"next<core::slice::Iter<u8>,u8>","decl_file":52,"decl_line":523,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17hde44fc31608d02c6E","name":"try_fold<core::slice::Iter<u32>,usize,closure,core::iter::LoopState<usize, core::result::Result<usize, !>>>","decl_file":52,"decl_line":431,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..TakeWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h409f6b8b23e551deE","name":"try_fold<core::iter::Rev<core::slice::Iter<u32>>,closure,usize,closure,core::result::Result<usize, !>>","decl_file":52,"decl_line":2181,"inline":"inlined"},{"tag":"namespace","name":"try_fold","children":[{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..TakeWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold28_$u7b$$u7b$closure$u7d$$u7d$17h7609a1d22bb969d6E","name":"{{closure}}<core::iter::Rev<core::slice::Iter<u32>>,closure,usize,closure,core::result::Result<usize, !>>","decl_file":52,"decl_line":2189,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..TakeWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold28_$u7b$$u7b$closure$u7d$$u7d$17h68efde92640a1db2E","name":"{{closure}}<core::iter::Rev<core::slice::Iter<u8>>,closure,usize,closure,core::result::Result<usize, !>>","decl_file":52,"decl_line":2189,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h3c5d189604d7c25bE","name":"next<core::slice::Iter<u32>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h4985cd3ab797e76aE","name":"try_fold<core::slice::Iter<u8>,usize,closure,core::iter::LoopState<usize, core::result::Result<usize, !>>>","decl_file":52,"decl_line":431,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN90_$LT$core..iter..TakeWhile$LT$I$C$$u20$P$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17hff889dd0bd035feaE","name":"try_fold<core::iter::Rev<core::slice::Iter<u8>>,closure,usize,closure,core::result::Result<usize, !>>","decl_file":52,"decl_line":2181,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17ha396274b90b91d12E","name":"next<core::slice::IterMut<u8>,core::slice::Iter<u8>>","decl_file":52,"decl_line":1217,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hbf57221632ea8b59E","name":"next<core::slice::IterMut<u8>,core::slice::Iter<u8>>","decl_file":52,"decl_line":1087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN81_$LT$core..iter..Enumerate$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hb9b567f84cddde62E","name":"next<core::slice::Iter<u8>>","decl_file":52,"decl_line":1747,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN87_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h86862b5399a58c4cE","name":"next_back<core::slice::Iter<u8>,u8>","decl_file":52,"decl_line":548,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1f2ec1b1c5f0f117E","name":"next<core::iter::Cloned<core::slice::Iter<u8>>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h8c93281aceec1179E","name":"next<core::slice::Iter<u8>>","decl_file":52,"decl_line":427,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h1d28abf2e68e2a68E","name":"fmt<core::str::SplitTerminator<char>,core::str::LinesAnyMap>","decl_file":52,"decl_line":1381,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h542edf889a58ea50E","name":"fmt<core::slice::Iter<u8>>","decl_file":52,"decl_line":512,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$core..iter..Map$LT$I$C$$u20$F$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h6d2114736fd4e084E","name":"fmt<core::iter::Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>,core::str::UnsafeBytesToStr>","decl_file":52,"decl_line":1381,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..iter..Filter$LT$I$C$$u20$P$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h44c269cc2c857164E","name":"fmt<core::str::Split<core::str::IsWhitespace>,core::str::IsNotEmpty>","decl_file":52,"decl_line":1492,"inline":"inlined"}]},{"tag":"namespace","name":"iterator","children":[{"tag":"namespace","name":"Iterator","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3cmp17he939abfd9f79e391E","name":"cmp<core::iter::Rev<core::iter::Cloned<core::slice::Iter<u32>>>,core::iter::Rev<core::iter::Cloned<core::slice::Iter<u32>>>>","decl_file":36,"decl_line":2357,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each17hca265807c865e7a2E","name":"try_for_each<core::slice::Iter<u32>,closure,core::iter::LoopState<(), ()>>","decl_file":36,"decl_line":1617,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3all17hd4dd08766327d9efE","name":"all<core::slice::Iter<u32>,closure>","decl_file":36,"decl_line":1737,"inline":"inlined"},{"tag":"namespace","name":"all","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3all28_$u7b$$u7b$closure$u7d$$u7d$17h149c07d043f5a209E","name":"{{closure}}<core::slice::Iter<u32>,closure>","decl_file":36,"decl_line":1740,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3all28_$u7b$$u7b$closure$u7d$$u7d$17hd255c757c846fbb8E","name":"{{closure}}<core::slice::Iter<u8>,closure>","decl_file":36,"decl_line":1740,"inline":"inlined"}]},{"tag":"namespace","name":"try_for_each","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each28_$u7b$$u7b$closure$u7d$$u7d$17h8047e39d32c2b493E","name":"{{closure}}<core::slice::Iter<u32>,closure,core::iter::LoopState<(), ()>>","decl_file":36,"decl_line":1620,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each28_$u7b$$u7b$closure$u7d$$u7d$17h1ed794cca961499fE","name":"{{closure}}<core::slice::Iter<u8>,closure,core::iter::LoopState<(), ()>>","decl_file":36,"decl_line":1620,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator5chain17h2abe735ee9c177a1E","name":"chain<core::slice::Iter<u8>,&[u8]>","decl_file":36,"decl_line":434,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3nth17ha4d36bcf54da898bE","name":"nth<core::char::EscapeUnicode>","decl_file":36,"decl_line":324,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3nth17hd22782ece4537fa3E","name":"nth<core::str::CharIndices>","decl_file":36,"decl_line":324,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold17h1cfc8d6f0746b8c6E","name":"fold<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u32>>, closure>,usize,closure>","decl_file":36,"decl_line":1692,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator5count17heee63d22637a7d33E","name":"count<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u32>>, closure>>","decl_file":36,"decl_line":249,"inline":"inlined"},{"tag":"namespace","name":"count","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator5count28_$u7b$$u7b$closure$u7d$$u7d$17h686da4877284d669E","name":"{{closure}}<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u32>>, closure>>","decl_file":36,"decl_line":251,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator5count28_$u7b$$u7b$closure$u7d$$u7d$17hda7c511625800e6cE","name":"{{closure}}<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u8>>, closure>>","decl_file":36,"decl_line":251,"inline":"inlined"}]},{"tag":"namespace","name":"fold","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold28_$u7b$$u7b$closure$u7d$$u7d$17h36081e93eaf8950bE","name":"{{closure}}<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u32>>, closure>,usize,closure>","decl_file":36,"decl_line":1695,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold28_$u7b$$u7b$closure$u7d$$u7d$17h4eb84c3804499871E","name":"{{closure}}<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u8>>, closure>,usize,closure>","decl_file":36,"decl_line":1695,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator12try_for_each17hf8c2e4aff59d3e7fE","name":"try_for_each<core::slice::Iter<u8>,closure,core::iter::LoopState<(), ()>>","decl_file":36,"decl_line":1617,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3all17he70290b6a8dc783fE","name":"all<core::slice::Iter<u8>,closure>","decl_file":36,"decl_line":1737,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator4fold17h138b683c598f4cf4E","name":"fold<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u8>>, closure>,usize,closure>","decl_file":36,"decl_line":1692,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator5count17h2995361c6ea603baE","name":"count<core::iter::TakeWhile<core::iter::Rev<core::slice::Iter<u8>>, closure>>","decl_file":36,"decl_line":249,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter8iterator8Iterator3cmp17hf633ea09ecb0a643E","name":"cmp<core::iter::Rev<core::iter::Cloned<core::slice::Iter<u8>>>,core::iter::Rev<core::iter::Cloned<core::slice::Iter<u8>>>>","decl_file":36,"decl_line":2357,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h80656c98a8491e82E","name":"next<core::char::EscapeUnicode>","decl_file":36,"decl_line":2623,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5983f0a4d9bde8a9E","name":"next<core::slice::Iter<&str>>","decl_file":36,"decl_line":2623,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha3c6b07f08ce7ba6E","name":"next<core::str::CharIndices>","decl_file":36,"decl_line":2623,"inline":"inlined"}]}]},{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","name":"next<usize>","decl_file":32,"decl_line":221,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter5range102_$LT$impl$u20$core..iter..traits..DoubleEndedIterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$9next_back17h49a56979dba1a711E","name":"next_back<usize>","decl_file":32,"decl_line":292,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$usize$u20$as$u20$core..iter..range..Step$GT$7sub_one17h4f68a7ccf85a7134E","name":"sub_one","decl_file":32,"decl_line":68,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$9size_hint17h03f32013c4456583E","name":"size_hint<usize>","decl_file":32,"decl_line":239,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$usize$u20$as$u20$core..iter..range..Step$GT$13steps_between17h2c2a68405e58fbf9E","name":"steps_between","decl_file":32,"decl_line":82,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"slice","children":[{"tag":"structure_type","name":"Split<u8, core::str::IsAsciiWhitespace>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"v","type":"&[u8]","alignment":4,"data_member_location":0},{"tag":"member","name":"pred","type":"IsAsciiWhitespace","alignment":1,"data_member_location":0},{"tag":"member","name":"finished","type":"bool","alignment":1,"data_member_location":8}]},{"tag":"structure_type","name":"Iter<u8>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u8","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","name":"post_inc_start<u8>","decl_file":9,"decl_line":2781,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$11pre_dec_end17h69d564b5ef3a851aE","name":"pre_dec_end<u8>","decl_file":9,"decl_line":2797,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$10make_slice17hab63a0dfbdfc9d6fE","name":"make_slice<u8>","decl_file":9,"decl_line":2773,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$8as_slice17hd2967abbe5abf225E","name":"as_slice<u8>","decl_file":9,"decl_line":3078,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<core::fmt::ArgumentV1>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&core::fmt::ArgumentV1>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hf7013462497e4851E","name":"post_inc_start<core::fmt::ArgumentV1>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h6facb862c0dc8469E","name":"index_mut<u32>","decl_file":9,"decl_line":2507,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h774851819fc161c2E","name":"index_mut<u32>","decl_file":9,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17h0276620bb1659545E","name":"index_mut<u32,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha3458687ff7c9c28E","name":"next<u32>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$10as_mut_ptr17h649b4865ab026162E","name":"as_mut_ptr<u32>","decl_file":9,"decl_line":416,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8iter_mut17h251a5a4e493e7e1fE","name":"iter_mut<u32>","decl_file":9,"decl_line":571,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice97_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$mut$u20$$u5b$T$u5d$$GT$9into_iter17h9b6f29df086906e7E","name":"into_iter<u32>","decl_file":9,"decl_line":2734,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h51c9d619d8f43fc5E","name":"index<u32>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h9ba2e9ef97b3dc0dE","name":"index<u32>","decl_file":9,"decl_line":2544,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17hab97bb95259d3017E","name":"index<u32,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h48d9506a6bd58985E","name":"next<u32>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter_private..TrustedRandomAccess$GT$13get_unchecked17h224126b0a9dc5965E","name":"get_unchecked<u32>","decl_file":9,"decl_line":5039,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h37e123031f97413cE","name":"next_back<u32>","decl_file":9,"decl_line":2951,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h5a4c6b361b1b02ffE","name":"next_back<u32>","decl_file":9,"decl_line":2951,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17hd5616f79929f6e4fE","name":"iter<u32>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h0e0e7fa704c8b18fE","name":"try_fold<u32,(),closure,core::iter::LoopState<(), ()>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17h76da6f3bd4cc6addE","name":"index_mut<u8>","decl_file":9,"decl_line":2507,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17h230cbc772747d877E","name":"index_mut<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN94_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h7ab197718405dfebE","name":"next<u8>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h4fadaadce9afab0bE","name":"get_unchecked_mut<u8>","decl_file":9,"decl_line":2490,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17ha163ce694cb65abfE","name":"index_mut<u8>","decl_file":9,"decl_line":2549,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17ha8dfeefdc6c722f9E","name":"index_mut<u8,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","name":"index<u8>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hb7398b68e44a8adeE","name":"index<u8>","decl_file":9,"decl_line":2544,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h07ea9aadbe99b000E","name":"index<u8,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17h1a630bc105449a6fE","name":"try_rfold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition17h49f4fd10563ec232E","name":"rposition<u8,closure>","decl_file":9,"decl_line":2930,"inline":"inlined"},{"tag":"namespace","name":"rposition","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17ha348dfce5258ffccE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2936,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17hb31d84d14a26b6fbE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2941,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17h08fdd2d6662379eaE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2936,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17h4512eac355e3240dE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2941,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17h3d54c3538d1444bfE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2936,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition28_$u7b$$u7b$closure$u7d$$u7d$17h31dc2bf4a5fbe676E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2941,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$15copy_from_slice17h7f4c58e94feeef48E","name":"copy_from_slice<u8>","decl_file":9,"decl_line":1957,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17hbe4f166853987af6E","name":"next_back<u8>","decl_file":9,"decl_line":2951,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h263106ee32500e62E","name":"next<core::num::flt2dec::Part>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$9index_mut17hd5af8beb2266717bE","name":"index_mut<u8>","decl_file":9,"decl_line":2584,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice77_$LT$impl$u20$core..ops..index..IndexMut$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$9index_mut17h84948bfcd4f95ccfE","name":"index_mut<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2326,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","name":"get_unchecked<u8>","decl_file":9,"decl_line":2485,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","name":"index<u8>","decl_file":9,"decl_line":2579,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","name":"index<u8,core::ops::range::RangeFrom<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17hd651f7a13cde850eE","name":"index<core::num::flt2dec::Part>","decl_file":9,"decl_line":2495,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN101_$LT$core..ops..range..RangeTo$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h57a8b47e3a121b1cE","name":"index<core::num::flt2dec::Part>","decl_file":9,"decl_line":2544,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h65463a28a072d9bdE","name":"index<core::num::flt2dec::Part,core::ops::range::RangeTo<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h83d1fcaffa6c4106E","name":"iter<u8>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice89_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$$u5b$T$u5d$$GT$9into_iter17h775401d5360ae84cE","name":"into_iter<u8>","decl_file":9,"decl_line":2724,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","name":"next<u8>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8is_empty17h6ab43293db4f649bE","name":"is_empty<u8>","decl_file":9,"decl_line":105,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h4ce189f4bfb73fb6E","name":"try_fold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17hc253e7e3bd44507aE","name":"position<u8,closure>","decl_file":9,"decl_line":2913,"inline":"inlined"},{"tag":"namespace","name":"position","children":[{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2919,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hda9e296621144f87E","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2923,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2919,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hfd5e6c14dee6671cE","name":"{{closure}}<u8,closure>","decl_file":9,"decl_line":2923,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h9ba3a7ac504132e8E","name":"try_fold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17he0257a3124187b61E","name":"position<u8,closure>","decl_file":9,"decl_line":2913,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8split_at17haab4ad31d2131850E","name":"split_at<u8>","decl_file":9,"decl_line":972,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8align_to17h63a7766ad35505ceE","name":"align_to<u8,(usize, usize)>","decl_file":9,"decl_line":2170,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$16align_to_offsets17hafe1c650d28bbf4bE","name":"align_to_offsets<u8,(usize, usize)>","decl_file":9,"decl_line":2081,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition17ha499ff0dc44cea44E","name":"rposition<u8,closure>","decl_file":9,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17h900451a766ffca20E","name":"try_rfold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17h42d8c0bdf517dbf8E","name":"try_rfold<u8,usize,closure,core::result::Result<usize, usize>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$9rposition17h97a905373ed7415bE","name":"rposition<u8,closure>","decl_file":9,"decl_line":2930,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","name":"get<u8>","decl_file":9,"decl_line":2414,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","name":"get<u8,usize>","decl_file":9,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h54521170cd45ad22E","name":"index<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":2315,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialEq$LT$A$GT$$GT$5equal17h44eebbecbd1aaad8E","name":"equal<u8>","decl_file":9,"decl_line":4915,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice81_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u5d$$GT$$u20$for$u20$$u5b$A$u5d$$GT$2eq17hd37d83aaccfc0670E","name":"eq<u8,u8>","decl_file":9,"decl_line":4856,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4fold17ha153521e9b547cb9E","name":"fold<u8,u64,closure>","decl_file":9,"decl_line":2899,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","name":"get_unchecked<u8>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17h9695ce0034045ff8E","name":"get_unchecked<u8,usize>","decl_file":9,"decl_line":333,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter_private..TrustedRandomAccess$GT$13get_unchecked17h15a8cc5921d49e26E","name":"get_unchecked<u8>","decl_file":9,"decl_line":5031,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back17h3d48b7ba021f1463E","name":"next_back<u8>","decl_file":9,"decl_line":2951,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17hcbf8b341011f5a6eE","name":"len<u8>","decl_file":9,"decl_line":2811,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice30_$LT$impl$u20$$u5b$u8$u5d$$GT$20make_ascii_uppercase17h34416ffd8e41ad80E","name":"make_ascii_uppercase","decl_file":9,"decl_line":2282,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice30_$LT$impl$u20$$u5b$u8$u5d$$GT$20make_ascii_lowercase17h056fc474ef31a7f3E","name":"make_ascii_lowercase","decl_file":9,"decl_line":2299,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h0d4d2d523096c2b8E","name":"get<u8>","decl_file":9,"decl_line":2463,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17hc581dd95cfe0cd91E","name":"get<u8,core::ops::range::Range<usize>>","decl_file":9,"decl_line":285,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN79_$LT$core..slice..Iter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hfffc7de2ace35ebdE","name":"clone<core::fmt::ArgumentV1>","decl_file":9,"decl_line":3087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17haafe13890276ab59E","name":"iter<core::fmt::ArgumentV1>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h2001211d5374b2f8E","name":"iter<&str>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hdff8e6e2a7b9ca0cE","name":"next<core::fmt::rt::v1::Argument>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5a43416b3e4eac2aE","name":"next<&str>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hcc91a81bb5814180E","name":"next<core::fmt::ArgumentV1>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h6f3f238d3ca161feE","name":"iter<core::num::flt2dec::Part>","decl_file":9,"decl_line":539,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice89_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$$u5b$T$u5d$$GT$9into_iter17h7765ef45b3c44f3eE","name":"into_iter<core::num::flt2dec::Part>","decl_file":9,"decl_line":2724,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5fa51d854db1eab1E","name":"next<(u8, u8)>","decl_file":9,"decl_line":2826,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$16binary_search_by17hcfe30ae7f3e59d12E","name":"binary_search_by<(char, [char; 3]),closure>","decl_file":9,"decl_line":1409,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17h59216009bf4eaf6eE","name":"try_rfold<u32,usize,closure,core::iter::LoopState<usize, core::result::Result<usize, !>>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialEq$LT$A$GT$$GT$5equal17h9fb90260a9abb663E","name":"equal<u32>","decl_file":9,"decl_line":4915,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice81_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u5d$$GT$$u20$for$u20$$u5b$A$u5d$$GT$2eq17h099ad021603f74d1E","name":"eq<u32,u32>","decl_file":9,"decl_line":4856,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h0e7a7979f6e75136E","name":"try_fold<u8,(),closure,core::iter::LoopState<(), ()>>","decl_file":9,"decl_line":2879,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN100_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9try_rfold17h760a30b8bbcbe700E","name":"try_rfold<u8,usize,closure,core::iter::LoopState<usize, core::result::Result<usize, !>>>","decl_file":9,"decl_line":2967,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN103_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter_private..TrustedRandomAccess$GT$13get_unchecked17ha3085bb5d54fa93eE","name":"get_unchecked<u8>","decl_file":9,"decl_line":5039,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$10as_mut_ptr17hddb5f7e970067705E","name":"as_mut_ptr<u8>","decl_file":9,"decl_line":416,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$8iter_mut17h39c46cad021a194dE","name":"iter_mut<u8>","decl_file":9,"decl_line":571,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice97_$LT$impl$u20$core..iter..traits..IntoIterator$u20$for$u20$$RF$$u27$a$u20$mut$u20$$u5b$T$u5d$$GT$9into_iter17h5b6e54833245ae10E","name":"into_iter<u8>","decl_file":9,"decl_line":2734,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$6as_ptr17hdc808996fc5ca9ceE","name":"as_ptr<u8>","decl_file":9,"decl_line":389,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN77_$LT$core..slice..Iter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hb20e336695bf5ec1E","name":"fmt<u8>","decl_file":9,"decl_line":3040,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5f32dd53e9f3835fE","name":"next<char>","decl_file":9,"decl_line":2826,"inline":"inlined"}]},{"tag":"structure_type","name":"IterMut<u32>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*mut u32","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*mut u32","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&mut u32>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN52_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17he81d56da5ac12e25E","name":"post_inc_start<u32>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<u32>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const u32","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const u32","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&u32>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h0fcd314352090e33E","name":"post_inc_start<u32>","decl_file":9,"decl_line":2781,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$11pre_dec_end17h5b5944b3d2e3667fE","name":"pre_dec_end<u32>","decl_file":9,"decl_line":2797,"inline":"inlined"}]},{"tag":"structure_type","name":"IterMut<u8>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*mut u8","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*mut u8","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&mut u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN52_$LT$core..slice..IterMut$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h42431a98b359cd3cE","name":"post_inc_start<u8>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<core::num::flt2dec::Part>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const core::num::flt2dec::Part","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const core::num::flt2dec::Part","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&core::num::flt2dec::Part>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h7ddcb354a1507c21E","name":"post_inc_start<core::num::flt2dec::Part>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"namespace","name":"memchr","children":[{"tag":"namespace","name":"memchr","children":[{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","name":"{{closure}}","decl_file":40,"decl_line":64,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","name":"{{closure}}","decl_file":40,"decl_line":90,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17h190455b2b6bdc8d8E","name":"{{closure}}","decl_file":40,"decl_line":90,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr11repeat_byte17h9f46eb079aac056bE","name":"repeat_byte","decl_file":40,"decl_line":44,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr18contains_zero_byte17hafe31be1b938bb09E","name":"contains_zero_byte","decl_file":40,"decl_line":32,"inline":"inlined"},{"tag":"subprogram","low_pc":28439,"high_pc":29150,"linkage_name":"_ZN4core5slice6memchr6memchr17ha1b71fc6d1bddf2aE","name":"memchr","decl_file":40,"decl_line":49,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$12align_offset17h493a3853f063996bE","low_pc":28446,"high_pc":28455,"call_file":40,"call_line":61,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr12align_offset17hdcf595db677a1368E","low_pc":28446,"high_pc":28455,"call_file":0,"call_line":1566}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h83d1fcaffa6c4106E","ranges":[[28470,28472],[28482,28507]],"call_file":40,"call_line":64,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","ranges":[[28470,28472],[28482,28507]],"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","ranges":[[28470,28472],[28482,28507]],"call_file":0,"call_line":1300}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3min17h4d30ffc98bf66413E","low_pc":28472,"high_pc":28482,"call_file":40,"call_line":63,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp3Ord3min17h015c694494aafd33E","low_pc":28472,"high_pc":28482,"call_file":16,"call_line":838,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","low_pc":28476,"high_pc":28481,"call_file":16,"call_line":575}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17hc253e7e3bd44507aE","low_pc":28507,"high_pc":28717,"call_file":40,"call_line":64,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h4ce189f4bfb73fb6E","low_pc":28507,"high_pc":28702,"call_file":9,"call_line":2919,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":28507,"high_pc":28520,"call_file":9,"call_line":2885},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","low_pc":28523,"high_pc":28543,"call_file":9,"call_line":2886,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","ranges":[[28525,28535],[28538,28543]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","low_pc":28545,"high_pc":28568,"call_file":9,"call_line":2887,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","ranges":[[28547,28560],[28563,28568]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","low_pc":28570,"high_pc":28593,"call_file":9,"call_line":2888,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","ranges":[[28572,28585],[28588,28593]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","ranges":[[28595,28613],[28627,28632]],"call_file":9,"call_line":2889,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","ranges":[[28597,28610],[28627,28632]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hd1e3382c05a7c0a7E","low_pc":28678,"high_pc":28702,"call_file":9,"call_line":2892,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17ha128c97abbc77e68E","low_pc":28678,"high_pc":28702,"call_file":9,"call_line":2920}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h0983efb60d7c6e8cE","low_pc":28702,"high_pc":28717,"call_file":9,"call_line":2919,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hda9e296621144f87E","low_pc":28702,"high_pc":28717,"call_file":14,"call_line":424}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr11repeat_byte17h9f46eb079aac056bE","low_pc":28725,"high_pc":28733,"call_file":40,"call_line":70},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr18contains_zero_byte17hafe31be1b938bb09E","ranges":[[28791,28800],[28822,28829]],"call_file":40,"call_line":80,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":28791,"high_pc":28799,"call_file":40,"call_line":33}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr18contains_zero_byte17hafe31be1b938bb09E","low_pc":28813,"high_pc":28822,"call_file":40,"call_line":79,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":28813,"high_pc":28821,"call_file":40,"call_line":33}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","ranges":[[28846,28861],[29123,29134]],"call_file":40,"call_line":90,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","ranges":[[28846,28861],[29123,29134]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[28846,28861],[29123,29134]],"call_file":9,"call_line":2580,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":28854,"high_pc":28861,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":28854,"high_pc":28861,"call_file":9,"call_line":2486,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":28854,"high_pc":28861,"call_file":0,"call_line":1300}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h83d1fcaffa6c4106E","low_pc":28861,"high_pc":28868,"call_file":40,"call_line":90,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":28861,"high_pc":28868,"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":28861,"high_pc":28868,"call_file":0,"call_line":1300}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position17he0257a3124187b61E","low_pc":28868,"high_pc":29091,"call_file":40,"call_line":90,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8try_fold17h9ba3a7ac504132e8E","low_pc":28868,"high_pc":29076,"call_file":9,"call_line":2919,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num23_$LT$impl$u20$usize$GT$12wrapping_sub17h4e17d1c2d694c49bE","low_pc":28879,"high_pc":28894,"call_file":9,"call_line":2885},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","low_pc":28897,"high_pc":28917,"call_file":9,"call_line":2886,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","ranges":[[28899,28909],[28912,28917]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","low_pc":28919,"high_pc":28942,"call_file":9,"call_line":2887,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","ranges":[[28921,28934],[28937,28942]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","low_pc":28944,"high_pc":28967,"call_file":9,"call_line":2888,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","ranges":[[28946,28959],[28962,28967]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","ranges":[[28969,28987],[29001,29006]],"call_file":9,"call_line":2889,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","ranges":[[28971,28984],[29001,29006]],"call_file":9,"call_line":2920}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17h0ffc1c130561e57aE","low_pc":29052,"high_pc":29076,"call_file":9,"call_line":2892,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17hacbd1286dc97315fE","low_pc":29052,"high_pc":29076,"call_file":9,"call_line":2920}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h27ee98e15c1cd27aE","low_pc":29076,"high_pc":29091,"call_file":9,"call_line":2919,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$8position28_$u7b$$u7b$closure$u7d$$u7d$17hfd5e6c14dee6671cE","low_pc":29076,"high_pc":29091,"call_file":14,"call_line":424}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hfc6bd4ec24aa44a5E","low_pc":29096,"high_pc":29122,"call_file":40,"call_line":90,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice6memchr6memchr28_$u7b$$u7b$closure$u7d$$u7d$17h190455b2b6bdc8d8E","low_pc":29096,"high_pc":29122,"call_file":14,"call_line":424}]}]},{"tag":"namespace","name":"memrchr","children":[{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr7memrchr28_$u7b$$u7b$closure$u7d$$u7d$17h1ff44cff6263acd8E","name":"{{closure}}","decl_file":40,"decl_line":113,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice6memchr7memrchr28_$u7b$$u7b$closure$u7d$$u7d$17h2243970dda2247d1E","name":"{{closure}}","decl_file":40,"decl_line":139,"inline":"inlined"}]}]},{"tag":"subprogram","low_pc":22614,"high_pc":22774,"linkage_name":"_ZN4core5slice20slice_index_len_fail17h0931645dc06345acE","name":"slice_index_len_fail","decl_file":9,"decl_line":2333,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[22665,22688],[22699,22728],[22745,22755]],"call_file":9,"call_line":2334}]},{"tag":"subprogram","low_pc":22894,"high_pc":23054,"linkage_name":"_ZN4core5slice22slice_index_order_fail17hbecc6278d0716654E","name":"slice_index_order_fail","decl_file":9,"decl_line":2339,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[22945,22968],[22979,23008],[23025,23035]],"call_file":9,"call_line":2340}]},{"tag":"structure_type","name":"Iter<&str>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const &str","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&&str>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h34837f87d7b1ac16E","name":"post_inc_start<&str>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"structure_type","name":"Iter<(u8, u8)>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const (u8, u8)","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const (u8, u8)","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&(u8, u8)>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hfd21fe1f698bf910E","name":"post_inc_start<(u8, u8)>","decl_file":9,"decl_line":2781,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core5slice14from_raw_parts17h171124c6ce15658aE","name":"from_raw_parts<u8>","decl_file":9,"decl_line":4786,"inline":"inlined"},{"tag":"structure_type","name":"Iter<char>","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"ptr","type":"*const char","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"*const char","alignment":4,"data_member_location":4},{"tag":"member","name":"_marker","type":"PhantomData<&char>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hba27a27c86e49397E","name":"post_inc_start<char>","decl_file":9,"decl_line":2781,"inline":"inlined"}]}]},{"tag":"namespace","name":"marker","children":[{"tag":"structure_type","name":"PhantomData<&u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<*mut Fn<()>>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&core::fmt::ArgumentV1>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<core::hash::sip::Sip13Rounds>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<core::hash::sip::Sip24Rounds>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&mut u32>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&u32>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&mut u8>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&core::num::flt2dec::Part>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&&str>","byte_size":0,"alignment":1},{"tag":"structure_type","name":"PhantomData<&(u8, u8)>","byte_size":0,"alignment":1},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"PhantomData<&char>","byte_size":0,"alignment":1}]},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"builders","children":[{"tag":"structure_type","name":"PadAdapter","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"buf","type":"&mut Write","alignment":4,"data_member_location":0},{"tag":"member","name":"on_newline","type":"bool","alignment":1,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10PadAdapter4wrap17h8e742939a7385cc1E","name":"wrap","decl_file":39,"decl_line":19,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders16debug_struct_new17h21ca356c25f15cebE","name":"debug_struct_new","decl_file":39,"decl_line":96,"inline":"inlined"},{"tag":"structure_type","name":"DebugStruct","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":4},{"tag":"member","name":"has_fields","type":"bool","alignment":1,"data_member_location":5},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders11DebugStruct6finish17h70a13c3215c3f625E","name":"finish","decl_file":39,"decl_line":138,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders11DebugStruct9is_pretty17h73fc38e3f5dd0a47E","name":"is_pretty","decl_file":39,"decl_line":151,"inline":"inlined"},{"tag":"subprogram","low_pc":27811,"high_pc":28437,"linkage_name":"_ZN4core3fmt8builders11DebugStruct5field17hae51d9be6082c323E","name":"field","decl_file":39,"decl_line":110,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17ha70b8465543f7b55E","low_pc":27859,"high_pc":28396,"call_file":39,"call_line":111,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct5field28_$u7b$$u7b$closure$u7d$$u7d$17hfc156da57f64e0f9E","low_pc":27861,"high_pc":28396,"call_file":6,"call_line":647,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct9is_pretty17h73fc38e3f5dd0a47E","low_pc":27902,"high_pc":27917,"call_file":39,"call_line":118,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","low_pc":27909,"high_pc":27917,"call_file":39,"call_line":152}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_fmt17hdaac2092689000b5E","ranges":[[27948,27958],[27978,28063]],"call_file":39,"call_line":127},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10PadAdapter4wrap17h8e742939a7385cc1E","low_pc":28089,"high_pc":28287,"call_file":39,"call_line":120,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8wrap_buf17h550f14bb5424e99cE","low_pc":28089,"high_pc":28287,"call_file":39,"call_line":21,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10PadAdapter4wrap28_$u7b$$u7b$closure$u7d$$u7d$17haf1f5775935abaf3E","ranges":[[28089,28098],[28103,28106]],"call_file":15,"call_line":1068},{"tag":"inlined_subroutine","abstract_origin":"_ZN79_$LT$core..slice..Iter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hfffc7de2ace35ebdE","ranges":[[28198,28208],[28226,28233]],"call_file":15,"call_line":1079}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":28287,"high_pc":28303,"call_file":39,"call_line":121},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":28305,"high_pc":28325,"call_file":39,"call_line":122},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","ranges":[[28327,28333],[28343,28349]],"call_file":39,"call_line":123},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":28351,"high_pc":28371,"call_file":39,"call_line":124}]}]}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"finish","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders11DebugStruct6finish28_$u7b$$u7b$closure$u7d$$u7d$17h196f6bd8fc374200E","name":"{{closure}}","decl_file":39,"decl_line":140,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugTuple6finish28_$u7b$$u7b$closure$u7d$$u7d$17ha63644281f7846a4E","name":"{{closure}}","decl_file":39,"decl_line":236,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugInner6finish28_$u7b$$u7b$closure$u7d$$u7d$17hb4a1b68c453d8826E","name":"{{closure}}","decl_file":39,"decl_line":289,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders8DebugSet6finish28_$u7b$$u7b$closure$u7d$$u7d$17h8128e4db5a4a0bf5E","name":"{{closure}}","decl_file":39,"decl_line":364,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList6finish28_$u7b$$u7b$closure$u7d$$u7d$17he33632e77dcc23c0E","name":"{{closure}}","decl_file":39,"decl_line":435,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders8DebugMap6finish28_$u7b$$u7b$closure$u7d$$u7d$17h9d250c7b08313bf4E","name":"{{closure}}","decl_file":39,"decl_line":533,"inline":"inlined"}]},{"tag":"subprogram","low_pc":31318,"high_pc":31952,"linkage_name":"_ZN82_$LT$core..fmt..builders..PadAdapter$LT$$u27$_$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h59780f55568356b3E","name":"write_str","decl_file":39,"decl_line":32,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$4find17h354f7d14d1a3c003E","ranges":[[31438,31720],[31752,31763]],"call_file":39,"call_line":38,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN66_$LT$char$u20$as$u20$core..str..pattern..Pattern$LT$$u27$a$GT$$GT$13into_searcher17h718420faa7a4ea32E","low_pc":31438,"high_pc":31492,"call_file":3,"call_line":2982},{"tag":"inlined_subroutine","abstract_origin":"_ZN109_$LT$core..str..pattern..CharSearcher$LT$$u27$a$GT$$u20$as$u20$core..str..pattern..Searcher$LT$$u27$a$GT$$GT$10next_match17hc227a6b56daee9d8E","ranges":[[31492,31720],[31752,31763]],"call_file":3,"call_line":2982,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17hc581dd95cfe0cd91E","low_pc":31587,"high_pc":31592,"call_file":46,"call_line":336,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h0d4d2d523096c2b8E","low_pc":31587,"high_pc":31592,"call_file":9,"call_line":288}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h54521170cd45ad22E","ranges":[[31594,31601],[31752,31763]],"call_file":46,"call_line":337,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[31594,31601],[31752,31763]],"call_file":9,"call_line":2316}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h73592a224be23078E","low_pc":31614,"high_pc":31633,"call_file":46,"call_line":337,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice81_$LT$impl$u20$core..cmp..PartialEq$LT$$u5b$B$u5d$$GT$$u20$for$u20$$u5b$A$u5d$$GT$2eq17hd37d83aaccfc0670E","low_pc":31614,"high_pc":31633,"call_file":16,"call_line":1016,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$$u5b$A$u5d$$u20$as$u20$core..slice..SlicePartialEq$LT$A$GT$$GT$5equal17h44eebbecbd1aaad8E","low_pc":31614,"high_pc":31633,"call_file":9,"call_line":4857}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17h9695ce0034045ff8E","low_pc":31668,"high_pc":31669,"call_file":46,"call_line":314,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","low_pc":31668,"high_pc":31669,"call_file":9,"call_line":336,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":31668,"high_pc":31669,"call_file":9,"call_line":2437,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":31668,"high_pc":31669,"call_file":0,"call_line":1300}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17hc581dd95cfe0cd91E","ranges":[[31642,31647],[31677,31685]],"call_file":46,"call_line":307,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17h0d4d2d523096c2b8E","ranges":[[31642,31647],[31677,31685]],"call_file":9,"call_line":288,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":31677,"high_pc":31685,"call_file":9,"call_line":2468,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":31677,"high_pc":31680,"call_file":9,"call_line":2486,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":31677,"high_pc":31680,"call_file":0,"call_line":1300}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits103_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeTo$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hff9ba3639eb88e1aE","ranges":[[31778,31814],[31920,31935]],"call_file":39,"call_line":48,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$5index17h269b7abc6966044bE","ranges":[[31778,31814],[31920,31935]],"call_file":3,"call_line":1708,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$3get17h41d6422e30080ed7E","low_pc":31778,"high_pc":31814,"call_file":3,"call_line":1942,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","low_pc":31778,"high_pc":31812,"call_file":3,"call_line":1915,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","ranges":[[31793,31798],[31800,31805]],"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","ranges":[[31793,31798],[31800,31805]],"call_file":9,"call_line":288,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","low_pc":31800,"high_pc":31805,"call_file":9,"call_line":2417,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":31800,"high_pc":31805,"call_file":9,"call_line":2437,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":31800,"high_pc":31805,"call_file":0,"call_line":1300}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17hba6de77ea02620cbE","low_pc":31920,"high_pc":31935,"call_file":3,"call_line":1942,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$5index28_$u7b$$u7b$closure$u7d$$u7d$17hab2a1398c145e50eE","low_pc":31920,"high_pc":31935,"call_file":14,"call_line":396}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..ops..index..Index$LT$core..ops..range..RangeFrom$LT$usize$GT$$GT$$u20$for$u20$str$GT$5index17hc500bce2e9274891E","ranges":[[31835,31887],[31936,31952]],"call_file":39,"call_line":49,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index17h6802cbf05d4f9b72E","ranges":[[31835,31887],[31936,31952]],"call_file":3,"call_line":1738,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$3get17hfaab8eba00b01ee1E","low_pc":31835,"high_pc":31887,"call_file":3,"call_line":1989,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","ranges":[[31835,31844],[31854,31875]],"call_file":3,"call_line":1960,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","ranges":[[31854,31859],[31861,31866]],"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","ranges":[[31854,31859],[31861,31866]],"call_file":9,"call_line":288,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","low_pc":31861,"high_pc":31866,"call_file":9,"call_line":2417,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":31861,"high_pc":31866,"call_file":9,"call_line":2437,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":31861,"high_pc":31866,"call_file":0,"call_line":1300}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$13get_unchecked17ha395a38e6c0c4df4E","ranges":[[31844,31853],[31882,31887]],"call_file":3,"call_line":1961,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":31844,"high_pc":31853,"call_file":3,"call_line":1976,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":31844,"high_pc":31853,"call_file":0,"call_line":1300}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17ha537687100ea9096E","low_pc":31936,"high_pc":31952,"call_file":3,"call_line":1989,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits105_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeFrom$LT$usize$GT$$GT$5index28_$u7b$$u7b$closure$u7d$$u7d$17h8aaa9dc446bffd77E","low_pc":31936,"high_pc":31952,"call_file":14,"call_line":396}]}]}]}]},{"tag":"namespace","name":"field","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders11DebugStruct5field28_$u7b$$u7b$closure$u7d$$u7d$17hfc156da57f64e0f9E","name":"{{closure}}","decl_file":39,"decl_line":111,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugTuple5field28_$u7b$$u7b$closure$u7d$$u7d$17hceb3ff20f07bc067E","name":"{{closure}}","decl_file":39,"decl_line":208,"inline":"inlined"}]},{"tag":"namespace","name":"wrap","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10PadAdapter4wrap28_$u7b$$u7b$closure$u7d$$u7d$17haf1f5775935abaf3E","name":"{{closure}}","decl_file":39,"decl_line":21,"inline":"inlined"}]},{"tag":"namespace","name":"entry","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugInner5entry28_$u7b$$u7b$closure$u7d$$u7d$17h6df3f883b8921248E","name":"{{closure}}","decl_file":39,"decl_line":262,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders8DebugMap5entry28_$u7b$$u7b$closure$u7d$$u7d$17h27669eaa8c985719E","name":"{{closure}}","decl_file":39,"decl_line":486,"inline":"inlined"}]}]},{"tag":"structure_type","name":"DebugTuple","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":8},{"tag":"member","name":"fields","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"empty_name","type":"bool","alignment":1,"data_member_location":9},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugTuple9is_pretty17hfbdd7ffd81d575f2E","name":"is_pretty","decl_file":39,"decl_line":249,"inline":"inlined"},{"tag":"subprogram","low_pc":31954,"high_pc":32445,"linkage_name":"_ZN4core3fmt8builders10DebugTuple5field17h9503af1f4a0fce9bE","name":"field","decl_file":39,"decl_line":207,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h29f1ed7a5fefc2beE","low_pc":31990,"high_pc":32401,"call_file":39,"call_line":208,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10DebugTuple5field28_$u7b$$u7b$closure$u7d$$u7d$17hceb3ff20f07bc067E","low_pc":31992,"high_pc":32401,"call_file":6,"call_line":647,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10DebugTuple9is_pretty17hfbdd7ffd81d575f2E","low_pc":32017,"high_pc":32032,"call_file":39,"call_line":215,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","low_pc":32024,"high_pc":32032,"call_file":39,"call_line":250}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":32038,"high_pc":32065,"call_file":39,"call_line":222},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":32072,"high_pc":32115,"call_file":39,"call_line":223},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10PadAdapter4wrap17h8e742939a7385cc1E","low_pc":32141,"high_pc":32342,"call_file":39,"call_line":217,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8wrap_buf17h550f14bb5424e99cE","low_pc":32141,"high_pc":32342,"call_file":39,"call_line":21,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10PadAdapter4wrap28_$u7b$$u7b$closure$u7d$$u7d$17haf1f5775935abaf3E","ranges":[[32141,32150],[32155,32158]],"call_file":15,"call_line":1068},{"tag":"inlined_subroutine","abstract_origin":"_ZN79_$LT$core..slice..Iter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..clone..Clone$GT$5clone17hfffc7de2ace35ebdE","ranges":[[32250,32260],[32277,32284]],"call_file":15,"call_line":1079}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":32342,"high_pc":32357,"call_file":39,"call_line":218},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":32359,"high_pc":32380,"call_file":39,"call_line":219}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugTuple6finish17h8da22b4f85b47dc4E","name":"finish","decl_file":39,"decl_line":234,"external":true,"inline":"inlined"}]},{"tag":"structure_type","name":"DebugInner","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":4},{"tag":"member","name":"has_fields","type":"bool","alignment":1,"data_member_location":5},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugInner9is_pretty17hce69b549a9dbd397E","name":"is_pretty","decl_file":39,"decl_line":292,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders10DebugInner6finish17h4259e6ec2f2fd87fE","name":"finish","decl_file":39,"decl_line":283,"inline":"inlined"}]},{"tag":"structure_type","name":"DebugSet","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"DebugInner","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"DebugList","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"inner","type":"DebugInner","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17h01e4a69a8f844333E","name":"entries<&u8,core::slice::Iter<u8>>","decl_file":39,"decl_line":421,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList5entry17hadb54e3c68a21dd4E","name":"entry","decl_file":39,"decl_line":414,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList6finish17heea15e4e58bdeafaE","name":"finish","decl_file":39,"decl_line":433,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders9DebugList7entries17hfd875edce24654d7E","name":"entries<&char,core::slice::Iter<char>>","decl_file":39,"decl_line":421,"inline":"inlined"}]},{"tag":"structure_type","name":"DebugMap","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"fmt","type":"&mut core::fmt::Formatter","alignment":4,"data_member_location":0},{"tag":"member","name":"result","type":"Result","alignment":1,"data_member_location":4},{"tag":"member","name":"has_fields","type":"bool","alignment":1,"data_member_location":5},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders8DebugMap9is_pretty17hf118026b389946afE","name":"is_pretty","decl_file":39,"decl_line":536,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders15debug_tuple_new17h1fc44805e9836887E","name":"debug_tuple_new","decl_file":39,"decl_line":194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders14debug_list_new17hbdf6d8b63302a688E","name":"debug_list_new","decl_file":39,"decl_line":400,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders13debug_set_new17hde454dedf4fd8341E","name":"debug_set_new","decl_file":39,"decl_line":329,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt8builders13debug_map_new17hc1167845f72c7b79E","name":"debug_map_new","decl_file":39,"decl_line":473,"inline":"inlined"}]},{"tag":"structure_type","name":"&mut Write","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"Write","children":[{"tag":"namespace","name":"write_fmt","children":[{"tag":"structure_type","name":"Adapter<core::fmt::builders::PadAdapter>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&mut core::fmt::builders::PadAdapter","alignment":4,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":32827,"high_pc":32844,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_str17h07fbcaf88a7a8f80E","name":"write_str<core::fmt::builders::PadAdapter>","decl_file":15,"decl_line":213},{"tag":"subprogram","low_pc":32845,"high_pc":32860,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h07c7471390068f01E","name":"write_char<core::fmt::builders::PadAdapter>","decl_file":15,"decl_line":217},{"tag":"subprogram","low_pc":32861,"high_pc":32977,"linkage_name":"_ZN96_$LT$core..fmt..Write..write_fmt..Adapter$LT$$u27$_$C$$u20$T$GT$$u20$as$u20$core..fmt..Write$GT$9write_fmt17h53afa6c1cace4412E","name":"write_fmt<core::fmt::builders::PadAdapter>","decl_file":15,"decl_line":221,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt5Write9write_fmt17h3de7fc76c1106c50E","ranges":[[32881,32883],[32888,32963]],"call_file":15,"call_line":222}]}]}]},{"tag":"subprogram","low_pc":32447,"high_pc":32712,"linkage_name":"_ZN4core3fmt5Write10write_char17he09826fb85f3bf71E","name":"write_char<core::fmt::builders::PadAdapter>","decl_file":15,"decl_line":179,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","low_pc":32474,"high_pc":32680,"call_file":15,"call_line":180}]},{"tag":"subprogram","low_pc":32713,"high_pc":32826,"abstract_origin":"_ZN4core3fmt5Write9write_fmt17h3de7fc76c1106c50E"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5Write9write_fmt17h3de7fc76c1106c50E","name":"write_fmt<core::fmt::builders::PadAdapter>","decl_file":15,"decl_line":204,"inline":"inlined"}]},{"tag":"structure_type","name":"Arguments","byte_size":24,"alignment":4,"children":[{"tag":"member","name":"pieces","type":"&[&str]","alignment":4,"data_member_location":0},{"tag":"member","name":"fmt","type":"Option<&[core::fmt::rt::v1::Argument]>","alignment":4,"data_member_location":8},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":16},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","name":"new_v1_formatted","decl_file":15,"decl_line":362,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Arguments6new_v117h030d4cea03f336acE","name":"new_v1","decl_file":15,"decl_line":344,"inline":"inlined"}]},{"tag":"namespace","name":"rt","children":[{"tag":"namespace","name":"v1","children":[{"tag":"structure_type","name":"Argument","byte_size":36,"alignment":4,"children":[{"tag":"member","name":"position","type":"Position","alignment":4,"data_member_location":0},{"tag":"member","name":"format","type":"FormatSpec","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"Position","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":255310,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Next","type":"Next","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"At","type":"At","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Next","byte_size":8,"alignment":4},{"tag":"structure_type","name":"At","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"FormatSpec","byte_size":28,"alignment":4,"children":[{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":24},{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":4},{"tag":"member","name":"precision","type":"Count","alignment":4,"data_member_location":8},{"tag":"member","name":"width","type":"Count","alignment":4,"data_member_location":16}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Alignment","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Left","const_value":0},{"tag":"enumerator","name":"Right","const_value":1},{"tag":"enumerator","name":"Center","const_value":2},{"tag":"enumerator","name":"Unknown","const_value":3}]},{"tag":"structure_type","name":"Count","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":255484,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Is","type":"Is","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Param","type":"Param","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"NextParam","type":"NextParam","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Implied","type":"Implied","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Is","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Param","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"NextParam","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Implied","byte_size":8,"alignment":4}]}]}]},{"tag":"structure_type","name":"ArgumentV1","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"value","type":"&core::fmt::Void","alignment":4,"data_member_location":0},{"tag":"member","name":"formatter","type":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>","alignment":4,"data_member_location":4},{"tag":"subprogram","low_pc":32978,"high_pc":32990,"linkage_name":"_ZN4core3fmt10ArgumentV110show_usize17h340c143bda28302eE","name":"show_usize","decl_file":15,"decl_line":301},{"tag":"subprogram","linkage_name":"_ZN4core3fmt10ArgumentV13new17he4893e290d1816c8E","name":"new<usize>","decl_file":15,"decl_line":308,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt10ArgumentV18as_usize17h1c6c99782d5efa10E","name":"as_usize","decl_file":15,"decl_line":325,"inline":"inlined"}]},{"tag":"structure_type","name":"Void","byte_size":0,"alignment":1,"children":[{"tag":"member","name":"_priv","type":"()","alignment":1,"data_member_location":0},{"tag":"member","name":"_oibit_remover","type":"PhantomData<*mut Fn<()>>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"Formatter","byte_size":52,"alignment":4,"children":[{"tag":"member","name":"flags","type":"u32","alignment":4,"data_member_location":0},{"tag":"member","name":"fill","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"align","type":"Alignment","alignment":1,"data_member_location":48},{"tag":"member","name":"width","type":"Option<usize>","alignment":4,"data_member_location":8},{"tag":"member","name":"precision","type":"Option<usize>","alignment":4,"data_member_location":16},{"tag":"member","name":"buf","type":"&mut Write","alignment":4,"data_member_location":24},{"tag":"member","name":"curarg","type":"Iter<core::fmt::ArgumentV1>","alignment":4,"data_member_location":32},{"tag":"member","name":"args","type":"&[core::fmt::ArgumentV1]","alignment":4,"data_member_location":40},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter9write_fmt17hdaac2092689000b5E","name":"write_fmt","decl_file":15,"decl_line":1456,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","name":"write_str","decl_file":15,"decl_line":1433,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12debug_struct17hf1d54c710f695d74E","name":"debug_struct","decl_file":15,"decl_line":1742,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","name":"alternate","decl_file":15,"decl_line":1671,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter8wrap_buf17h550f14bb5424e99cE","name":"wrap_buf<closure>","decl_file":15,"decl_line":1063,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter3run17hdc099adb7ddd73ffE","name":"run","decl_file":15,"decl_line":1087,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter8getcount17hc5b67b0fde5a002eE","name":"getcount","decl_file":15,"decl_line":1105,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter9sign_plus17h37013cb556d450f3E","name":"sign_plus","decl_file":15,"decl_line":1620,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter19sign_aware_zero_pad17hbad2460c78727692E","name":"sign_aware_zero_pad","decl_file":15,"decl_line":1694,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12with_padding17h81c220a0cc90cec0E","name":"with_padding<closure>","decl_file":15,"decl_line":1299,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12with_padding17hbe0a2aae62a78e61E","name":"with_padding<closure>","decl_file":15,"decl_line":1299,"inline":"inlined"},{"tag":"subprogram","low_pc":32992,"high_pc":34332,"linkage_name":"_ZN4core3fmt9Formatter12pad_integral17hea7aa821b29c8cb2E","name":"pad_integral","decl_file":15,"decl_line":1165,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9sign_plus17h37013cb556d450f3E","low_pc":33047,"high_pc":33057,"call_file":15,"call_line":1175},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","ranges":[[33080,33089],[33116,33123]],"call_file":15,"call_line":1180},{"tag":"inlined_subroutine","abstract_origin":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$5count17h6bae085655498417E","low_pc":33133,"high_pc":33191,"call_file":15,"call_line":1181,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[33133,33140],[33168,33186]],"call_file":3,"call_line":584,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":33168,"high_pc":33175,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":33168,"high_pc":33175,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str17utf8_is_cont_byte17h6c0ed45c25029789E","low_pc":33160,"high_pc":33165,"call_file":3,"call_line":585}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter19sign_aware_zero_pad17hbad2460c78727692E","low_pc":33285,"high_pc":33290,"call_file":15,"call_line":1207},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12with_padding17h81c220a0cc90cec0E","ranges":[[33301,33329],[33506,33682],[33797,34025]],"call_file":15,"call_line":1217,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","ranges":[[33554,33682],[33797,33863]],"call_file":15,"call_line":1316},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","ranges":[[33868,33884],[33922,33924]],"call_file":15,"call_line":1318,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":33868,"high_pc":33882,"call_file":32,"call_line":222}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12pad_integral28_$u7b$$u7b$closure$u7d$$u7d$17ha08201391a0df7ffE","low_pc":33924,"high_pc":33973,"call_file":15,"call_line":1322},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","low_pc":33979,"high_pc":33993,"call_file":15,"call_line":1324,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":33979,"high_pc":33993,"call_file":32,"call_line":222}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12with_padding17hbe0a2aae62a78e61E","ranges":[[33468,33499],[33683,33796],[34025,34312]],"call_file":15,"call_line":1211,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","ranges":[[33734,33796],[34025,34159]],"call_file":15,"call_line":1316},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","ranges":[[34164,34180],[34218,34220]],"call_file":15,"call_line":1318,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":34164,"high_pc":34178,"call_file":32,"call_line":222}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12pad_integral28_$u7b$$u7b$closure$u7d$$u7d$17h6ecb2cf9072160dcE","low_pc":34220,"high_pc":34254,"call_file":15,"call_line":1322},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","low_pc":34260,"high_pc":34274,"call_file":15,"call_line":1324,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":34260,"high_pc":34274,"call_file":32,"call_line":222}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12with_padding17h5054725e72c3ee87E","name":"with_padding<closure>","decl_file":15,"decl_line":1299,"inline":"inlined"},{"tag":"subprogram","low_pc":23145,"high_pc":24366,"linkage_name":"_ZN4core3fmt9Formatter3pad17h34ead3f601bff9c6E","name":"pad","decl_file":15,"decl_line":1253,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17h5fb0ad0bfec48f67E","low_pc":23172,"high_pc":23200,"call_file":15,"call_line":1255,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h4e9290638404eb79E","low_pc":23172,"high_pc":23200,"call_file":14,"call_line":216}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter8iterator8Iterator3nth17hd22782ece4537fa3E","ranges":[[23237,23240],[23252,23561]],"call_file":15,"call_line":1264,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17ha3c6b07f08ce7ba6E","ranges":[[23237,23240],[23252,23460],[23497,23527],[23538,23561]],"call_file":36,"call_line":325,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN87_$LT$core..str..CharIndices$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h9250e4d66959239aE","ranges":[[23237,23240],[23252,23460],[23497,23527],[23538,23561]],"call_file":36,"call_line":2623,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h31769beda6688264E","ranges":[[23237,23240],[23252,23460],[23497,23524],[23552,23561]],"call_file":3,"call_line":670,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str15next_code_point17h1e0c4a51b9b46e12E","ranges":[[23237,23240],[23252,23460],[23497,23524],[23552,23561]],"call_file":3,"call_line":571,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[23237,23240],[23252,23261],[23552,23561]],"call_file":3,"call_line":504,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","ranges":[[23237,23240],[23252,23261]],"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","ranges":[[23237,23240],[23252,23261]],"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[23294,23305],[23315,23326]],"call_file":3,"call_line":513,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":23315,"high_pc":23326,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23315,"high_pc":23326,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":23305,"high_pc":23315,"call_file":3,"call_line":513},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[23363,23370],[23380,23391]],"call_file":3,"call_line":518,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":23380,"high_pc":23391,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23380,"high_pc":23391,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":23370,"high_pc":23380,"call_file":3,"call_line":518},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","low_pc":23414,"high_pc":23424,"call_file":3,"call_line":519},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":23434,"high_pc":23448,"call_file":3,"call_line":524,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":23441,"high_pc":23448,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23441,"high_pc":23448,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str11unwrap_or_017h98ed1d35d994133cE","low_pc":23448,"high_pc":23460,"call_file":3,"call_line":524},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str18utf8_acc_cont_byte17h716c31a42575a409E","ranges":[[23497,23502],[23513,23514]],"call_file":3,"call_line":525}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$3get17h04a5964722632793E","low_pc":23625,"high_pc":23661,"call_file":15,"call_line":1269,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str6traits103_$LT$impl$u20$core..slice..SliceIndex$LT$str$GT$$u20$for$u20$core..ops..range..RangeTo$LT$usize$GT$$GT$3get17h41d6422e30080ed7E","low_pc":23625,"high_pc":23661,"call_file":3,"call_line":2309,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str21_$LT$impl$u20$str$GT$16is_char_boundary17h4a6a5cfd08c07264E","low_pc":23625,"high_pc":23656,"call_file":3,"call_line":1915,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$3get17h4c380aa5dfc574ebE","low_pc":23636,"high_pc":23648,"call_file":3,"call_line":2192,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$3get17hb24e7dea09fe15c4E","low_pc":23636,"high_pc":23648,"call_file":9,"call_line":288,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17hdcb174eafba6c8d3E","low_pc":23643,"high_pc":23648,"call_file":9,"call_line":2417,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":23643,"high_pc":23648,"call_file":9,"call_line":2437,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23643,"high_pc":23648,"call_file":0,"call_line":1300}]}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$9unwrap_or17h2fffc23061966382E","low_pc":23662,"high_pc":23680,"call_file":15,"call_line":1269},{"tag":"inlined_subroutine","abstract_origin":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$5count17h6bae085655498417E","low_pc":23706,"high_pc":23757,"call_file":15,"call_line":1283,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str17utf8_is_cont_byte17h6c0ed45c25029789E","low_pc":23718,"high_pc":23723,"call_file":3,"call_line":585},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":23726,"high_pc":23742,"call_file":3,"call_line":584,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":23726,"high_pc":23733,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23726,"high_pc":23733,"call_file":9,"call_line":2788}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN81_$LT$core..str..Chars$LT$$u27$a$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$5count17h6bae085655498417E","low_pc":23770,"high_pc":23829,"call_file":15,"call_line":1290,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3str17utf8_is_cont_byte17h6c0ed45c25029789E","low_pc":23805,"high_pc":23810,"call_file":3,"call_line":585},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","low_pc":23813,"high_pc":23829,"call_file":3,"call_line":584,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":23813,"high_pc":23820,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":23813,"high_pc":23820,"call_file":9,"call_line":2788}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12with_padding17h5054725e72c3ee87E","ranges":[[23843,23871],[23910,24314]],"call_file":15,"call_line":1290,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","low_pc":23960,"high_pc":24157,"call_file":15,"call_line":1316},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","ranges":[[24162,24182],[24220,24222]],"call_file":15,"call_line":1318,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":24162,"high_pc":24180,"call_file":32,"call_line":222}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter3pad28_$u7b$$u7b$closure$u7d$$u7d$17h7ddf179600597140E","low_pc":24222,"high_pc":24256,"call_file":15,"call_line":1322},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17hdeaa07945d94fcdfE","low_pc":24262,"high_pc":24276,"call_file":15,"call_line":1324,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","low_pc":24262,"high_pc":24276,"call_file":32,"call_line":222}]}]}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12with_padding17h27f8c9ddd4c70c65E","name":"with_padding<closure>","decl_file":15,"decl_line":1299,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter11debug_tuple17h1394f96c6ff48ee5E","name":"debug_tuple","decl_file":15,"decl_line":1773,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter15debug_lower_hex17h9a6f90473e805861E","name":"debug_lower_hex","decl_file":15,"decl_line":1700,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter15debug_upper_hex17h5e01f02f059804a5E","name":"debug_upper_hex","decl_file":15,"decl_line":1702,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter10debug_list17hd2db5bb2b73bb925E","name":"debug_list","decl_file":15,"decl_line":1797,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN42_$LT$str$u20$as$u20$core..fmt..Display$GT$3fmt17h8a6a47fb89634a64E","name":"fmt","decl_file":15,"decl_line":1978,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$bool$u20$as$u20$core..fmt..Display$GT$3fmt17h37210e1d4848cf79E","name":"fmt","decl_file":15,"decl_line":1950,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN41_$LT$bool$u20$as$u20$core..fmt..Debug$GT$3fmt17h55b270119393f3a1E","name":"fmt","decl_file":15,"decl_line":1943,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..fmt..Formatter$LT$$u27$_$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h64c5bec7aa7f3d04E","name":"write_char","decl_file":15,"decl_line":1891,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..fmt..Arguments$LT$$u27$_$GT$$u20$as$u20$core..fmt..Display$GT$3fmt17hb16d6a3cd0796552E","name":"fmt","decl_file":15,"decl_line":446,"external":true,"inline":"inlined"},{"tag":"namespace","name":"getcount","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter8getcount28_$u7b$$u7b$closure$u7d$$u7d$17hd034bfa448f6438eE","name":"{{closure}}","decl_file":15,"decl_line":1113,"inline":"inlined"}]},{"tag":"namespace","name":"pad_integral","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12pad_integral28_$u7b$$u7b$closure$u7d$$u7d$17ha08201391a0df7ffE","name":"{{closure}}","decl_file":15,"decl_line":1217,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter12pad_integral28_$u7b$$u7b$closure$u7d$$u7d$17h6ecb2cf9072160dcE","name":"{{closure}}","decl_file":15,"decl_line":1211,"inline":"inlined"},{"tag":"subprogram","low_pc":34334,"high_pc":34710,"linkage_name":"_ZN4core3fmt9Formatter12pad_integral28_$u7b$$u7b$closure$u7d$$u7d$17hb1a6a00d71292916E","name":"{{closure}}","decl_file":15,"decl_line":1185,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","low_pc":34400,"high_pc":34606,"call_file":15,"call_line":1187}]}]},{"tag":"namespace","name":"pad","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter3pad28_$u7b$$u7b$closure$u7d$$u7d$17h7ddf179600597140E","name":"{{closure}}","decl_file":15,"decl_line":1290,"inline":"inlined"}]},{"tag":"namespace","name":"pad_formatted_parts","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter19pad_formatted_parts28_$u7b$$u7b$closure$u7d$$u7d$17h2c903491bab9a84fE","name":"{{closure}}","decl_file":15,"decl_line":1360,"inline":"inlined"}]},{"tag":"namespace","name":"write_formatted_parts","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt9Formatter21write_formatted_parts11write_bytes17h46c92e6f6d6c554bE","name":"write_bytes","decl_file":15,"decl_line":1374,"inline":"inlined"}]},{"tag":"subprogram","low_pc":34711,"high_pc":34725,"abstract_origin":"_ZN42_$LT$str$u20$as$u20$core..fmt..Display$GT$3fmt17h8a6a47fb89634a64E"},{"tag":"subprogram","low_pc":30696,"high_pc":31316,"linkage_name":"_ZN41_$LT$char$u20$as$u20$core..fmt..Debug$GT$3fmt17h3711e9e9ca1f9905E","name":"fmt","decl_file":15,"decl_line":1985,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$core..fmt..Formatter$LT$$u27$_$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h64c5bec7aa7f3d04E","low_pc":30707,"high_pc":30734,"call_file":15,"call_line":1986},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$12escape_debug17ha4e065e1a8f6fe5dE","low_pc":30769,"high_pc":30942,"call_file":15,"call_line":1987,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$16escape_debug_ext17h1a540b8ae47edbc9E","low_pc":30769,"high_pc":30942,"call_file":18,"call_line":248,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$20is_grapheme_extended17h4b971a495728c8c1E","low_pc":30838,"high_pc":30852,"call_file":18,"call_line":202,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core7unicode6tables16derived_property15Grapheme_Extend17hcfe316b6d2c8a3b4E","low_pc":30838,"high_pc":30852,"call_file":18,"call_line":714}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_unicode17h0dce6bdf98b58dc9E","low_pc":30855,"high_pc":30880,"call_file":18,"call_line":203,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","low_pc":30860,"high_pc":30863,"call_file":18,"call_line":179}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_unicode17h0dce6bdf98b58dc9E","low_pc":30909,"high_pc":30932,"call_file":18,"call_line":206,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","low_pc":30914,"high_pc":30917,"call_file":18,"call_line":179}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN74_$LT$core..char..EscapeDebug$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5d00a93454c3166eE","low_pc":30957,"high_pc":31249,"call_file":15,"call_line":1987,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN76_$LT$core..char..EscapeDefault$u20$as$u20$core..iter..iterator..Iterator$GT$4next17haa52e9a33f6aacdeE","low_pc":30957,"high_pc":31249,"call_file":44,"call_line":368,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN76_$LT$core..char..EscapeUnicode$u20$as$u20$core..iter..iterator..Iterator$GT$4next17he52a8658fe2c2354E","low_pc":31003,"high_pc":31249,"call_file":44,"call_line":277,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core4char7convert10from_digit17h7a1e3f413c1b25b7E","low_pc":31099,"high_pc":31114,"call_file":44,"call_line":172}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$core..fmt..Formatter$LT$$u27$_$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h64c5bec7aa7f3d04E","low_pc":31283,"high_pc":31305,"call_file":15,"call_line":1988},{"tag":"inlined_subroutine","abstract_origin":"_ZN71_$LT$core..fmt..Formatter$LT$$u27$_$GT$$u20$as$u20$core..fmt..Write$GT$10write_char17h64c5bec7aa7f3d04E","low_pc":31250,"high_pc":31282,"call_file":15,"call_line":1990}]},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"subprogram","low_pc":35368,"high_pc":35401,"linkage_name":"_ZN53_$LT$core..fmt..Error$u20$as$u20$core..fmt..Debug$GT$3fmt17h92381a1eadd5bfa2E","name":"fmt","decl_file":15,"decl_line":104,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter11debug_tuple17h1394f96c6ff48ee5E","low_pc":35368,"high_pc":35400,"call_file":15,"call_line":104,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders15debug_tuple_new17h1fc44805e9836887E","low_pc":35368,"high_pc":35400,"call_file":15,"call_line":1774,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35368,"high_pc":35400,"call_file":39,"call_line":195}]}]}]},{"tag":"subprogram","low_pc":35402,"high_pc":35417,"linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h0f0edcdb0dd42580E","name":"fmt<usize>","decl_file":15,"decl_line":1914},{"tag":"subprogram","linkage_name":"_ZN54_$LT$$BP$const$u20$T$u20$as$u20$core..fmt..Pointer$GT$3fmt17hfa982328f3e3ac5cE","name":"fmt<u8>","decl_file":15,"decl_line":2007,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$$BP$mut$u20$T$u20$as$u20$core..fmt..Pointer$GT$3fmt17he4f9427335f1edf3E","name":"fmt<u8>","decl_file":15,"decl_line":2035,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h29421f75ce4bf518E","name":"fmt<str>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN48_$LT$$u5b$T$u5d$$u20$as$u20$core..fmt..Debug$GT$3fmt17hd141ad5c9a3f09d7E","name":"fmt<u8>","decl_file":15,"decl_line":2098,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..marker..PhantomData$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hfc2f193584c97af5E","name":"fmt<core::hash::sip::Sip13Rounds>","decl_file":15,"decl_line":2112,"inline":"inlined"},{"tag":"subprogram","low_pc":35419,"high_pc":35824,"linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h54291dc19a86e786E","name":"fmt<core::option::Option<u8>>","decl_file":15,"decl_line":1914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hdd28db829ec57fdeE","low_pc":35448,"high_pc":35809,"call_file":15,"call_line":1914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter11debug_tuple17h1394f96c6ff48ee5E","low_pc":35458,"high_pc":35515,"call_file":14,"call_line":158,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders15debug_tuple_new17h1fc44805e9836887E","low_pc":35458,"high_pc":35515,"call_file":15,"call_line":1774,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35460,"high_pc":35491,"call_file":39,"call_line":195}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10DebugTuple6finish17h8da22b4f85b47dc4E","low_pc":35545,"high_pc":35775,"call_file":14,"call_line":158,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h0eecc028d9ce761dE","low_pc":35576,"high_pc":35750,"call_file":39,"call_line":236,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10DebugTuple6finish28_$u7b$$u7b$closure$u7d$$u7d$17ha63644281f7846a4E","low_pc":35582,"high_pc":35750,"call_file":6,"call_line":647,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders10DebugTuple9is_pretty17hfbdd7ffd81d575f2E","low_pc":35582,"high_pc":35597,"call_file":39,"call_line":237,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","low_pc":35589,"high_pc":35597,"call_file":39,"call_line":250}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35604,"high_pc":35635,"call_file":39,"call_line":238},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35678,"high_pc":35709,"call_file":39,"call_line":241},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35717,"high_pc":35750,"call_file":39,"call_line":243}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter11debug_tuple17h1394f96c6ff48ee5E","low_pc":35776,"high_pc":35809,"call_file":14,"call_line":158,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders15debug_tuple_new17h1fc44805e9836887E","low_pc":35776,"high_pc":35809,"call_file":15,"call_line":1774,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":35776,"high_pc":35809,"call_file":39,"call_line":195}]}]}]}]},{"tag":"subprogram","low_pc":35826,"high_pc":36321,"linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h5afd226be993355dE","name":"fmt<u8>","decl_file":15,"decl_line":1914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17hcf9174035eb5e775E","ranges":[[35854,36278],[36295,36321]],"call_file":15,"call_line":1914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter15debug_lower_hex17h9a6f90473e805861E","low_pc":35854,"high_pc":35882,"call_file":37,"call_line":155},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter15debug_upper_hex17h5e01f02f059804a5E","low_pc":35891,"high_pc":35896,"call_file":37,"call_line":157},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num51_$LT$impl$u20$core..fmt..Display$u20$for$u20$u8$GT$3fmt17haab9ab062fffa647E","ranges":[[35898,35949],[36182,36278]],"call_file":37,"call_line":160,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":35930,"high_pc":35937,"call_file":37,"call_line":238},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","low_pc":36201,"high_pc":36204,"call_file":37,"call_line":244},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":36229,"high_pc":36236,"call_file":37,"call_line":248},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","low_pc":36242,"high_pc":36253,"call_file":37,"call_line":248}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u8$GT$3fmt17he172b3069b45f87eE","ranges":[[35950,36067],[36295,36307]],"call_file":37,"call_line":156,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num12GenericRadix7fmt_int17h3014ba71a116f08cE","ranges":[[35961,36067],[36295,36307]],"call_file":37,"call_line":183,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Rem$GT$3rem17h70a00a9ac461d5a0E","ranges":[[35961,35981],[36004,36011]],"call_file":37,"call_line":73},{"tag":"inlined_subroutine","abstract_origin":"_ZN73_$LT$core..fmt..num..LowerHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h25a291ad7a5a48afE","low_pc":35981,"high_pc":35994,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Div$GT$3div17hea4e91c9626809eeE","low_pc":36011,"high_pc":36012,"call_file":37,"call_line":74},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","ranges":[[36017,36031],[36054,36057],[36295,36307]],"call_file":37,"call_line":95,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","ranges":[[36017,36031],[36054,36057],[36295,36307]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[36017,36031],[36054,36057],[36295,36307]],"call_file":9,"call_line":2580,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":36054,"high_pc":36057,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice14from_raw_parts17h171124c6ce15658aE","low_pc":36054,"high_pc":36057,"call_file":9,"call_line":2486}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u8$GT$3fmt17hfafd7ea54859ee12E","ranges":[[36072,36177],[36308,36321]],"call_file":37,"call_line":158,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num12GenericRadix7fmt_int17h2274362a7e681f01E","ranges":[[36072,36177],[36308,36321]],"call_file":37,"call_line":183,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Rem$GT$3rem17h70a00a9ac461d5a0E","ranges":[[36072,36092],[36114,36121]],"call_file":37,"call_line":73},{"tag":"inlined_subroutine","abstract_origin":"_ZN73_$LT$core..fmt..num..UpperHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h3b6767ae8dd4b702E","low_pc":36092,"high_pc":36104,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Div$GT$3div17hea4e91c9626809eeE","low_pc":36121,"high_pc":36122,"call_file":37,"call_line":74},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","ranges":[[36127,36141],[36164,36167],[36308,36321]],"call_file":37,"call_line":95,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","ranges":[[36127,36141],[36164,36167],[36308,36321]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[36127,36141],[36164,36167],[36308,36321]],"call_file":9,"call_line":2580,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":36164,"high_pc":36167,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice14from_raw_parts17h171124c6ce15658aE","low_pc":36164,"high_pc":36167,"call_file":9,"call_line":2486}]}]}]}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h867a361108b15af9E","name":"fmt<Any>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17he14b173e2574ff1dE","name":"fmt<[char]>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN48_$LT$$u5b$T$u5d$$u20$as$u20$core..fmt..Debug$GT$3fmt17h35918c8fc1e7964fE","name":"fmt<char>","decl_file":15,"decl_line":2098,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$$LP$$RP$$u20$as$u20$core..fmt..Debug$GT$3fmt17h9e2b8e470868e824E","name":"fmt","decl_file":15,"decl_line":2106,"inline":"inlined"},{"tag":"subprogram","low_pc":36322,"high_pc":36340,"linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17hd328f6bebdde107aE","name":"fmt<()>","decl_file":15,"decl_line":1914,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN45_$LT$$LP$$RP$$u20$as$u20$core..fmt..Debug$GT$3fmt17h9e2b8e470868e824E","low_pc":36322,"high_pc":36339,"call_file":15,"call_line":1914}]},{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..fmt..Arguments$LT$$u27$_$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h972ccac33977c6bdE","name":"fmt","decl_file":15,"decl_line":439,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$$RF$T$u20$as$u20$core..fmt..Debug$GT$3fmt17h03a2e751d16eb471E","name":"fmt<core::fmt::Arguments>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Display$GT$3fmt17he51f80523e45199cE","name":"fmt<str>","decl_file":15,"decl_line":1914,"inline":"inlined"},{"tag":"subprogram","low_pc":27729,"high_pc":27749,"abstract_origin":"_ZN44_$LT$$RF$T$u20$as$u20$core..fmt..Display$GT$3fmt17he51f80523e45199cE","children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN42_$LT$str$u20$as$u20$core..fmt..Display$GT$3fmt17h8a6a47fb89634a64E","ranges":[[27729,27732],[27742,27748]],"call_file":15,"call_line":1914}]}]},{"tag":"namespace","name":"float","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float23float_to_decimal_common17h8786ec3f13637245E","name":"float_to_decimal_common<f32>","decl_file":133,"decl_line":50,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$f64$GT$3fmt17h1b1dc0d8e996a14eE","name":"fmt","decl_file":133,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$f32$GT$3fmt17ha2330ef65a02db41E","name":"fmt","decl_file":133,"decl_line":128,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float27float_to_exponential_common17he5f8a59d4e21de65E","name":"float_to_exponential_common<f32>","decl_file":133,"decl_line":107,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float23float_to_decimal_common17hc68d4de6c2171544E","name":"float_to_decimal_common<f64>","decl_file":133,"decl_line":50,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt5float27float_to_exponential_common17hcdb982ec1c8f25cfE","name":"float_to_exponential_common<f64>","decl_file":133,"decl_line":107,"inline":"inlined"}]},{"tag":"subprogram","low_pc":26015,"high_pc":27185,"linkage_name":"_ZN4core3fmt5write17h13f872e726799720E","name":"write","decl_file":15,"decl_line":1022,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17haafe13890276ab59E","low_pc":26089,"high_pc":26097,"call_file":15,"call_line":1031,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h67cdf0524933171fE","low_pc":26089,"high_pc":26097,"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h111594daab58f90bE","low_pc":26089,"high_pc":26097,"call_file":0,"call_line":1300}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$4iter17h2001211d5374b2f8E","ranges":[[26165,26167],[26174,26178]],"call_file":15,"call_line":1034,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h16207395f2d1a580E","ranges":[[26165,26167],[26174,26178]],"call_file":9,"call_line":547,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h585e4bfadd8bb3c1E","ranges":[[26165,26167],[26174,26178]],"call_file":0,"call_line":1300}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17heb85f9030f3304aeE","ranges":[[26284,26298],[26864,26876],[27017,27024]],"call_file":15,"call_line":1047,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17h3e9d44392f549a5fE","ranges":[[26284,26298],[26864,26876],[27017,27024]],"call_file":52,"call_line":1088,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hdff8e6e2a7b9ca0cE","ranges":[[26284,26291],[27017,27024]],"call_file":52,"call_line":1150},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17hc8ab57d612d98a02E","ranges":[[26291,26298],[26864,26876]],"call_file":52,"call_line":1150,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17h9259e4b6bc665f05E","ranges":[[26291,26298],[26864,26876]],"call_file":14,"call_line":632,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5983f0a4d9bde8a9E","ranges":[[26291,26298],[26864,26876]],"call_file":52,"call_line":1151,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5a43416b3e4eac2aE","ranges":[[26291,26298],[26864,26876]],"call_file":36,"call_line":2623,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h34837f87d7b1ac16E","low_pc":26864,"high_pc":26876,"call_file":9,"call_line":2836}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter3run17hdc099adb7ddd73ffE","ranges":[[26340,26808],[26837,26859],[27117,27185]],"call_file":15,"call_line":1049,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8getcount17hc5b67b0fde5a002eE","ranges":[[26374,26527],[27149,27166]],"call_file":15,"call_line":1092,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hcc91a81bb5814180E","low_pc":26410,"high_pc":26435,"call_file":15,"call_line":1113,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hf7013462497e4851E","low_pc":26425,"high_pc":26435,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h111594daab58f90bE","low_pc":26427,"high_pc":26432,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17ha4d858eea8c8d2c5E","low_pc":26435,"high_pc":26461,"call_file":15,"call_line":1113,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8getcount28_$u7b$$u7b$closure$u7d$$u7d$17hd034bfa448f6438eE","low_pc":26435,"high_pc":26461,"call_file":14,"call_line":632,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt10ArgumentV18as_usize17h1c6c99782d5efa10E","low_pc":26435,"high_pc":26461,"call_file":15,"call_line":1113}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt10ArgumentV18as_usize17h1c6c99782d5efa10E","low_pc":26487,"high_pc":26519,"call_file":15,"call_line":1110}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8getcount17hc5b67b0fde5a002eE","ranges":[[26554,26713],[27167,27185]],"call_file":15,"call_line":1093,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hcc91a81bb5814180E","low_pc":26590,"high_pc":26615,"call_file":15,"call_line":1113,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hf7013462497e4851E","low_pc":26605,"high_pc":26615,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h111594daab58f90bE","low_pc":26607,"high_pc":26612,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17ha4d858eea8c8d2c5E","low_pc":26615,"high_pc":26641,"call_file":15,"call_line":1113,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter8getcount28_$u7b$$u7b$closure$u7d$$u7d$17hd034bfa448f6438eE","low_pc":26615,"high_pc":26641,"call_file":14,"call_line":632,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt10ArgumentV18as_usize17h1c6c99782d5efa10E","low_pc":26615,"high_pc":26641,"call_file":15,"call_line":1113}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt10ArgumentV18as_usize17h1c6c99782d5efa10E","low_pc":26670,"high_pc":26702,"call_file":15,"call_line":1110}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hcc91a81bb5814180E","low_pc":26783,"high_pc":26808,"call_file":15,"call_line":1097,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hf7013462497e4851E","low_pc":26798,"high_pc":26808,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h111594daab58f90bE","low_pc":26800,"high_pc":26805,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17hcb3ce8c7bd419517E","low_pc":27135,"high_pc":27148,"call_file":15,"call_line":1097}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN84_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h0eee9070536e9fa1E","low_pc":26997,"high_pc":27009,"call_file":15,"call_line":1039,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next17h172b207a47c65f43E","low_pc":26997,"high_pc":27009,"call_file":52,"call_line":1088,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h3a28411b100be54dE","low_pc":26997,"high_pc":27009,"call_file":52,"call_line":1150,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..iter..Zip$LT$A$C$$u20$B$GT$$u20$as$u20$core..iter..ZipImpl$LT$A$C$$u20$B$GT$$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17hc8a702b52f2aa71eE","low_pc":26997,"high_pc":27009,"call_file":14,"call_line":632,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN64_$LT$$RF$mut$u20$I$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5983f0a4d9bde8a9E","low_pc":26997,"high_pc":27009,"call_file":52,"call_line":1151,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5a43416b3e4eac2aE","low_pc":26997,"high_pc":27009,"call_file":36,"call_line":2623,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h34837f87d7b1ac16E","low_pc":26997,"high_pc":27009,"call_file":9,"call_line":2836}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5a43416b3e4eac2aE","low_pc":27032,"high_pc":27049,"call_file":15,"call_line":1055,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h34837f87d7b1ac16E","low_pc":27039,"high_pc":27049,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h585e4bfadd8bb3c1E","low_pc":27041,"high_pc":27046,"call_file":9,"call_line":2788}]}]}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i8$GT$3fmt17hc2bace987032441cE","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num51_$LT$impl$u20$core..fmt..Display$u20$for$u20$i8$GT$3fmt17h202d39560bc1364eE","name":"fmt","decl_file":37,"decl_line":201,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i8$GT$3fmt17hb1d794f8eff0d306E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..fmt..num..LowerHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h25a291ad7a5a48afE","name":"digit","decl_file":37,"decl_line":121,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i8$GT$3fmt17haef63705257d97f6E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..fmt..num..UpperHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h3b6767ae8dd4b702E","name":"digit","decl_file":37,"decl_line":121,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num49_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u8$GT$3fmt17hcf9174035eb5e775E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num51_$LT$impl$u20$core..fmt..Display$u20$for$u20$u8$GT$3fmt17haab9ab062fffa647E","name":"fmt","decl_file":37,"decl_line":201,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u8$GT$3fmt17he172b3069b45f87eE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u8$GT$3fmt17hfafd7ea54859ee12E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i16$GT$3fmt17h4776876d82a7a714E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i16$GT$3fmt17hd9627497cf5c16cdE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u16$u20$as$u20$core..fmt..num..Int$GT$5to_u817hd7ff1a2f3172c5bdE","name":"to_u8","decl_file":37,"decl_line":39,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i16$GT$3fmt17h2b45b3bb14bc849dE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u16$GT$3fmt17ha88edf538769688fE","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u16$GT$3fmt17h146254b479c20646E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u16$GT$3fmt17h85d39546c11b72afE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i32$GT$3fmt17h277c651f4b005275E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i32$GT$3fmt17hcd6924a851d553ddE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u32$u20$as$u20$core..fmt..num..Int$GT$5to_u817h8af7eb62b1b7b57bE","name":"to_u8","decl_file":37,"decl_line":39,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i32$GT$3fmt17hc3311b7b0d400226E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u32$GT$3fmt17hb0293d31e6820497E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u32$GT$3fmt17h46a4f025990c3d71E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u32$GT$3fmt17hddaedca17ed44cb5E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$i64$GT$3fmt17h6d0db092329e2635E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$i64$GT$3fmt17hcf557160fcde4195E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u64$u20$as$u20$core..fmt..num..Int$GT$5to_u817h119f2c3135f8daefE","name":"to_u8","decl_file":37,"decl_line":39,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$i64$GT$3fmt17h389184a832ceca1eE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num50_$LT$impl$u20$core..fmt..Debug$u20$for$u20$u64$GT$3fmt17ha14c1f7a27b15e99E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$u64$GT$3fmt17h1c5f11c1e0d74cbfE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num53_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$u64$GT$3fmt17h12590fe727ae5ba2E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..Debug$u20$for$u20$isize$GT$3fmt17h032b3527c4f15218E","name":"fmt","decl_file":37,"decl_line":154,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$isize$GT$3fmt17h8f50815600d200f5E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$usize$u20$as$u20$core..fmt..num..Int$GT$5to_u817hd08cd355246df545E","name":"to_u8","decl_file":37,"decl_line":39,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$isize$GT$3fmt17ha988418d1adefafeE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$usize$GT$3fmt17ha4e202a180a1123aE","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$usize$GT$3fmt17h7cba52a94f1f4f68E","name":"fmt","decl_file":37,"decl_line":142,"external":true,"inline":"inlined"},{"tag":"subprogram","low_pc":27364,"high_pc":27698,"linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..Debug$u20$for$u20$usize$GT$3fmt17h9443525d0da36952E","name":"fmt","decl_file":37,"decl_line":154,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter15debug_lower_hex17h9a6f90473e805861E","low_pc":27385,"high_pc":27405,"call_file":37,"call_line":155},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter15debug_upper_hex17h5e01f02f059804a5E","low_pc":27407,"high_pc":27412,"call_file":37,"call_line":157},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..LowerHex$u20$for$u20$usize$GT$3fmt17ha4e202a180a1123aE","ranges":[[27429,27543],[27672,27684]],"call_file":37,"call_line":156,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num12GenericRadix7fmt_int17hfb7cf2a280b99bb5E","ranges":[[27440,27543],[27672,27684]],"call_file":37,"call_line":182,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Div$GT$3div17h6f0485e2f74977daE","ranges":[[27440,27451],[27483,27488]],"call_file":37,"call_line":74},{"tag":"inlined_subroutine","abstract_origin":"_ZN45_$LT$usize$u20$as$u20$core..fmt..num..Int$GT$5to_u817hd08cd355246df545E","low_pc":27451,"high_pc":27460,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN73_$LT$core..fmt..num..LowerHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h25a291ad7a5a48afE","low_pc":27460,"high_pc":27473,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","ranges":[[27493,27507],[27530,27533],[27672,27684]],"call_file":37,"call_line":95,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","ranges":[[27493,27507],[27530,27533],[27672,27684]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[27493,27507],[27530,27533],[27672,27684]],"call_file":9,"call_line":2580,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":27530,"high_pc":27533,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice14from_raw_parts17h171124c6ce15658aE","low_pc":27530,"high_pc":27533,"call_file":9,"call_line":2486}]}]}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num55_$LT$impl$u20$core..fmt..UpperHex$u20$for$u20$usize$GT$3fmt17h7cba52a94f1f4f68E","ranges":[[27544,27655],[27685,27698]],"call_file":37,"call_line":158,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt3num12GenericRadix7fmt_int17h46d92bcf57b253b3E","ranges":[[27555,27655],[27685,27698]],"call_file":37,"call_line":182,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Div$GT$3div17h6f0485e2f74977daE","ranges":[[27555,27566],[27597,27602]],"call_file":37,"call_line":74},{"tag":"inlined_subroutine","abstract_origin":"_ZN45_$LT$usize$u20$as$u20$core..fmt..num..Int$GT$5to_u817hd08cd355246df545E","low_pc":27566,"high_pc":27575,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN73_$LT$core..fmt..num..UpperHex$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17h3b6767ae8dd4b702E","low_pc":27575,"high_pc":27587,"call_file":37,"call_line":75},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h94595ca9c7186a01E","ranges":[[27607,27621],[27644,27647],[27685,27698]],"call_file":37,"call_line":95,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN103_$LT$core..ops..range..RangeFrom$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h7ab1031d419a38faE","ranges":[[27607,27621],[27644,27647],[27685,27698]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[27607,27621],[27644,27647],[27685,27698]],"call_file":9,"call_line":2580,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":27644,"high_pc":27647,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice14from_raw_parts17h171124c6ce15658aE","low_pc":27644,"high_pc":27647,"call_file":9,"call_line":2486}]}]}]}]}]}]}]},{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..fmt..num..Binary$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17hf035e1e60d842eedE","name":"digit","decl_file":37,"decl_line":121,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN70_$LT$core..fmt..num..Octal$u20$as$u20$core..fmt..num..GenericRadix$GT$5digit17hc266eae3d02c1932E","name":"digit","decl_file":37,"decl_line":121,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$u128$u20$as$u20$core..fmt..num..Int$GT$5to_u817ha15e9c1c20f03acdE","name":"to_u8","decl_file":37,"decl_line":39,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN42_$LT$u8$u20$as$u20$core..fmt..num..Int$GT$6to_u3217h4ba5818e77ef1bf8E","name":"to_u32","decl_file":37,"decl_line":41,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u16$u20$as$u20$core..fmt..num..Int$GT$6to_u3217he34f5b9db83a72fdE","name":"to_u32","decl_file":37,"decl_line":41,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u32$u20$as$u20$core..fmt..num..Int$GT$6to_u3217h2226f460d4841db2E","name":"to_u32","decl_file":37,"decl_line":41,"external":true,"inline":"inlined"},{"tag":"subprogram","low_pc":25661,"high_pc":26013,"linkage_name":"_ZN4core3fmt3num52_$LT$impl$u20$core..fmt..Display$u20$for$u20$u32$GT$3fmt17h3c62053c8db1ddd8E","name":"fmt","decl_file":37,"decl_line":201,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN43_$LT$u32$u20$as$u20$core..fmt..num..Int$GT$6to_u3217h2226f460d4841db2E","low_pc":25685,"high_pc":25700,"call_file":37,"call_line":0},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":25756,"high_pc":25757,"call_file":37,"call_line":225},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":25786,"high_pc":25787,"call_file":37,"call_line":226},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","ranges":[[25839,25844],[25849,25876]],"call_file":37,"call_line":238},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":25880,"high_pc":25887,"call_file":37,"call_line":238},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","ranges":[[25912,25917],[25922,25927]],"call_file":37,"call_line":244},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","ranges":[[25938,25943],[25948,25953]],"call_file":37,"call_line":248},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":25958,"high_pc":25965,"call_file":37,"call_line":248}]},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u64$u20$as$u20$core..fmt..num..Int$GT$6to_u6417heede775fd6050f2dE","name":"to_u64","decl_file":37,"decl_line":42,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$u128$u20$as$u20$core..fmt..num..Int$GT$7to_u12817h88d9748be942b134E","name":"to_u128","decl_file":37,"decl_line":43,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"GenericRadix","children":[{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h3014ba71a116f08cE","name":"fmt_int<core::fmt::num::LowerHex,u8>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h2274362a7e681f01E","name":"fmt_int<core::fmt::num::UpperHex,u8>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h5fea0c83c86bfcd7E","name":"fmt_int<core::fmt::num::LowerHex,u16>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17ha8a38ffd0b71bedbE","name":"fmt_int<core::fmt::num::UpperHex,u16>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h941e81eb68bd80f7E","name":"fmt_int<core::fmt::num::LowerHex,u32>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h7015cd235aa9b051E","name":"fmt_int<core::fmt::num::UpperHex,u32>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17ha3e4ddebc37a1010E","name":"fmt_int<core::fmt::num::LowerHex,u64>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h307c60312f21772bE","name":"fmt_int<core::fmt::num::UpperHex,u64>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17hfb7cf2a280b99bb5E","name":"fmt_int<core::fmt::num::LowerHex,usize>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h46d92bcf57b253b3E","name":"fmt_int<core::fmt::num::UpperHex,usize>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17hde5b8cc512d87718E","name":"fmt_int<core::fmt::num::Binary,u8>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h508a66116ed1be57E","name":"fmt_int<core::fmt::num::Octal,u8>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h00643bc0cf9188a1E","name":"fmt_int<core::fmt::num::Binary,u16>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h5bd0bf5126d726ecE","name":"fmt_int<core::fmt::num::Octal,u16>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17hc3ff7ed1ec5a6259E","name":"fmt_int<core::fmt::num::Binary,u32>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17hc38184ef9a798566E","name":"fmt_int<core::fmt::num::Octal,u32>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h7aa0a0fa1fd4490cE","name":"fmt_int<core::fmt::num::Binary,u64>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h507d25ef3164468fE","name":"fmt_int<core::fmt::num::Octal,u64>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h5dec6e8bd3763cc8E","name":"fmt_int<core::fmt::num::Binary,u128>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h77f70eb5ff079c4eE","name":"fmt_int<core::fmt::num::Octal,u128>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17heb08c3f93c5c88fbE","name":"fmt_int<core::fmt::num::LowerHex,u128>","decl_file":37,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3fmt3num12GenericRadix7fmt_int17h29d322ec3b8abf2fE","name":"fmt_int<core::fmt::num::UpperHex,u128>","decl_file":37,"decl_line":61,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"char","children":[{"tag":"namespace","name":"convert","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"CharErrorKind","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"EmptyString","const_value":0},{"tag":"enumerator","name":"TooManyChars","const_value":1}]},{"tag":"structure_type","name":"ParseCharError","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"kind","type":"CharErrorKind","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4char7convert14ParseCharError13__description17h31d27a01ac4cf8b2E","name":"__description","decl_file":45,"decl_line":189,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN71_$LT$core..char..convert..CharErrorKind$u20$as$u20$core..fmt..Debug$GT$3fmt17h2b67e3354ce68508E","name":"fmt","decl_file":45,"decl_line":199,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4char7convert10from_digit17h7a1e3f413c1b25b7E","name":"from_digit","decl_file":45,"decl_line":315,"inline":"inlined"}]},{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"EscapeUnicodeState","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Done","const_value":0},{"tag":"enumerator","name":"RightBrace","const_value":1},{"tag":"enumerator","name":"Value","const_value":2},{"tag":"enumerator","name":"LeftBrace","const_value":3},{"tag":"enumerator","name":"Type","const_value":4},{"tag":"enumerator","name":"Backslash","const_value":5}]},{"tag":"structure_type","name":"EscapeDefaultState","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":278718,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Done","type":"Done","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Char","type":"Char","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"Backslash","type":"Backslash","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Unicode","type":"Unicode","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Done","byte_size":16,"alignment":4},{"tag":"structure_type","name":"Char","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Backslash","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Unicode","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"EscapeUnicode","alignment":4,"data_member_location":4}]}]},{"tag":"structure_type","name":"EscapeUnicode","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"c","type":"char","alignment":4,"data_member_location":0},{"tag":"member","name":"state","type":"EscapeUnicodeState","alignment":1,"data_member_location":8},{"tag":"member","name":"hex_digit_idx","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"EscapeDefault","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"state","type":"EscapeDefaultState","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"CaseMappingIter","byte_size":16,"alignment":4,"children":[{"tag":"variant_part","discr":278919,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"Three","type":"Three","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Two","type":"Two","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"One","type":"One","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":3,"children":[{"tag":"member","name":"Zero","type":"Zero","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Three","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"__1","type":"char","alignment":4,"data_member_location":8},{"tag":"member","name":"__2","type":"char","alignment":4,"data_member_location":12}]},{"tag":"structure_type","name":"Two","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4},{"tag":"member","name":"__1","type":"char","alignment":4,"data_member_location":8}]},{"tag":"structure_type","name":"One","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":4}]},{"tag":"structure_type","name":"Zero","byte_size":16,"alignment":4}]},{"tag":"namespace","name":"methods","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8to_digit17h0383109c63923135E","name":"to_digit","decl_file":18,"decl_line":123,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$16escape_debug_ext17h1a540b8ae47edbc9E","name":"escape_debug_ext","decl_file":18,"decl_line":196,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$12escape_debug17ha4e065e1a8f6fe5dE","name":"escape_debug","decl_file":18,"decl_line":247,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$20is_grapheme_extended17h4b971a495728c8c1E","name":"is_grapheme_extended","decl_file":18,"decl_line":713,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$8len_utf817h758134eab1d945d1E","name":"len_utf8","decl_file":18,"decl_line":361,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$13is_whitespace17hfaaf694cac7d1f26E","name":"is_whitespace","decl_file":18,"decl_line":655,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$11encode_utf817h2658ffec62ebb951E","name":"encode_utf8","decl_file":18,"decl_line":438,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4char7methods22_$LT$impl$u20$char$GT$14escape_unicode17h0dce6bdf98b58dc9E","name":"escape_unicode","decl_file":18,"decl_line":173,"inline":"inlined"}]}]},{"tag":"namespace","name":"decode","children":[{"tag":"structure_type","name":"DecodeUtf16Error","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"code","type":"u16","alignment":2,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN69_$LT$core..char..EscapeUnicodeState$u20$as$u20$core..clone..Clone$GT$5clone17h7b3cb96c7294c1bcE","name":"clone","decl_file":44,"decl_line":142,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$core..char..EscapeUnicode$u20$as$u20$core..clone..Clone$GT$5clone17h1c931766ffaf134cE","name":"clone","decl_file":44,"decl_line":127,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$core..char..EscapeUnicode$u20$as$u20$core..iter..iterator..Iterator$GT$4next17he52a8658fe2c2354E","name":"next","decl_file":44,"decl_line":156,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$core..char..EscapeUnicode$u20$as$u20$core..iter..iterator..Iterator$GT$4last17h4095cc32473badfdE","name":"last","decl_file":44,"decl_line":199,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN83_$LT$core..char..EscapeUnicode$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17h2e3044357b1e01e8E","name":"len","decl_file":44,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$core..char..EscapeDefaultState$u20$as$u20$core..clone..Clone$GT$5clone17hac2a7d5f161d9427E","name":"clone","decl_file":44,"decl_line":254,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$core..char..EscapeDefault$u20$as$u20$core..clone..Clone$GT$5clone17h6bc7af085e68a700E","name":"clone","decl_file":44,"decl_line":248,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$core..char..EscapeDefault$u20$as$u20$core..iter..iterator..Iterator$GT$4next17haa52e9a33f6aacdeE","name":"next","decl_file":44,"decl_line":266,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN83_$LT$core..char..EscapeDefault$u20$as$u20$core..iter..traits..ExactSizeIterator$GT$3len17h49262f57fa6b7e76E","name":"len","decl_file":44,"decl_line":331,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN76_$LT$core..char..EscapeDefault$u20$as$u20$core..iter..iterator..Iterator$GT$9size_hint17hc67fde4589e7664cE","name":"size_hint","decl_file":44,"decl_line":282,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..char..CaseMappingIter$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h70d3aae4e5fba724E","name":"next","decl_file":44,"decl_line":453,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN74_$LT$core..char..EscapeDebug$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5d00a93454c3166eE","name":"next","decl_file":44,"decl_line":368,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN62_$LT$core..char..EscapeDefault$u20$as$u20$core..fmt..Debug$GT$3fmt17h1d45ca9c7601316fE","name":"fmt","decl_file":44,"decl_line":248,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"any","children":[{"tag":"structure_type","name":"&Any","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"*mut u8","alignment":4,"data_member_location":0,"artificial":true},{"tag":"member","name":"vtable","type":"&[usize; 3]","alignment":4,"data_member_location":4,"artificial":true}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":27699,"high_pc":27712,"linkage_name":"_ZN36_$LT$T$u20$as$u20$core..any..Any$GT$11get_type_id17h03f39cb19cff7cc9E","name":"get_type_id<core::panic::{{impl}}::internal_constructor::NoPayload>","decl_file":17,"decl_line":115},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$2is17h32c8fbc4f86af2d7E","name":"is<&str>","decl_file":17,"decl_line":169,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17h477341a43417e9b7E","name":"downcast_ref<&str>","decl_file":17,"decl_line":203,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN98_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$static$RP$$GT$12downcast_ref17hbe3504e726d5805dE","name":"downcast_ref<&str>","decl_file":17,"decl_line":300,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN58_$LT$core..any..TypeId$u20$as$u20$core..cmp..PartialEq$GT$2eq17hbb134b0edcbec728E","name":"eq","decl_file":17,"decl_line":435,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN126_$LT$$LP$dyn$u20$core..any..Any$u20$$u2b$$u20$core..marker..Send$u20$$u2b$$u20$$u27$static$RP$$u20$as$u20$core..fmt..Debug$GT$3fmt17hc4535c660552a0faE","name":"fmt","decl_file":17,"decl_line":134,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<&core::fmt::Arguments>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":283076,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::fmt::Arguments","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<&[core::fmt::rt::v1::Argument]>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":283150,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&[core::fmt::rt::v1::Argument]","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"Option<usize>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":283224,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h85dce22e3b880241E","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h6e07774b3fce2e37E","name":"map<usize,u8,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h008951fc47dd7648E","name":"map<usize,u8,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h0983efb60d7c6e8cE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h27ee98e15c1cd27aE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hfc6bd4ec24aa44a5E","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h840fbc2eaa9a44ffE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h2e25b4352292de4cE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_some17h4e9290638404eb79E","name":"is_some<usize>","decl_file":14,"decl_line":193,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$7is_none17h5fb0ad0bfec48f67E","name":"is_none<usize>","decl_file":14,"decl_line":215,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h654e0495115a7f1aE","name":"map<usize,usize,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$9unwrap_or17h2657e6054764faf2E","name":"unwrap_or<usize>","decl_file":14,"decl_line":375,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<u8>","byte_size":2,"alignment":1,"children":[{"tag":"variant_part","discr":283453,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":2,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":1}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h8823332b7b0e2ec1E","name":"unwrap<u8>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&u32>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":283541,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&u32","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h35207efe640d49e0E","name":"map<&u32,(usize, &u32),closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hbf1d8707479d0e10E","name":"map<&u32,u32,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned17h63ab3f2ed3528bb8E","name":"cloned<u32>","decl_file":14,"decl_line":901,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"cloned","children":[{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned28_$u7b$$u7b$closure$u7d$$u7d$17h5c9f44eb405934e9E","name":"{{closure}}<u32>","decl_file":14,"decl_line":902,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned28_$u7b$$u7b$closure$u7d$$u7d$17hc207865d40c0f7feE","name":"{{closure}}<u8>","decl_file":14,"decl_line":902,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN70_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..cmp..PartialEq$GT$2eq17h300dc7e18e1e67cdE","name":"eq<&u8>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hdd28db829ec57fdeE","name":"fmt<u8>","decl_file":14,"decl_line":158,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN66_$LT$core..option..Option$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hfc1b9ab9f4e87dd0E","name":"fmt<&core::fmt::Arguments>","decl_file":14,"decl_line":158,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&str>","byte_size":8,"alignment":4,"children":[{"tag":"variant_part","discr":283798,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":8,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&str","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17ha537687100ea9096E","name":"unwrap_or_else<&str,closure>","decl_file":14,"decl_line":393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17h0515ff3574f84ed6E","name":"unwrap_or_else<&str,closure>","decl_file":14,"decl_line":393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$14unwrap_or_else17hba6de77ea02620cbE","name":"unwrap_or_else<&str,closure>","decl_file":14,"decl_line":393,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$9unwrap_or17h2fffc23061966382E","name":"unwrap_or<&str>","decl_file":14,"decl_line":375,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<char>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":283957,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":1114112,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"char","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h876ce2ec7ad75965E","name":"unwrap<char>","decl_file":14,"decl_line":352,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17hb48d206fde6a4c74E","name":"map<char,(usize, char),closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&core::fmt::rt::v1::Argument>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":284060,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::fmt::rt::v1::Argument","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17hc8ab57d612d98a02E","name":"and_then<&core::fmt::rt::v1::Argument,(&core::fmt::rt::v1::Argument, &&str),closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&core::fmt::ArgumentV1>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":284147,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&core::fmt::ArgumentV1","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17ha4d858eea8c8d2c5E","name":"and_then<&core::fmt::ArgumentV1,usize,closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h3a28411b100be54dE","name":"and_then<&core::fmt::ArgumentV1,(&core::fmt::ArgumentV1, &&str),closure>","decl_file":14,"decl_line":630,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17hcb3ce8c7bd419517E","name":"unwrap<&core::fmt::ArgumentV1>","decl_file":14,"decl_line":352,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<core::time::Duration>","byte_size":24,"alignment":8,"children":[{"tag":"variant_part","discr":284260,"children":[{"tag":"member","type":"u64","alignment":8,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":24,"alignment":8},{"tag":"structure_type","name":"Some","byte_size":24,"alignment":8,"children":[{"tag":"member","name":"__0","type":"Duration","alignment":8,"data_member_location":8}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6expect17h876380042c779111E","name":"expect<core::time::Duration>","decl_file":14,"decl_line":319,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<u64>","byte_size":16,"alignment":8,"children":[{"tag":"variant_part","discr":284348,"children":[{"tag":"member","type":"u64","alignment":8,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":8,"data_member_location":0}]},{"tag":"variant","discr_value":1,"children":[{"tag":"member","name":"Some","type":"Some","alignment":8,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":16,"alignment":8},{"tag":"structure_type","name":"Some","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"u64","alignment":8,"data_member_location":8}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$8and_then17h2d71f4db100c8164E","name":"and_then<u64,u64,closure>","decl_file":14,"decl_line":630,"inline":"inlined"}]},{"tag":"structure_type","name":"Option<&u8>","byte_size":4,"alignment":4,"children":[{"tag":"variant_part","discr":284436,"children":[{"tag":"member","type":"u32","alignment":4,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":0,"children":[{"tag":"member","name":"None","type":"None","alignment":4,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":4,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":4,"alignment":4},{"tag":"structure_type","name":"Some","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"&u8","alignment":4,"data_member_location":0}]},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h9225ef15346dfc44E","name":"map<&u8,u8,closure>","decl_file":14,"decl_line":422,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned17h76a14fc2c2da4705E","name":"cloned<u8>","decl_file":14,"decl_line":901,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h3fe26cf8aa616edfE","name":"map<&u8,(usize, &u8),closure>","decl_file":14,"decl_line":422,"inline":"inlined"}]}]},{"tag":"namespace","name":"result","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Result","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Ok","const_value":0},{"tag":"enumerator","name":"Err","const_value":1},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h112ff9015b0c4b81E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17ha70b8465543f7b55E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h29f1ed7a5fefc2beE","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h0eecc028d9ce761dE","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h198d87a26d6c5ed2E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17hbc733a1b61275e7fE","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17hb167d6112104bd36E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17had2f4e4448f500cbE","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17ha55c6007541ac990E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h7016ef0bb836d154E","name":"and_then<(),core::fmt::Error,(),closure>","decl_file":6,"decl_line":645,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$11into_result17h3a8e6d30b8d09609E","name":"into_result<(),core::str::Utf8Error>","decl_file":6,"decl_line":1264,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17h13c539d063a0a363E","name":"from_error<&str,core::str::Utf8Error>","decl_file":6,"decl_line":1274,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN78_$LT$core..result..Result$LT$T$C$$u20$E$GT$$u20$as$u20$core..ops..try..Try$GT$10from_error17h70483e64e4735ee1E","name":"from_error<&mut str,core::str::Utf8Error>","decl_file":6,"decl_line":1274,"inline":"inlined"}]}]},{"tag":"namespace","name":"hash","children":[{"tag":"namespace","name":"sip","children":[{"tag":"structure_type","name":"Hasher<core::hash::sip::Sip13Rounds>","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"k0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"k1","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":56},{"tag":"member","name":"state","type":"State","alignment":8,"data_member_location":16},{"tag":"member","name":"tail","type":"u64","alignment":8,"data_member_location":48},{"tag":"member","name":"ntail","type":"usize","alignment":4,"data_member_location":60},{"tag":"member","name":"_marker","type":"PhantomData<core::hash::sip::Sip13Rounds>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"State","byte_size":32,"alignment":8,"children":[{"tag":"member","name":"v0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"v2","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"v1","type":"u64","alignment":8,"data_member_location":16},{"tag":"member","name":"v3","type":"u64","alignment":8,"data_member_location":24}]},{"tag":"structure_type","name":"Hasher<core::hash::sip::Sip24Rounds>","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"k0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"k1","type":"u64","alignment":8,"data_member_location":8},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":56},{"tag":"member","name":"state","type":"State","alignment":8,"data_member_location":16},{"tag":"member","name":"tail","type":"u64","alignment":8,"data_member_location":48},{"tag":"member","name":"ntail","type":"usize","alignment":4,"data_member_location":60},{"tag":"member","name":"_marker","type":"PhantomData<core::hash::sip::Sip24Rounds>","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"SipHasher24","byte_size":64,"alignment":8,"children":[{"tag":"member","name":"hasher","type":"Hasher<core::hash::sip::Sip24Rounds>","alignment":8,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN69_$LT$core..hash..sip..Hasher$LT$S$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hadfba14afc131a8dE","name":"fmt<core::hash::sip::Sip13Rounds>","decl_file":51,"decl_line":64,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN69_$LT$core..hash..sip..Hasher$LT$S$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h2f83a9893f8a2fc5E","name":"fmt<core::hash::sip::Sip24Rounds>","decl_file":51,"decl_line":64,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN65_$LT$core..hash..sip..SipHasher24$u20$as$u20$core..fmt..Debug$GT$3fmt17h8a0a707befe5f2d6E","name":"fmt","decl_file":51,"decl_line":41,"external":true,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"structure_type","name":"NonNull<u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"pointer","type":"NonZero<*const u8>","alignment":4,"data_member_location":0}]},{"tag":"subprogram","low_pc":22452,"high_pc":22454,"linkage_name":"_ZN4core3ptr13drop_in_place17h09cdf3709e54be5bE","name":"drop_in_place<&i8>","decl_file":0,"decl_line":194},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h38e8798c363db742E","name":"offset<u32>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hc62bb20759bcdc7dE","name":"offset<u32>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h2c528c01ea5a726fE","name":"add<u32>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h2240d10affd69cd2E","name":"add<u32>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h13ac72b6bf783577E","name":"offset<u8>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h3b3c1839dc27e606E","name":"add<u8>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h41d6935faf735fddE","name":"offset<core::num::flt2dec::Part>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","name":"offset<u8>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","name":"add<u8>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$12align_offset17h493a3853f063996bE","name":"align_offset<u8>","decl_file":0,"decl_line":1561,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h111594daab58f90bE","name":"offset<core::fmt::ArgumentV1>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h67cdf0524933171fE","name":"add<core::fmt::ArgumentV1>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h585e4bfadd8bb3c1E","name":"offset<&str>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h16207395f2d1a580E","name":"add<&str>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hf8c9160a713a0f66E","name":"offset<(u8, u8)>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN64_$LT$core..ptr..NonNull$LT$T$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17hb72be4fc5eb662e3E","name":"fmt<u8>","decl_file":0,"decl_line":2962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h23a6a7d2132bd550E","name":"offset<char>","decl_file":0,"decl_line":1079,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr5write17ha410bd52a6cbe3d7E","name":"write<usize>","decl_file":0,"decl_line":738,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr23swap_nonoverlapping_one17hacffaa3bda82f5fcE","name":"swap_nonoverlapping_one<usize>","decl_file":0,"decl_line":359,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr12align_offset17hdcf595db677a1368E","name":"align_offset<u8>","decl_file":0,"decl_line":2358,"inline":"inlined"}]},{"tag":"namespace","name":"nonzero","children":[{"tag":"structure_type","name":"NonZero<*const u8>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"*const u8","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"NonZero<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"__0","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"f32","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$7to_bits17h7ae4a2df075644e0E","name":"to_bits","decl_file":134,"decl_line":429,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$9from_bits17h3b81a8c027d590a3E","name":"from_bits","decl_file":134,"decl_line":473,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$8classify17ha5521dc229b57ee4E","name":"classify","decl_file":134,"decl_line":261,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"f64","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$7to_bits17h3d57cda1e51903b4E","name":"to_bits","decl_file":135,"decl_line":442,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$9from_bits17h007fc438aa341a5dE","name":"from_bits","decl_file":135,"decl_line":486,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$8classify17h40f24d6727a9c3fbE","name":"classify","decl_file":135,"decl_line":261,"external":true,"inline":"inlined"}]}]},{"tag":"namespace","name":"cmp","children":[{"tag":"namespace","name":"Ord","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3max17h738ba70bab27063eE","name":"max<usize>","decl_file":16,"decl_line":556,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3Ord3min17h015c694494aafd33E","name":"min<usize>","decl_file":16,"decl_line":573,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3max17h5ad386572cc748faE","name":"max<usize>","decl_file":16,"decl_line":857,"inline":"inlined"},{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2ge17h7394230abbd4a4cbE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls48_$LT$impl$u20$core..cmp..Ord$u20$for$u20$u32$GT$3cmp17h155cd93ccb529052E","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","name":"le","decl_file":16,"decl_line":952,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls53_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u8$GT$2eq17h9de8c2f35425f5f0E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h75dfbd5cf7dde43dE","name":"eq<u8,u8>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls91_$LT$impl$u20$core..cmp..PartialEq$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2eq17h73592a224be23078E","name":"eq<[u8],[u8]>","decl_file":16,"decl_line":1016,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls49_$LT$impl$u20$core..cmp..Ord$u20$for$u20$char$GT$3cmp17haacb0c31f49e18f7E","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls92_$LT$impl$u20$core..cmp..PartialOrd$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2ge17h71c95dc8e73f03d7E","name":"ge<core::num::bignum::Big32x40,core::num::bignum::Big32x40>","decl_file":16,"decl_line":1031,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls92_$LT$impl$u20$core..cmp..PartialOrd$LT$$RF$$u27$b$u20$B$GT$$u20$for$u20$$RF$$u27$a$u20$A$GT$2ge17he790b71324358366E","name":"ge<core::num::bignum::tests::Big8x3,core::num::bignum::tests::Big8x3>","decl_file":16,"decl_line":1031,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls47_$LT$impl$u20$core..cmp..Ord$u20$for$u20$u8$GT$3cmp17h8d45fd778af3de6aE","name":"cmp","decl_file":16,"decl_line":962,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u64$GT$2eq17h9747c05ea55ee715E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u128$GT$2eq17h68c3bd1b47485508E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"}]}]},{"tag":"namespace","name":"PartialOrd","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp10PartialOrd2lt17h0cb53755e5ce5fa0E","name":"lt<core::cmp::Ordering,core::cmp::Ordering>","decl_file":16,"decl_line":748,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp10PartialOrd2ge17hc74337433e68ec69E","name":"ge<core::num::bignum::Big32x40,core::num::bignum::Big32x40>","decl_file":16,"decl_line":813,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp10PartialOrd2ge17hc3819c4869ebe6ceE","name":"ge<core::num::bignum::tests::Big8x3,core::num::bignum::tests::Big8x3>","decl_file":16,"decl_line":813,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3cmp3min17h4d30ffc98bf66413E","name":"min<usize>","decl_file":16,"decl_line":837,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN60_$LT$core..cmp..Ordering$u20$as$u20$core..cmp..PartialEq$GT$2eq17h2e17a7fdb33668eeE","name":"eq","decl_file":16,"decl_line":295,"inline":"inlined"}]}]},{"tag":"namespace","name":"clone","children":[{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls52_$LT$impl$u20$core..clone..Clone$u20$for$u20$u32$GT$5clone17h0be8eadf1b628ea9E","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls54_$LT$impl$u20$core..clone..Clone$u20$for$u20$usize$GT$5clone17h966f2a4cbcd7b10eE","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls53_$LT$impl$u20$core..clone..Clone$u20$for$u20$char$GT$5clone17h0caefa2bb5a61f6cE","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls54_$LT$impl$u20$core..clone..Clone$u20$for$u20$$RF$T$GT$5clone17hd4ac945920097abeE","name":"clone<[core::num::flt2dec::Part]>","decl_file":47,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls54_$LT$impl$u20$core..clone..Clone$u20$for$u20$$RF$T$GT$5clone17h20531ffd33fccf9aE","name":"clone<[u8]>","decl_file":47,"decl_line":209,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5clone5impls51_$LT$impl$u20$core..clone..Clone$u20$for$u20$u8$GT$5clone17hc46abe1d42e8967eE","name":"clone","decl_file":47,"decl_line":166,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"arith","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Sub$GT$3sub17h8984f53754ccbf53E","name":"sub","decl_file":34,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Rem$GT$3rem17h70a00a9ac461d5a0E","name":"rem","decl_file":34,"decl_line":538,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN44_$LT$u8$u20$as$u20$core..ops..arith..Div$GT$3div17hea4e91c9626809eeE","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$u16$u20$as$u20$core..ops..arith..Div$GT$3div17hc3b73d39fe1eff23E","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$u32$u20$as$u20$core..ops..arith..Div$GT$3div17hefa8391c168e00ddE","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$u64$u20$as$u20$core..ops..arith..Div$GT$3div17ha9ab7120841ae4f9E","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Div$GT$3div17h6f0485e2f74977daE","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$u128$u20$as$u20$core..ops..arith..Div$GT$3div17hb551d38c5d8e3569E","name":"div","decl_file":34,"decl_line":453,"inline":"inlined"}]}]},{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":27187,"high_pc":27362,"linkage_name":"_ZN71_$LT$core..ops..range..Range$LT$Idx$GT$$u20$as$u20$core..fmt..Debug$GT$3fmt17h492d8d8dc81b139aE","name":"fmt<usize>","decl_file":38,"decl_line":93,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_fmt17hdaac2092689000b5E","low_pc":27252,"high_pc":27348,"call_file":38,"call_line":94}]}]}]},{"tag":"namespace","name":"function","children":[{"tag":"namespace","name":"FnMut","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5FnMut8call_mut17hd2ca8a115cc9675cE","name":"call_mut<fn(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16) -> (usize, i16),(&core::num::flt2dec::decoder::Decoded, &mut [u8], i16)>","decl_file":50,"decl_line":156,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ops8function5FnMut8call_mut17h9afbda9d57ffbc52E","name":"call_mut<fn(&core::num::flt2dec::decoder::Decoded, &mut [u8]) -> (usize, i16),(&core::num::flt2dec::decoder::Decoded, &mut [u8])>","decl_file":50,"decl_line":156,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"ascii","children":[{"tag":"namespace","name":"escape_default","children":[{"tag":"subprogram","linkage_name":"_ZN4core5ascii14escape_default6hexify17hde3bb6601a8c5bb8E","name":"hexify","decl_file":136,"decl_line":117,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"namespace","name":"next","children":[{"tag":"subprogram","linkage_name":"_ZN77_$LT$core..ascii..EscapeDefault$u20$as$u20$core..iter..iterator..Iterator$GT$4next28_$u7b$$u7b$closure$u7d$$u7d$17hae036dd27f139055E","name":"{{closure}}","decl_file":136,"decl_line":128,"inline":"inlined"}]},{"tag":"namespace","name":"next_back","children":[{"tag":"subprogram","linkage_name":"_ZN86_$LT$core..ascii..EscapeDefault$u20$as$u20$core..iter..traits..DoubleEndedIterator$GT$9next_back28_$u7b$$u7b$closure$u7d$$u7d$17h18a99bf5687c9225E","name":"{{closure}}","decl_file":136,"decl_line":134,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"mem","children":[{"tag":"subprogram","linkage_name":"_ZN4core3mem4swap17hd352a91bdf4a6d60E","name":"swap<usize>","decl_file":10,"decl_line":610,"inline":"inlined"}]},{"tag":"namespace","name":"sync","children":[{"tag":"namespace","name":"atomic","children":[{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h5f3b3b1988af7c9dE","name":"atomic_load<u8>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicBool","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic10AtomicBool4load17h5119bc22c7a6647fE","name":"load","decl_file":20,"decl_line":358,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17hc97494a5a8632bc9E","name":"atomic_load<i8>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicI8","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"v","type":"UnsafeCell<i8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic8AtomicI84load17h46225f6e6b80f344E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicU8","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u8>","alignment":1,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic8AtomicU84load17h9849ef24690116afE","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h318fea4eb9a0a553E","name":"atomic_load<i16>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicI16","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"v","type":"UnsafeCell<i16>","alignment":2,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicI164load17h4d219ea0986d1b82E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h2ec8ecc5e313cc79E","name":"atomic_load<u16>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicU16","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u16>","alignment":2,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicU164load17hc8b6d180e76756e5E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h862175adbc94a8beE","name":"atomic_load<i32>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicI32","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<i32>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicI324load17he106ad7ac124f450E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h0cf3ad80d4dc8813E","name":"atomic_load<u32>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicU32","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u32>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicU324load17hde986e3946253d9fE","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"structure_type","name":"AtomicI64","byte_size":8,"alignment":8,"children":[{"tag":"member","name":"v","type":"UnsafeCell<i64>","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicI643new17h7e16be22489c20acE","name":"new","decl_file":20,"decl_line":1155,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicI644load17hbdd0ea006ba020dcE","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h962892769229b9abE","name":"atomic_load<i64>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17ha8b3b36e909116f3E","name":"atomic_load<u64>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicU64","byte_size":8,"alignment":8,"children":[{"tag":"member","name":"v","type":"UnsafeCell<u64>","alignment":8,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic9AtomicU644load17h1807087a5fff8433E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17h6d39afc54eae1f1bE","name":"atomic_load<isize>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicIsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<isize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicIsize4load17h44d356fd1215243bE","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11atomic_load17hb85c9f3f94ade880E","name":"atomic_load<usize>","decl_file":20,"decl_line":2034,"inline":"inlined"},{"tag":"structure_type","name":"AtomicUsize","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"v","type":"UnsafeCell<usize>","alignment":4,"data_member_location":0},{"tag":"subprogram","linkage_name":"_ZN4core4sync6atomic11AtomicUsize4load17h0741b33a28325388E","name":"load","decl_file":20,"decl_line":1232,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"cell","children":[{"tag":"structure_type","name":"UnsafeCell<u8>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"u8","alignment":1,"data_member_location":0}]},{"tag":"namespace","name":"{{impl}}","children":[]},{"tag":"structure_type","name":"UnsafeCell<i8>","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"value","type":"i8","alignment":1,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<i16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"value","type":"i16","alignment":2,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<u16>","byte_size":2,"alignment":2,"children":[{"tag":"member","name":"value","type":"u16","alignment":2,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<i32>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"i32","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<u32>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"u32","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<i64>","byte_size":8,"alignment":8,"children":[{"tag":"member","name":"value","type":"i64","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<u64>","byte_size":8,"alignment":8,"children":[{"tag":"member","name":"value","type":"u64","alignment":8,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<isize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"isize","alignment":4,"data_member_location":0}]},{"tag":"structure_type","name":"UnsafeCell<usize>","byte_size":4,"alignment":4,"children":[{"tag":"member","name":"value","type":"usize","alignment":4,"data_member_location":0}]}]},{"tag":"namespace","name":"panicking","children":[{"tag":"subprogram","low_pc":22775,"high_pc":22892,"linkage_name":"_ZN4core9panicking5panic17h3ed16afb850d7110E","name":"panic","decl_file":35,"decl_line":44,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments6new_v117h030d4cea03f336acE","ranges":[[22818,22828],[22835,22863]],"call_file":35,"call_line":52}]},{"tag":"subprogram","low_pc":22456,"high_pc":22612,"linkage_name":"_ZN4core9panicking18panic_bounds_check17hfef3b48b6324f35dE","name":"panic_bounds_check","decl_file":35,"decl_line":57,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Arguments16new_v1_formatted17h77e504c9f4e9c79bE","ranges":[[22507,22530],[22541,22570],[22587,22597]],"call_file":35,"call_line":59}]},{"tag":"subprogram","low_pc":23055,"high_pc":23143,"linkage_name":"_ZN4core9panicking9panic_fmt17hadbeabec8c8d832eE","name":"panic_fmt","decl_file":35,"decl_line":64,"external":true,"noreturn":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5panic9PanicInfo20internal_constructor17h7f7883a6234f3b51E","ranges":[[23084,23089],[23094,23133]],"call_file":35,"call_line":73}]}]},{"tag":"namespace","name":"ffi","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]},{"tag":"namespace","name":"unicode","children":[{"tag":"namespace","name":"tables","children":[{"tag":"namespace","name":"derived_property","children":[{"tag":"subprogram","linkage_name":"_ZN4core7unicode6tables16derived_property15Grapheme_Extend17hcfe316b6d2c8a3b4E","name":"Grapheme_Extend","decl_file":43,"decl_line":690,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"property","children":[{"tag":"subprogram","linkage_name":"_ZN4core7unicode6tables8property11White_Space17heb781e517579062fE","name":"White_Space","decl_file":43,"decl_line":1286,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"general_category","children":[]},{"tag":"namespace","name":"conversions","children":[{"tag":"subprogram","linkage_name":"_ZN4core7unicode6tables11conversions18bsearch_case_table17he4aa72b4e1acff9fE","name":"bsearch_case_table","decl_file":43,"decl_line":1307,"inline":"inlined"},{"tag":"namespace","name":"bsearch_case_table","children":[{"tag":"subprogram","linkage_name":"_ZN4core7unicode6tables11conversions18bsearch_case_table28_$u7b$$u7b$closure$u7d$$u7d$17hd0e9cc470831b97dE","name":"{{closure}}","decl_file":43,"decl_line":1308,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"bool_trie","children":[{"tag":"structure_type","name":"SmallBoolTrie","byte_size":16,"alignment":4,"children":[{"tag":"member","name":"r1","type":"&[u8]","alignment":4,"data_member_location":0},{"tag":"member","name":"r2","type":"&[u64]","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core7unicode9bool_trie13SmallBoolTrie6lookup17h3161a787ed240546E","name":"lookup","decl_file":41,"decl_line":65,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core7unicode9bool_trie15trie_range_leaf17h909ff37a6be9ad7eE","name":"trie_range_leaf","decl_file":41,"decl_line":74,"inline":"inlined"},{"tag":"structure_type","name":"BoolTrie","byte_size":1528,"alignment":8,"children":[{"tag":"member","name":"r1","type":"u64[]","alignment":8,"data_member_location":0},{"tag":"member","name":"r2","type":"u8[]","alignment":1,"data_member_location":280},{"tag":"member","name":"r3","type":"&[u64]","alignment":4,"data_member_location":256},{"tag":"member","name":"r4","type":"u8[]","alignment":1,"data_member_location":1272},{"tag":"member","name":"r5","type":"&[u8]","alignment":4,"data_member_location":264},{"tag":"member","name":"r6","type":"&[u64]","alignment":4,"data_member_location":272},{"tag":"subprogram","low_pc":29152,"high_pc":29480,"linkage_name":"_ZN4core7unicode9bool_trie8BoolTrie6lookup17hc53a9f8bcad142b0E","name":"lookup","decl_file":41,"decl_line":44}]}]},{"tag":"namespace","name":"printable","children":[{"tag":"subprogram","low_pc":34727,"high_pc":35104,"linkage_name":"_ZN4core7unicode9printable5check17hb802385b4698b8d9E","name":"check","decl_file":42,"decl_line":14,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h5fa51d854db1eab1E","ranges":[[34734,34794],[34915,34924]],"call_file":42,"call_line":18,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17hfd21fe1f698bf910E","low_pc":34785,"high_pc":34794,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17hf8c9160a713a0f66E","low_pc":34785,"high_pc":34794,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5slice74_$LT$impl$u20$core..ops..index..Index$LT$I$GT$$u20$for$u20$$u5b$T$u5d$$GT$5index17h54521170cd45ad22E","ranges":[[34822,34843],[35080,35104]],"call_file":42,"call_line":21,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$5index17h0f21b6e7662beaaeE","ranges":[[34822,34843],[35080,35104]],"call_file":9,"call_line":2316,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN99_$LT$core..ops..range..Range$LT$usize$GT$$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17he6a3b8b8d91ba031E","low_pc":34836,"high_pc":34843,"call_file":9,"call_line":2502,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h36a08af7f45212d3E","low_pc":34836,"high_pc":34843,"call_file":9,"call_line":2486,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":34836,"high_pc":34843,"call_file":0,"call_line":1300}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[34843,34850],[34864,34869]],"call_file":42,"call_line":21,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":34864,"high_pc":34869,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":34864,"high_pc":34869,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN78_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1c5d159a4850bfd1E","ranges":[[34924,34929],[34949,34979],[35043,35052]],"call_file":42,"call_line":35,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[34924,34929],[34949,34958],[35043,35052]],"call_file":52,"call_line":524,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":34949,"high_pc":34958,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":34949,"high_pc":34958,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned17h76a14fc2c2da4705E","low_pc":34958,"high_pc":34979,"call_file":52,"call_line":524,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h9225ef15346dfc44E","low_pc":34958,"high_pc":34979,"call_file":14,"call_line":902,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned28_$u7b$$u7b$closure$u7d$$u7d$17hc207865d40c0f7feE","low_pc":34958,"high_pc":34979,"call_file":14,"call_line":424,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5clone5impls51_$LT$impl$u20$core..clone..Clone$u20$for$u20$u8$GT$5clone17hc46abe1d42e8967eE","low_pc":34958,"high_pc":34979,"call_file":14,"call_line":902}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN78_$LT$core..iter..Cloned$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17h1c5d159a4850bfd1E","ranges":[[34989,34996],[35005,35013],[35016,35023]],"call_file":42,"call_line":37,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN91_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hf83518b40a45a8e9E","ranges":[[34989,34996],[35016,35023]],"call_file":52,"call_line":524,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN49_$LT$core..slice..Iter$LT$$u27$a$C$$u20$T$GT$$GT$14post_inc_start17h17bd566ccfe8ca1bE","low_pc":35016,"high_pc":35023,"call_file":9,"call_line":2836,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h75a480e7aef3b526E","low_pc":35016,"high_pc":35023,"call_file":9,"call_line":2788}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned17h76a14fc2c2da4705E","low_pc":35005,"high_pc":35013,"call_file":52,"call_line":524,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$3map17h9225ef15346dfc44E","low_pc":35005,"high_pc":35013,"call_file":14,"call_line":902,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN53_$LT$core..option..Option$LT$$RF$$u27$a$u20$T$GT$$GT$6cloned28_$u7b$$u7b$closure$u7d$$u7d$17hc207865d40c0f7feE","low_pc":35005,"high_pc":35013,"call_file":14,"call_line":424,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core5clone5impls51_$LT$impl$u20$core..clone..Clone$u20$for$u20$u8$GT$5clone17hc46abe1d42e8967eE","low_pc":35005,"high_pc":35013,"call_file":14,"call_line":902}]}]}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN38_$LT$core..option..Option$LT$T$GT$$GT$6unwrap17h8823332b7b0e2ec1E","low_pc":35066,"high_pc":35079,"call_file":42,"call_line":37}]},{"tag":"subprogram","low_pc":29482,"high_pc":29674,"linkage_name":"_ZN4core7unicode9printable12is_printable17he1d89eaf9c8bb36cE","name":"is_printable","decl_file":42,"decl_line":50,"external":true}]},{"tag":"namespace","name":"version","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]},{"tag":"namespace","name":"time","children":[{"tag":"structure_type","name":"Duration","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"secs","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"nanos","type":"u32","alignment":4,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_add17h069ca9befcd4c725E","name":"checked_add","decl_file":49,"decl_line":344,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_sub17h5512088d1030ded3E","name":"checked_sub","decl_file":49,"decl_line":382,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_mul17h5962b55e3a2194b4E","name":"checked_mul","decl_file":49,"decl_line":418,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_div17h71ef88e2bbad6cb9E","name":"checked_div","decl_file":49,"decl_line":454,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN62_$LT$core..time..Duration$u20$as$u20$core..ops..arith..Add$GT$3add17h7244b52b2db84109E","name":"add","decl_file":49,"decl_line":581,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN62_$LT$core..time..Duration$u20$as$u20$core..ops..arith..Sub$GT$3sub17ha486c15de6635b7cE","name":"sub","decl_file":49,"decl_line":597,"external":true,"inline":"inlined"},{"tag":"namespace","name":"checked_mul","children":[{"tag":"subprogram","linkage_name":"_ZN4core4time8Duration11checked_mul28_$u7b$$u7b$closure$u7d$$u7d$17hfc8d7a5b5d5a8056E","name":"{{closure}}","decl_file":49,"decl_line":425,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..time..Duration$u20$as$u20$core..ops..arith..Mul$LT$u32$GT$$GT$3mul17had8bd1e89724bbc9E","name":"mul","decl_file":49,"decl_line":613,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN73_$LT$core..time..Duration$u20$as$u20$core..ops..arith..Div$LT$u32$GT$$GT$3div17hd69b35ab60263850E","name":"div","decl_file":49,"decl_line":638,"external":true,"inline":"inlined"},{"tag":"namespace","name":"fmt","children":[{"tag":"namespace","name":"fmt_decimal","children":[{"tag":"subprogram","linkage_name":"_ZN57_$LT$core..time..Duration$u20$as$u20$core..fmt..Debug$GT$3fmt11fmt_decimal28_$u7b$$u7b$closure$u7d$$u7d$17h7cc33bd2196ce272E","name":"{{closure}}","decl_file":49,"decl_line":770,"inline":"inlined"}]}]}]}]},{"tag":"namespace","name":"task","children":[{"tag":"namespace","name":"wake","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]},{"tag":"namespace","name":"alloc","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","low_pc":36342,"high_pc":36565,"linkage_name":"_ZN59_$LT$core..alloc..LayoutErr$u20$as$u20$core..fmt..Debug$GT$3fmt17h22f17d5e32d5a697E","name":"fmt","decl_file":2,"decl_line":326,"external":true,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter12debug_struct17hf1d54c710f695d74E","low_pc":36362,"high_pc":36412,"call_file":2,"call_line":326,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders16debug_struct_new17h21ca356c25f15cebE","low_pc":36362,"high_pc":36412,"call_file":15,"call_line":1743,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9write_str17h6a6d0bda0abff774E","low_pc":36364,"high_pc":36395,"call_file":39,"call_line":99}]}]},{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct6finish17h70a13c3215c3f625E","ranges":[[36447,36543],[36555,36564]],"call_file":2,"call_line":326,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN47_$LT$core..result..Result$LT$T$C$$u20$E$GT$$GT$8and_then17h112ff9015b0c4b81E","low_pc":36476,"high_pc":36535,"call_file":39,"call_line":140,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct6finish28_$u7b$$u7b$closure$u7d$$u7d$17h196f6bd8fc374200E","low_pc":36482,"high_pc":36535,"call_file":6,"call_line":647,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt8builders11DebugStruct9is_pretty17h73fc38e3f5dd0a47E","ranges":[[36482,36487],[36504,36512]],"call_file":39,"call_line":141,"children":[{"tag":"inlined_subroutine","abstract_origin":"_ZN4core3fmt9Formatter9alternate17hd0290a931d764006E","low_pc":36504,"high_pc":36512,"call_file":39,"call_line":152}]}]}]}]}]}]},{"tag":"structure_type","name":"CannotReallocInPlace","byte_size":0,"alignment":1,"children":[]}]},{"tag":"namespace","name":"array","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core5array69_$LT$impl$u20$core..fmt..Debug$u20$for$u20$$u5b$T$u3b$$u20$_$u5d$$GT$3fmt17hce38e86cf59fe878E","name":"fmt<u8>","decl_file":54,"decl_line":188,"inline":"inlined"}]}]},{"tag":"namespace","name":"coresimd","children":[{"tag":"namespace","name":"simd","children":[{"tag":"namespace","name":"{{impl}}","children":[]}]}]}]},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":10}]},{"tag":"base_type","name":"u32","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":2}]},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":4}]},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":7}]},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":14}]},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":27}]},{"tag":"array_type","type":"(u64, i16, i16)","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":81}]},{"tag":"structure_type","name":"(u64, i16, i16)","byte_size":16,"alignment":8,"children":[{"tag":"member","name":"__0","type":"u64","alignment":8,"data_member_location":0},{"tag":"member","name":"__1","type":"i16","alignment":2,"data_member_location":8},{"tag":"member","name":"__2","type":"i16","alignment":2,"data_member_location":10}]},{"tag":"base_type","name":"u64","encoding":"unsigned","byte_size":8},{"tag":"base_type","name":"i16","encoding":"signed","byte_size":2},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":256}]},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"array_type","type":"AsciiCharacterClass","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":128}]},{"tag":"variable","name":"vtable","type":"vtable","location":"038C141000 // DW_OP_addr 0x10148c"},{"tag":"structure_type","containing_type":232831,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":233545,"name":"vtable","byte_size":0,"alignment":4},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"structure_type","name":"&str","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u8","name":"*const u8"},{"tag":"base_type","name":"char","encoding":"unsigned_char","byte_size":4},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":4}]},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":246759,"name":"vtable","byte_size":0,"alignment":4},{"tag":"structure_type","name":"&[u8]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u8","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":248124,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":236672,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":304601,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":304568,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":304509,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":236761,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":304502,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":233632,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":233706,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0394151000 // DW_OP_addr 0x101594"},{"tag":"structure_type","containing_type":252258,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u8","name":"*mut u8"},{"tag":"pointer_type","type":"usize[]","name":"&[usize; 3]"},{"tag":"array_type","type":"usize","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":3}]},{"tag":"variable","name":"vtable","type":"vtable","location":"03C4151000 // DW_OP_addr 0x1015c4"},{"tag":"structure_type","containing_type":304948,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u8","name":"&u8"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":304983,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"char","name":"&char"},{"tag":"variable","name":"vtable","type":"vtable","location":"03D4151000 // DW_OP_addr 0x1015d4"},{"tag":"structure_type","containing_type":255035,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"PadAdapter","name":"&mut core::fmt::builders::PadAdapter"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305053,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u64","name":"&u64"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305088,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"i16","name":"&i16"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305123,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"bool","name":"&bool"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305158,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Decoded","name":"&core::num::flt2dec::decoder::Decoded"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305193,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&[u8]","name":"&&[u8]"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305228,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u16","name":"&u16"},{"tag":"base_type","name":"u16","encoding":"unsigned","byte_size":2},{"tag":"variable","name":"vtable","type":"vtable","location":"03581C1000 // DW_OP_addr 0x101c58"},{"tag":"structure_type","containing_type":305270,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"usize","name":"&usize"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305305,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"i64","name":"&i64"},{"tag":"base_type","name":"i64","encoding":"signed","byte_size":8},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305347,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Decimal","name":"&core::num::dec2flt::parse::Decimal"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305382,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"FloatErrorKind","name":"&core::num::dec2flt::FloatErrorKind"},{"tag":"variable","name":"vtable","type":"vtable","location":"03681C1000 // DW_OP_addr 0x101c68"},{"tag":"structure_type","containing_type":305417,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"()","name":"&()"},{"tag":"base_type","name":"()","encoding":"unsigned","byte_size":0},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305459,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"IntErrorKind","name":"&core::num::IntErrorKind"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305494,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"CharErrorKind","name":"&core::char::convert::CharErrorKind"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305529,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"EscapeUnicodeState","name":"&core::char::EscapeUnicodeState"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305564,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"EscapeDefaultState","name":"&core::char::EscapeDefaultState"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305599,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"EscapeUnicode","name":"&core::char::EscapeUnicode"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305634,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"EscapeDefault","name":"&core::char::EscapeDefault"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305669,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"CaseMappingIter","name":"&core::char::CaseMappingIter"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305704,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&Any","name":"&&Any"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305739,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Option<&core::fmt::Arguments>","name":"&core::option::Option<&core::fmt::Arguments>"},{"tag":"pointer_type","type":"Arguments","name":"&core::fmt::Arguments"},{"tag":"structure_type","name":"&[&str]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const &str","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"&str","name":"*const &str"},{"tag":"structure_type","name":"&[core::fmt::rt::v1::Argument]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::rt::v1::Argument","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"Argument","name":"*const core::fmt::rt::v1::Argument"},{"tag":"structure_type","name":"&[core::fmt::ArgumentV1]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::fmt::ArgumentV1","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"ArgumentV1","name":"*const core::fmt::ArgumentV1"},{"tag":"pointer_type","type":"Void","name":"&core::fmt::Void"},{"tag":"pointer_type","type":"subroutine Result","name":"fn(&core::fmt::Void, &mut core::fmt::Formatter) -> core::result::Result<(), core::fmt::Error>"},{"tag":"subroutine_type","type":"Result","children":[{"tag":"formal_parameter","type":"&core::fmt::Void"},{"tag":"formal_parameter","type":"&mut core::fmt::Formatter"}]},{"tag":"pointer_type","type":"Formatter","name":"&mut core::fmt::Formatter"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305943,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Location","name":"&core::panic::Location"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":305978,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&str","name":"&&str"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306013,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u32","name":"&u32"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306048,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Iter<u8>","name":"&core::slice::Iter<u8>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306083,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&core::fmt::Arguments","name":"&&core::fmt::Arguments"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306118,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"u8[]","name":"&[u8; 4]"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306153,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"&[char]","name":"&&[char]"},{"tag":"structure_type","name":"&[char]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const char","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"char","name":"*const char"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306227,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"CharIndices","name":"&core::str::CharIndices"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306262,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"MultiCharEqSearcher<&[char]>","name":"&core::str::pattern::MultiCharEqSearcher<&[char]>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306297,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"StrSearcherImpl","name":"&core::str::pattern::StrSearcherImpl"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306332,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"TwoWaySearcher","name":"&core::str::pattern::TwoWaySearcher"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306367,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"EmptyNeedle","name":"&core::str::pattern::EmptyNeedle"},{"tag":"variable","name":"vtable","type":"vtable","location":"03781C1000 // DW_OP_addr 0x101c78"},{"tag":"structure_type","containing_type":306402,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Option<u8>","name":"&core::option::Option<u8>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306437,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Chars","name":"&core::str::Chars"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306472,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Cloned<core::slice::Iter<u8>>","name":"&core::iter::Cloned<core::slice::Iter<u8>>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":236691,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":233564,"name":"vtable","byte_size":0,"alignment":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306559,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Map<core::str::SplitTerminator<char>, core::str::LinesAnyMap>","name":"&core::iter::Map<core::str::SplitTerminator<char>, core::str::LinesAnyMap>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306594,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Lines","name":"&core::str::Lines"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306629,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Filter<core::str::Split<core::str::IsWhitespace>, core::str::IsNotEmpty>","name":"&core::iter::Filter<core::str::Split<core::str::IsWhitespace>, core::str::IsNotEmpty>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306664,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Map<core::iter::Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>, core::str::UnsafeBytesToStr>","name":"&core::iter::Map<core::iter::Filter<core::slice::Split<u8, core::str::IsAsciiWhitespace>, core::str::IsNotEmpty>, core::str::UnsafeBytesToStr>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306699,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Hasher<core::hash::sip::Sip13Rounds>","name":"&core::hash::sip::Hasher<core::hash::sip::Sip13Rounds>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306734,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"Hasher<core::hash::sip::Sip24Rounds>","name":"&core::hash::sip::Hasher<core::hash::sip::Sip24Rounds>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306769,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"SipHasher24","name":"&core::hash::sip::SipHasher24"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306804,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"State","name":"&core::hash::sip::State"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306839,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"PhantomData<core::hash::sip::Sip24Rounds>","name":"&core::marker::PhantomData<core::hash::sip::Sip24Rounds>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306874,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"PhantomData<core::hash::sip::Sip13Rounds>","name":"&core::marker::PhantomData<core::hash::sip::Sip13Rounds>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306909,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"NonNull<u8>","name":"&core::ptr::NonNull<u8>"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306944,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"NonZeroUsize","name":"&core::num::NonZeroUsize"},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":306979,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"i8","name":"&i8"},{"tag":"base_type","name":"i8","encoding":"signed","byte_size":1},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":307021,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"i32","name":"&i32"},{"tag":"base_type","name":"i32","encoding":"signed","byte_size":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":307063,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"f32","name":"&f32"},{"tag":"base_type","name":"f32","encoding":"float","byte_size":4},{"tag":"variable","name":"vtable","type":"vtable","location":"0300000000 // DW_OP_addr 0x0"},{"tag":"structure_type","containing_type":307105,"name":"vtable","byte_size":0,"alignment":4},{"tag":"pointer_type","type":"f64","name":"&f64"},{"tag":"base_type","name":"f64","encoding":"float","byte_size":8},{"tag":"array_type","type":"u32","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":40}]},{"tag":"pointer_type","type":"u32","name":"*mut u32"},{"tag":"pointer_type","type":"u32","name":"*const u32"},{"tag":"pointer_type","type":"Part","name":"*const core::num::flt2dec::Part"},{"tag":"structure_type","name":"&[core::num::flt2dec::Part]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const core::num::flt2dec::Part","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0}]},{"tag":"structure_type","name":"&[u64]","byte_size":8,"alignment":4,"children":[{"tag":"member","name":"data_ptr","type":"*const u64","alignment":4,"data_member_location":0},{"tag":"member","name":"length","type":"usize","alignment":4,"data_member_location":4}]},{"tag":"pointer_type","type":"u64","name":"*const u64"},{"tag":"pointer_type","type":"Argument","name":"&core::fmt::rt::v1::Argument"},{"tag":"pointer_type","type":"ArgumentV1","name":"&core::fmt::ArgumentV1"},{"tag":"array_type","type":"u64","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":32}]},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":992}]},{"tag":"pointer_type","type":"(u8, u8)","name":"*const (u8, u8)"},{"tag":"structure_type","name":"(u8, u8)","byte_size":2,"alignment":1,"children":[{"tag":"member","name":"__0","type":"u8","alignment":1,"data_member_location":0},{"tag":"member","name":"__1","type":"u8","alignment":1,"data_member_location":1}]},{"tag":"array_type","type":"u8","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":3}]},{"tag":"base_type","name":"isize","encoding":"signed","byte_size":4}]},{"tag":"compile_unit","producer":"clang LLVM (rustc version 1.32.0-nightly (653da4fd0 2018-11-08))","language":"Rust","name":"rustc/compiler_builtins_shim/../../libcompiler_builtins/src/lib.rs","stmt_list":217142,"GNU_pubnames":true,"low_pc":0,"ranges":[[36611,36665],[36566,36610],[36666,36734]],"children":[{"tag":"namespace","name":"compiler_builtins","children":[{"tag":"namespace","name":"math","children":[{"tag":"namespace","name":"libm","children":[{"tag":"namespace","name":"exp2","children":[{"tag":"variable","name":"TBL","type":"u64[]","decl_file":137,"decl_line":32,"alignment":1,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN17compiler_builtins4math4libm4exp23TBL17h1fe28471442d863aE"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4exp24exp217hcfc7881f114e1f52E","name":"exp2","decl_file":137,"decl_line":322,"inline":"inlined"}]},{"tag":"namespace","name":"exp2f","children":[{"tag":"variable","name":"EXP2FT","type":"u64[]","decl_file":138,"decl_line":29,"alignment":1,"location":"0300000000 // DW_OP_addr 0x0","linkage_name":"_ZN17compiler_builtins4math4libm5exp2f6EXP2FT17hba3cfac2281268c1E"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5exp2f5exp2f17h24c74eb1f902e5b0E","name":"exp2f","decl_file":138,"decl_line":73,"inline":"inlined"}]},{"tag":"namespace","name":"k_tan","children":[{"tag":"variable","name":"T","type":"f64[]","decl_file":139,"decl_line":43,"alignment":1,"linkage_name":"_ZN17compiler_builtins4math4libm5k_tan1T17h95f1b79b14acb9dfE"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5k_tan5k_tan17hb553939d8d461694E","name":"k_tan","decl_file":139,"decl_line":62,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5k_tan13zero_low_word17h0a71b3490e7fc984E","name":"zero_low_word","decl_file":139,"decl_line":104,"inline":"inlined"}]},{"tag":"namespace","name":"fabs","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4fabs4fabs17h768bf9c45e50fabaE","name":"fabs","decl_file":140,"decl_line":4,"inline":"inlined"}]},{"tag":"namespace","name":"atan","children":[]},{"tag":"namespace","name":"scalbn","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm6scalbn6scalbn17h8b3b55e64be897a8E","name":"scalbn","decl_file":141,"decl_line":2,"inline":"inlined"}]},{"tag":"namespace","name":"exp","children":[]},{"tag":"namespace","name":"expm1","children":[]},{"tag":"namespace","name":"rem_pio2","children":[{"tag":"namespace","name":"rem_pio2","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm8rem_pio28rem_pio26medium17h25faec5e4d4363d9E","name":"medium","decl_file":142,"decl_line":53,"inline":"inlined"}]}]},{"tag":"namespace","name":"floor","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5floor5floor17h9bb664ab2e5885e3E","name":"floor","decl_file":143,"decl_line":6,"inline":"inlined"}]},{"tag":"namespace","name":"rem_pio2_large","children":[]},{"tag":"namespace","name":"acos","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4acos4acos17h99ff85339d6fe742E","name":"acos","decl_file":144,"decl_line":59,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4acos1r17h35636d185df3ab45E","name":"r","decl_file":144,"decl_line":52,"inline":"inlined"}]},{"tag":"namespace","name":"sqrt","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4sqrt4sqrt17h06d1d224626e6c59E","name":"sqrt","decl_file":145,"decl_line":84,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm13get_high_word17h625d2fe0ab84e7fcE","name":"get_high_word","decl_file":146,"decl_line":226,"inline":"inlined"},{"tag":"namespace","name":"asin","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4asin4asin17h9edeabf1979b585eE","name":"asin","decl_file":147,"decl_line":66,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4asin6comp_r17h9dc39a87d72549fdE","name":"comp_r","decl_file":147,"decl_line":59,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm12get_low_word17ha6b9cebda7e8d28fE","name":"get_low_word","decl_file":146,"decl_line":231,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm17with_set_low_word17haca8a7b545c2a834E","name":"with_set_low_word","decl_file":146,"decl_line":244,"inline":"inlined"},{"tag":"namespace","name":"atan2","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5atan25atan217h1a56e11264696c28E","name":"atan2","decl_file":148,"decl_line":47,"inline":"inlined"}]},{"tag":"namespace","name":"cbrt","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4cbrt4cbrt17h18f5d2ae9361b444E","name":"cbrt","decl_file":149,"decl_line":31,"inline":"inlined"}]},{"tag":"namespace","name":"cosh","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4cosh4cosh17h2d3f2b954f2220abE","name":"cosh","decl_file":150,"decl_line":6,"inline":"inlined"}]},{"tag":"namespace","name":"k_expo2","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm7k_expo27k_expo217he897d1deb440ed10E","name":"k_expo2","decl_file":151,"decl_line":8,"inline":"inlined"}]},{"tag":"namespace","name":"hypot","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5hypot5hypot17h08e6deb7d5309d8aE","name":"hypot","decl_file":152,"decl_line":22,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5hypot2sq17h323e677e0f35d927E","name":"sq","decl_file":152,"decl_line":8,"inline":"inlined"}]},{"tag":"namespace","name":"log1p","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5log1p5log1p17h9499ddba6e1c015bE","name":"log1p","decl_file":153,"decl_line":69,"inline":"inlined"}]},{"tag":"namespace","name":"sinh","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4sinh4sinh17h92c74f39ec38c128E","name":"sinh","decl_file":154,"decl_line":8,"inline":"inlined"}]},{"tag":"namespace","name":"expo2","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5expo25expo217hdef4088dd6c4decaE","name":"expo2","decl_file":155,"decl_line":5,"inline":"inlined"}]},{"tag":"namespace","name":"tan","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3tan3tan17h35f29a78a1bda076E","name":"tan","decl_file":156,"decl_line":43,"inline":"inlined"}]},{"tag":"namespace","name":"tanh","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4tanh4tanh17h23b0f7bc24b490bfE","name":"tanh","decl_file":157,"decl_line":8,"inline":"inlined"}]},{"tag":"namespace","name":"cos","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3cos3cos17h83888be227583ec1E","name":"cos","decl_file":158,"decl_line":45,"inline":"inlined"}]},{"tag":"namespace","name":"k_cos","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5k_cos5k_cos17hddbba94ae91587a5E","name":"k_cos","decl_file":159,"decl_line":55,"inline":"inlined"}]},{"tag":"namespace","name":"k_sin","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5k_sin5k_sin17h9e537726c886204fE","name":"k_sin","decl_file":160,"decl_line":47,"inline":"inlined"}]},{"tag":"namespace","name":"cosf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4cosf4cosf17he4a0ca367714d20fE","name":"cosf","decl_file":161,"decl_line":28,"inline":"inlined"}]},{"tag":"namespace","name":"k_cosf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm6k_cosf6k_cosf17h051ff8f48afb7491E","name":"k_cosf","decl_file":162,"decl_line":24,"inline":"inlined"}]},{"tag":"namespace","name":"k_sinf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm6k_sinf6k_sinf17ha93c8238542623b5E","name":"k_sinf","decl_file":163,"decl_line":24,"inline":"inlined"}]},{"tag":"namespace","name":"rem_pio2f","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm9rem_pio2f9rem_pio2f17h21b6c2aae0182eaaE","name":"rem_pio2f","decl_file":164,"decl_line":35,"inline":"inlined"}]},{"tag":"namespace","name":"expf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4expf4expf17h85b483d301e8d3e5E","name":"expf","decl_file":165,"decl_line":30,"inline":"inlined"}]},{"tag":"namespace","name":"scalbnf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm7scalbnf7scalbnf17hb269b1deec4ae0f4E","name":"scalbnf","decl_file":166,"decl_line":2,"inline":"inlined"}]},{"tag":"namespace","name":"log2","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4log24log217h051ea5c73bb39f38E","name":"log2","decl_file":167,"decl_line":33,"inline":"inlined"}]},{"tag":"namespace","name":"log2f","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5log2f5log2f17h89a6b7f0dfb490b4E","name":"log2f","decl_file":168,"decl_line":27,"inline":"inlined"}]},{"tag":"namespace","name":"log10","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5log105log1017hbdb7704d881cbe2eE","name":"log10","decl_file":169,"decl_line":35,"inline":"inlined"}]},{"tag":"namespace","name":"log10f","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm6log10f6log10f17h770df6c98199af11E","name":"log10f","decl_file":170,"decl_line":29,"inline":"inlined"}]},{"tag":"namespace","name":"log","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3log3log17h984e38fa76c24899E","name":"log","decl_file":171,"decl_line":74,"inline":"inlined"}]},{"tag":"namespace","name":"logf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4logf4logf17hb2e3198143219522E","name":"logf","decl_file":172,"decl_line":25,"inline":"inlined"}]},{"tag":"namespace","name":"round","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5round5round17h8599c9d98d40c6f1E","name":"round","decl_file":173,"decl_line":6,"inline":"inlined"}]},{"tag":"namespace","name":"roundf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm6roundf6roundf17hb89678f253f2ee30E","name":"roundf","decl_file":174,"decl_line":6,"inline":"inlined"}]},{"tag":"namespace","name":"sin","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3sin3sin17hd461cc2a2196d3aaE","name":"sin","decl_file":175,"decl_line":44,"inline":"inlined"}]},{"tag":"namespace","name":"sinf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4sinf4sinf17h56954699aac1d505E","name":"sinf","decl_file":176,"decl_line":28,"inline":"inlined"}]},{"tag":"namespace","name":"pow","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3pow3pow17hb8cf56ba33f9107fE","name":"pow","decl_file":177,"decl_line":93,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm18with_set_high_word17h4f8887008915b41aE","name":"with_set_high_word","decl_file":146,"decl_line":236,"inline":"inlined"},{"tag":"namespace","name":"powf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4powf4powf17h17fe7d863fd5d109E","name":"powf","decl_file":178,"decl_line":47,"inline":"inlined"}]},{"tag":"namespace","name":"sqrtf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5sqrtf5sqrtf17hbe6f95cdc4d3332aE","name":"sqrtf","decl_file":179,"decl_line":19,"inline":"inlined"}]},{"tag":"namespace","name":"fabsf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5fabsf5fabsf17hecd06eaf11af3eb2E","name":"fabsf","decl_file":180,"decl_line":2,"inline":"inlined"}]},{"tag":"namespace","name":"fmod","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4fmod4fmod17hf60cbf43a888194cE","name":"fmod","decl_file":181,"decl_line":4,"inline":"inlined"}]},{"tag":"namespace","name":"fmodf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm5fmodf5fmodf17h9c48643afb29afb1E","name":"fmodf","decl_file":182,"decl_line":5,"inline":"inlined"}]},{"tag":"namespace","name":"fma","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3fma9normalize17h2d0f531236768738E","name":"normalize","decl_file":183,"decl_line":14,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3fma3fma17h29def2fd94c7fdb6E","name":"fma","decl_file":183,"decl_line":52,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm3fma3mul17h819550d6dd2a060bE","name":"mul","decl_file":183,"decl_line":34,"inline":"inlined"}]},{"tag":"namespace","name":"fmaf","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins4math4libm4fmaf4fmaf17h4250ac5fb75b00caE","name":"fmaf","decl_file":184,"decl_line":44,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"float","children":[{"tag":"namespace","name":"cmp","children":[{"tag":"enumeration_type","type":"u8","enum_class":true,"name":"Result","byte_size":1,"alignment":1,"children":[{"tag":"enumerator","name":"Less","const_value":0},{"tag":"enumerator","name":"Equal","const_value":1},{"tag":"enumerator","name":"Greater","const_value":2},{"tag":"enumerator","name":"Unordered","const_value":3},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp6Result9to_ge_abi17hac2a8c68a3adc4dcE","name":"to_ge_abi","decl_file":185,"decl_line":24,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp6Result9to_le_abi17h074f332afaebba61E","name":"to_le_abi","decl_file":185,"decl_line":15,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp3cmp17hbc3e2351a8da638dE","name":"cmp<f32>","decl_file":185,"decl_line":34,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp5unord17hdbe6da60c6a9c58aE","name":"unord<f32>","decl_file":185,"decl_line":93,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp3cmp17heeee9680abab141aE","name":"cmp<f64>","decl_file":185,"decl_line":34,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3cmp5unord17h8b59afa5470b65ffE","name":"unord<f64>","decl_file":185,"decl_line":93,"inline":"inlined"}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN55_$LT$f32$u20$as$u20$compiler_builtins..float..Float$GT$10from_parts17h9da57866bb28365bE","name":"from_parts","decl_file":186,"decl_line":120,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f32$u20$as$u20$compiler_builtins..float..Float$GT$9from_repr17h86429585df0bfe91E","name":"from_repr","decl_file":186,"decl_line":117,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f64$u20$as$u20$compiler_builtins..float..Float$GT$10from_parts17h8ef3c2abcfa1896fE","name":"from_parts","decl_file":186,"decl_line":120,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f64$u20$as$u20$compiler_builtins..float..Float$GT$9from_repr17hc55ffaca868d03acE","name":"from_repr","decl_file":186,"decl_line":117,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f32$u20$as$u20$compiler_builtins..float..Float$GT$4repr17hcf1b03e50a1f824aE","name":"repr","decl_file":186,"decl_line":103,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f64$u20$as$u20$compiler_builtins..float..Float$GT$4repr17h5eaa4683912b9632E","name":"repr","decl_file":186,"decl_line":103,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f32$u20$as$u20$compiler_builtins..float..Float$GT$9normalize17h1cd84ca838e7fd72E","name":"normalize","decl_file":186,"decl_line":125,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$f64$u20$as$u20$compiler_builtins..float..Float$GT$9normalize17h14abf8b43e467fa5E","name":"normalize","decl_file":186,"decl_line":125,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"conv","children":[]},{"tag":"namespace","name":"add","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3add3add17h9925dbf28cad085aE","name":"add<f32>","decl_file":187,"decl_line":5,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3add3add17h6bea57b5927d0782E","name":"add<f64>","decl_file":187,"decl_line":5,"inline":"inlined"}]},{"tag":"namespace","name":"pow","children":[{"tag":"namespace","name":"Pow","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3pow3Pow3pow17h89bc86298e03c743E","name":"pow<f32>","decl_file":188,"decl_line":6,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3pow3Pow3pow17h700ca4e66b48cba3E","name":"pow<f64>","decl_file":188,"decl_line":6,"inline":"inlined"}]}]},{"tag":"namespace","name":"sub","children":[]},{"tag":"namespace","name":"mul","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3mul3mul17h4c2d8600181b9a2dE","name":"mul<f32>","decl_file":189,"decl_line":4,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3mul3mul17ha766e03ed2688288E","name":"mul<f64>","decl_file":189,"decl_line":4,"inline":"inlined"}]},{"tag":"namespace","name":"div","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3div5div3217hdaa479c7d0c6228aE","name":"div32<f32>","decl_file":190,"decl_line":6,"inline":"inlined"},{"tag":"namespace","name":"div32","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3div5div3210negate_u3217h6053aa4cffe307baE","name":"negate_u32","decl_file":190,"decl_line":33,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3div5div6417ha52571bd7f32a2a9E","name":"div64<f64>","decl_file":190,"decl_line":206,"inline":"inlined"},{"tag":"namespace","name":"div64","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3div5div6410negate_u3217h23d65e0c21d73195E","name":"negate_u32","decl_file":190,"decl_line":238,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float3div5div6410negate_u6417h61c628d4622da1c3E","name":"negate_u64","decl_file":190,"decl_line":243,"inline":"inlined"}]}]},{"tag":"namespace","name":"extend","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5float6extend6extend17hd72824200d0d3064E","name":"extend<f32,f64>","decl_file":191,"decl_line":5,"inline":"inlined"}]}]},{"tag":"namespace","name":"mem","children":[{"tag":"subprogram","low_pc":36611,"high_pc":36665,"linkage_name":"memcpy","name":"memcpy","decl_file":48,"decl_line":9,"external":true},{"tag":"subprogram","low_pc":36566,"high_pc":36610,"linkage_name":"memset","name":"memset","decl_file":48,"decl_line":45,"external":true},{"tag":"subprogram","low_pc":36666,"high_pc":36734,"linkage_name":"memcmp","name":"memcmp","decl_file":48,"decl_line":55,"external":true}]},{"tag":"namespace","name":"int","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$15overflowing_add17h6b3c17f1cf28c9cbE","name":"overflowing_add","decl_file":192,"decl_line":124,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_add17h0e11d791ec174f4aE","name":"wrapping_add","decl_file":192,"decl_line":108,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$u64$u20$as$u20$compiler_builtins..int..LargeInt$GT$3low17h7cb1f334e5c70392E","name":"low","decl_file":192,"decl_line":210,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17h9ed964c4ccdb6246E","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$u64$u20$as$u20$compiler_builtins..int..LargeInt$GT$4high17h1f77051ae671be08E","name":"high","decl_file":192,"decl_line":216,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_add17hde6bf7ce198e5696E","name":"wrapping_add","decl_file":192,"decl_line":108,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$u64$u20$as$u20$compiler_builtins..int..LargeInt$GT$10from_parts17h84ca0c171c7ddee9E","name":"from_parts","decl_file":192,"decl_line":222,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i32$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17hb22bb30a3f80b164E","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17h3d19196ffe5ef9baE","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i128$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17hbf64b97dc3b1dd01E","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i128$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17hc9d7388328646b0eE","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17h5792f40d9cfc089cE","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17hdf0bd1c684387d11E","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_add17h5d0709aac8a66147E","name":"wrapping_add","decl_file":192,"decl_line":108,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u128$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17h431838fa3034b7eeE","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u128$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17h2b89a1183649b162E","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i32$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_sub17h4503b634709184cdE","name":"wrapping_sub","decl_file":192,"decl_line":116,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17he8423710104a1790E","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_sub17h77817a870eebe90eE","name":"wrapping_sub","decl_file":192,"decl_line":116,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_div17h19982900aec3a0c1E","name":"aborting_div","decl_file":192,"decl_line":128,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_rem17ha7ea323b247f0524E","name":"aborting_rem","decl_file":192,"decl_line":132,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_rem17hb823d369b4d2f06bE","name":"aborting_rem","decl_file":192,"decl_line":132,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i32$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_mul17h4d47ef12e6509c36E","name":"wrapping_mul","decl_file":192,"decl_line":112,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i128$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_sub17h2daabbe6d31e1928E","name":"wrapping_sub","decl_file":192,"decl_line":116,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u128$u20$as$u20$compiler_builtins..int..Int$GT$12aborting_rem17h2bde4e0c7fb87346E","name":"aborting_rem","decl_file":192,"decl_line":132,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$i64$u20$as$u20$compiler_builtins..int..LargeInt$GT$4high17h2a7d78b0f59d0631E","name":"high","decl_file":192,"decl_line":216,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$i64$u20$as$u20$compiler_builtins..int..LargeInt$GT$10from_parts17ha86e9ea65bef7544E","name":"from_parts","decl_file":192,"decl_line":222,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN56_$LT$i64$u20$as$u20$compiler_builtins..int..LargeInt$GT$3low17hddca77e345046344E","name":"low","decl_file":192,"decl_line":210,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i32$u20$as$u20$compiler_builtins..int..Int$GT$12extract_sign17haddfef9fbc9d4b0dE","name":"extract_sign","decl_file":192,"decl_line":167,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$compiler_builtins..int..Int$GT$12extract_sign17head93e4a10df6c3cE","name":"extract_sign","decl_file":192,"decl_line":167,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$i128$u20$as$u20$compiler_builtins..int..Int$GT$12extract_sign17hed288a2f6465b13fE","name":"extract_sign","decl_file":192,"decl_line":167,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_sub17h9f53808dca35c03bE","name":"wrapping_sub","decl_file":192,"decl_line":116,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$compiler_builtins..int..Int$GT$13leading_zeros17hdcf978e7025030dbE","name":"leading_zeros","decl_file":192,"decl_line":136,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_sub17h26e4d0c3be10129dE","name":"wrapping_sub","decl_file":192,"decl_line":116,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$u64$u20$as$u20$compiler_builtins..int..CastInto$LT$i32$GT$$GT$4cast17hc117db536dfa9d49E","name":"cast","decl_file":192,"decl_line":245,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$9from_bool17h365d46719269083fE","name":"from_bool","decl_file":192,"decl_line":96,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$13leading_zeros17hb04be0e2e0cf3b65E","name":"leading_zeros","decl_file":192,"decl_line":136,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$i32$u20$as$u20$compiler_builtins..int..CastInto$LT$u64$GT$$GT$4cast17h0d1c7ea2a86c56c5E","name":"cast","decl_file":192,"decl_line":245,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u32$u20$as$u20$compiler_builtins..int..WideInt$GT$8wide_mul17h551360fab299d2feE","name":"wide_mul","decl_file":192,"decl_line":272,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u32$u20$as$u20$compiler_builtins..int..WideInt$GT$15wide_shift_left17hb5f005ec5aa035ddE","name":"wide_shift_left","decl_file":192,"decl_line":277,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u32$u20$as$u20$compiler_builtins..int..WideInt$GT$28wide_shift_right_with_sticky17h3f54e3eb994cda53E","name":"wide_shift_right_with_sticky","decl_file":192,"decl_line":282,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u64$u20$as$u20$compiler_builtins..int..WideInt$GT$8wide_mul17h38165373facd33d7E","name":"wide_mul","decl_file":192,"decl_line":272,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u64$u20$as$u20$compiler_builtins..int..WideInt$GT$15wide_shift_left17h4d5513f8b2e324dcE","name":"wide_shift_left","decl_file":192,"decl_line":277,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$u64$u20$as$u20$compiler_builtins..int..WideInt$GT$28wide_shift_right_with_sticky17hfbf9576beb59c815E","name":"wide_shift_right_with_sticky","decl_file":192,"decl_line":282,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$u64$u20$as$u20$compiler_builtins..int..CastInto$LT$u32$GT$$GT$4cast17h847323cceca9fb31E","name":"cast","decl_file":192,"decl_line":245,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN67_$LT$u32$u20$as$u20$compiler_builtins..int..CastInto$LT$u64$GT$$GT$4cast17ha35e61ee26090adbE","name":"cast","decl_file":192,"decl_line":245,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$compiler_builtins..int..Int$GT$12wrapping_shl17h312322c0b66e11c5E","name":"wrapping_shl","decl_file":192,"decl_line":120,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"addsub","children":[{"tag":"namespace","name":"UAddSub","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub7UAddSub4uadd17h8c39cb433e2e4437E","name":"uadd<u128>","decl_file":193,"decl_line":5,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub7UAddSub4usub17h5c142825b564fec3E","name":"usub<u128>","decl_file":193,"decl_line":16,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub7UAddSub8uadd_one17h49779c2b808ff871E","name":"uadd_one<u128>","decl_file":193,"decl_line":11,"inline":"inlined"}]},{"tag":"namespace","name":"AddSub","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub6AddSub3add17h837d4ce6804451e8E","name":"add<u128>","decl_file":193,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub6AddSub3add17he288de59c40a68c1E","name":"add<i128>","decl_file":193,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub6AddSub3sub17h2c4bb957988d8cdfE","name":"sub<u128>","decl_file":193,"decl_line":30,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub6AddSub3sub17h3a1649a69a232bbdE","name":"sub<i128>","decl_file":193,"decl_line":30,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub13rust_u128_add17ha54938e35717f55fE","name":"rust_u128_add","decl_file":194,"decl_line":293,"external":true,"inline":"inlined"},{"tag":"namespace","name":"Addo","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub4Addo4addo17h94b2382f131d2d05E","name":"addo<i128>","decl_file":193,"decl_line":41,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub4Addo4addo17h7a748b7ba9e0ebe2E","name":"addo<u128>","decl_file":193,"decl_line":41,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub13rust_u128_sub17hecc415677e241b70E","name":"rust_u128_sub","decl_file":194,"decl_line":293,"external":true,"inline":"inlined"},{"tag":"namespace","name":"Subo","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub4Subo4subo17hd8197e927d1b576dE","name":"subo<i128>","decl_file":193,"decl_line":63,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6addsub4Subo4subo17hc319b653baf44cc9E","name":"subo<u128>","decl_file":193,"decl_line":63,"inline":"inlined"}]}]},{"tag":"namespace","name":"mul","children":[{"tag":"namespace","name":"Mul","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul3Mul3mul17h9a1f85f00557256eE","name":"mul<u64>","decl_file":195,"decl_line":7,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul3Mul3mul17h8b7e4992c44072faE","name":"mul<i128>","decl_file":195,"decl_line":7,"inline":"inlined"}]},{"tag":"namespace","name":"Mulo","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul4Mulo4mulo17h0081338bc4dbcc57E","name":"mulo<i32>","decl_file":195,"decl_line":32,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul4Mulo4mulo17ha77d3045b08c7088E","name":"mulo<i64>","decl_file":195,"decl_line":32,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul4Mulo4mulo17hb1ba4f656fcd2a1fE","name":"mulo<i128>","decl_file":195,"decl_line":32,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"__multi3","name":"__multi3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__muloti4","name":"__muloti4","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"namespace","name":"UMulo","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int3mul5UMulo4mulo17hd6bec64435532274E","name":"mulo<u128>","decl_file":195,"decl_line":74,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17h321f740b7e36c52dE","name":"unwrap<i32>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17h48c89aa556b63310E","name":"unwrap<i64>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17h41c540df220e4514E","name":"unwrap<i128>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17ha438bb52e425a1b5E","name":"unwrap<u128>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"namespace","name":"sdiv","children":[{"tag":"namespace","name":"Div","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Div3div17h424435a91091eddbE","name":"div<i32>","decl_file":196,"decl_line":5,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Div3div17h174a2861b0eb0a95E","name":"div<i64>","decl_file":196,"decl_line":5,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Div3div17he0c78557baefb056E","name":"div<i128>","decl_file":196,"decl_line":5,"inline":"inlined"}]},{"tag":"namespace","name":"Mod","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Mod4mod_17h0f64836666be4fd9E","name":"mod_<i32>","decl_file":196,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Mod4mod_17he27c22df108798adE","name":"mod_<i64>","decl_file":196,"decl_line":27,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv3Mod4mod_17h2eb0331e6c633f3fE","name":"mod_<i128>","decl_file":196,"decl_line":27,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"__divsi3","name":"__divsi3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"namespace","name":"__divmodsi4","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv11__divmodsi428_$u7b$$u7b$closure$u7d$$u7d$17h577200cceef7296bE","name":"{{closure}}","decl_file":196,"decl_line":96,"inline":"inlined"}]},{"tag":"namespace","name":"Divmod","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv6Divmod6divmod17h7ec0b6cb86ec9940E","name":"divmod<i32,closure>","decl_file":196,"decl_line":45,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv6Divmod6divmod17he8988c03e4983517E","name":"divmod<i64,closure>","decl_file":196,"decl_line":45,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"__divdi3","name":"__divdi3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"namespace","name":"__divmoddi4","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int4sdiv11__divmoddi428_$u7b$$u7b$closure$u7d$$u7d$17ha94f4d778e1167a9E","name":"{{closure}}","decl_file":196,"decl_line":101,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"__divti3","name":"__divti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__modti3","name":"__modti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17hc811aef0b2f3088dE","name":"unwrap<u32>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int6unwrap17h792bd72cab670be8E","name":"unwrap<u64>","decl_file":192,"decl_line":82,"inline":"inlined"},{"tag":"namespace","name":"shift","children":[{"tag":"namespace","name":"Ashl","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Ashl4ashl17h5d3018db6fabc1d6E","name":"ashl<u64>","decl_file":197,"decl_line":5,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Ashl4ashl17h5ab08f5b5e0c0f4dE","name":"ashl<u128>","decl_file":197,"decl_line":5,"inline":"inlined"}]},{"tag":"namespace","name":"Ashr","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Ashr4ashr17h7ef6e3e371a5d821E","name":"ashr<i64>","decl_file":197,"decl_line":26,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Ashr4ashr17h3fdea70a5012287fE","name":"ashr<i128>","decl_file":197,"decl_line":26,"inline":"inlined"}]},{"tag":"namespace","name":"Lshr","children":[{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Lshr4lshr17h6fa51601045fb493E","name":"lshr<u64>","decl_file":197,"decl_line":48,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift4Lshr4lshr17h8c017e58f9c9d5d6E","name":"lshr<u128>","decl_file":197,"decl_line":48,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"__ashlti3","name":"__ashlti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift13rust_i128_shl17h1830d39e4282e91aE","name":"rust_i128_shl","decl_file":194,"decl_line":293,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__ashrti3","name":"__ashrti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift13rust_i128_shr17h3cf0bc11ae0c3f38E","name":"rust_i128_shr","decl_file":194,"decl_line":293,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__lshrti3","name":"__lshrti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins3int5shift13rust_u128_shr17h4608effe5d434388E","name":"rust_u128_shr","decl_file":194,"decl_line":293,"external":true,"inline":"inlined"}]},{"tag":"namespace","name":"udiv","children":[{"tag":"subprogram","linkage_name":"__udivsi3","name":"__udivsi3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__udivti3","name":"__udivti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"},{"tag":"subprogram","linkage_name":"__umodti3","name":"__umodti3","decl_file":194,"decl_line":254,"external":true,"inline":"inlined"}]}]},{"tag":"subprogram","linkage_name":"_ZN17compiler_builtins5abort17h7a5de3d61c7cfd29E","name":"abort","decl_file":198,"decl_line":40,"noreturn":true,"inline":"inlined"}]},{"tag":"array_type","type":"u64","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":512}]},{"tag":"base_type","name":"u64","encoding":"unsigned","byte_size":8},{"tag":"base_type","name":"__ARRAY_SIZE_TYPE__","byte_size":8,"encoding":"unsigned"},{"tag":"array_type","type":"u64","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":16}]},{"tag":"array_type","type":"f64","children":[{"tag":"subrange_type","type":"__ARRAY_SIZE_TYPE__","lower_bound":0,"count":13}]},{"tag":"base_type","name":"f64","encoding":"float","byte_size":8},{"tag":"base_type","name":"u8","encoding":"unsigned","byte_size":1},{"tag":"namespace","name":"core","children":[{"tag":"namespace","name":"f64","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$7to_bits17h3d57cda1e51903b4E","name":"to_bits","decl_file":135,"decl_line":442,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$6is_nan17hc0b55b9f49358b4dE","name":"is_nan","decl_file":135,"decl_line":170,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f6421_$LT$impl$u20$f64$GT$9from_bits17h007fc438aa341a5dE","name":"from_bits","decl_file":135,"decl_line":486,"inline":"inlined"}]}]},{"tag":"namespace","name":"ptr","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr13read_volatile17h82797840dacc329bE","name":"read_volatile<f32>","decl_file":0,"decl_line":877,"inline":"inlined"},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h1fca50338e71eac7E","name":"offset<f64>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17hf9713a5fd9653885E","name":"add<f64>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h482a9f7799b32bbbE","name":"offset<f64>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17hcfb0a7309a436f78E","name":"add<f64>","decl_file":0,"decl_line":1935,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$6offset17h9d79ab6a75a9d3ebE","name":"offset<i32>","decl_file":0,"decl_line":1079,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr33_$LT$impl$u20$$BP$const$u20$T$GT$3add17h8fc6048af08297b0E","name":"add<i32>","decl_file":0,"decl_line":1297,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$6offset17h9aab738203c12139E","name":"offset<i32>","decl_file":0,"decl_line":1699,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3ptr31_$LT$impl$u20$$BP$mut$u20$T$GT$3add17h1c4646404e229d01E","name":"add<i32>","decl_file":0,"decl_line":1935,"inline":"inlined"}]},{"tag":"subprogram","linkage_name":"_ZN4core3ptr13read_volatile17h1e7f4a0f3931d06fE","name":"read_volatile<f64>","decl_file":0,"decl_line":877,"inline":"inlined"}]},{"tag":"namespace","name":"slice","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h3d05e1e7c5a34a4eE","name":"get_unchecked<f64>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17hd702e50bc132092fE","name":"get_unchecked<f64,usize>","decl_file":9,"decl_line":333,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17he6733a3db6848236E","name":"get_unchecked_mut<f64>","decl_file":9,"decl_line":2441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h38c98a304db28423E","name":"get_unchecked_mut<f64,usize>","decl_file":9,"decl_line":360,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$13get_unchecked17h34a01c6222475af6E","name":"get_unchecked<i32>","decl_file":9,"decl_line":2436,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$13get_unchecked17h1a0d44fee1d02f24E","name":"get_unchecked<i32,usize>","decl_file":9,"decl_line":333,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN68_$LT$usize$u20$as$u20$core..slice..SliceIndex$LT$$u5b$T$u5d$$GT$$GT$17get_unchecked_mut17h2f7c7502ecf7983dE","name":"get_unchecked_mut<i32>","decl_file":9,"decl_line":2441,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core5slice29_$LT$impl$u20$$u5b$T$u5d$$GT$17get_unchecked_mut17h2ce01d0887fb97deE","name":"get_unchecked_mut<i32,usize>","decl_file":9,"decl_line":360,"inline":"inlined"}]}]},{"tag":"namespace","name":"iter","children":[{"tag":"namespace","name":"range","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core4iter5range102_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..RangeInclusive$LT$A$GT$$GT$4next17h40c6324f2e149fa8E","name":"next<usize>","decl_file":32,"decl_line":340,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter5range111_$LT$impl$u20$core..iter..traits..DoubleEndedIterator$u20$for$u20$core..ops..range..RangeInclusive$LT$A$GT$$GT$9next_back17h567b930bbfce2640E","name":"next_back<usize>","decl_file":32,"decl_line":414,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core4iter5range93_$LT$impl$u20$core..iter..iterator..Iterator$u20$for$u20$core..ops..range..Range$LT$A$GT$$GT$4next17h7ad1d60e326153b6E","name":"next<usize>","decl_file":32,"decl_line":221,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN49_$LT$usize$u20$as$u20$core..iter..range..Step$GT$7sub_one17h4f68a7ccf85a7134E","name":"sub_one","decl_file":32,"decl_line":68,"inline":"inlined"}]}]},{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN75_$LT$core..iter..Rev$LT$I$GT$$u20$as$u20$core..iter..iterator..Iterator$GT$4next17hda9b138c32f78b85E","name":"next<core::ops::range::RangeInclusive<usize>>","decl_file":52,"decl_line":427,"inline":"inlined"}]}]},{"tag":"namespace","name":"cmp","children":[{"tag":"namespace","name":"impls","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2lt17hc3ef3408f387f951E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls57_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$usize$GT$2le17h227c0f8a624dd4ebE","name":"le","decl_file":16,"decl_line":952,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls56_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i128$GT$2ge17hdcf8668484554a5fE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls56_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u128$GT$2lt17h58b83394b5aad07fE","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls56_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u128$GT$2gt17hde6c8e73b9854327E","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$i32$GT$2eq17h7b908e9c3c229a08E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i32$GT$2lt17h6d92ea56cd588f00E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i32$GT$2gt17h2dc2208b1cfae17aE","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$i64$GT$2eq17h96105218986b4deaE","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i64$GT$2lt17h091c5514f6f53ee9E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i64$GT$2gt17h2c43a491a08c8c64E","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$i128$GT$2eq17h40394465d814fdb7E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls56_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i128$GT$2lt17hc9d07e9fe3b34d1bE","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls56_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i128$GT$2gt17h201394efaddbfde7E","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u32$GT$2gt17h74db1ab853a055bfE","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i32$GT$2ge17h2736686b19d8dd87E","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u64$GT$2gt17h9c6c2e80daea9ef1E","name":"gt","decl_file":16,"decl_line":956,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u64$GT$2eq17h9747c05ea55ee715E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$i64$GT$2ge17h941bc1c41b2d0fb2E","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u32$GT$2ge17h7ce75cb279df60e5E","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u32$GT$2eq17hf272114aeef52bb7E","name":"eq","decl_file":16,"decl_line":870,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u32$GT$2lt17h7e12d4f9e603d863E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u32$GT$2ne17h63d98adfa00785cdE","name":"ne","decl_file":16,"decl_line":872,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u64$GT$2ge17h2e2bac71c525c88bE","name":"ge","decl_file":16,"decl_line":954,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls55_$LT$impl$u20$core..cmp..PartialOrd$u20$for$u20$u64$GT$2lt17h0fdb201cdf314e84E","name":"lt","decl_file":16,"decl_line":950,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3cmp5impls54_$LT$impl$u20$core..cmp..PartialEq$u20$for$u20$u64$GT$2ne17h60310ef0ee7691efE","name":"ne","decl_file":16,"decl_line":872,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"ops","children":[{"tag":"namespace","name":"range","children":[{"tag":"structure_type","name":"RangeInclusive<usize>","byte_size":12,"alignment":4,"children":[{"tag":"member","name":"start","type":"usize","alignment":4,"data_member_location":0},{"tag":"member","name":"end","type":"usize","alignment":4,"data_member_location":4},{"tag":"member","name":"is_empty","type":"Option<bool>","alignment":1,"data_member_location":8},{"tag":"subprogram","linkage_name":"_ZN52_$LT$core..ops..range..RangeInclusive$LT$Idx$GT$$GT$16compute_is_empty17ha497bf499b39660aE","name":"compute_is_empty<usize>","decl_file":38,"decl_line":545,"inline":"inlined"}]}]},{"tag":"namespace","name":"arith","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN47_$LT$usize$u20$as$u20$core..ops..arith..Sub$GT$3sub17h8984f53754ccbf53E","name":"sub","decl_file":34,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$core..ops..arith..AddAssign$GT$10add_assign17hbe1596c5c0b79238E","name":"add_assign","decl_file":34,"decl_line":693,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$i32$u20$as$u20$core..ops..arith..Sub$GT$3sub17h562a51904d673d2aE","name":"sub","decl_file":34,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$i64$u20$as$u20$core..ops..arith..Sub$GT$3sub17ha8c9d21145def2ddE","name":"sub","decl_file":34,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i128$u20$as$u20$core..ops..arith..Sub$GT$3sub17h89cb07991f8ff566E","name":"sub","decl_file":34,"decl_line":208,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i128$u20$as$u20$core..ops..arith..Neg$GT$3neg17hc504b25febecba1eE","name":"neg","decl_file":34,"decl_line":624,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$i64$u20$as$u20$core..ops..arith..AddAssign$GT$10add_assign17h03b148b7a04f1d82E","name":"add_assign","decl_file":34,"decl_line":693,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$core..ops..arith..AddAssign$GT$10add_assign17h1307f679ae299bc2E","name":"add_assign","decl_file":34,"decl_line":693,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$f32$u20$as$u20$core..ops..arith..MulAssign$GT$10mul_assign17h6d13a779482b8e32E","name":"mul_assign","decl_file":34,"decl_line":796,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$f32$u20$as$u20$core..ops..arith..Div$GT$3div17h884435a7bc506c4bE","name":"div","decl_file":34,"decl_line":469,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$f64$u20$as$u20$core..ops..arith..MulAssign$GT$10mul_assign17h8c30bb255af4d9b1E","name":"mul_assign","decl_file":34,"decl_line":796,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$f64$u20$as$u20$core..ops..arith..Div$GT$3div17h9181e75bf79ff60fE","name":"div","decl_file":34,"decl_line":469,"inline":"inlined"}]}]},{"tag":"namespace","name":"bit","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN44_$LT$u128$u20$as$u20$core..ops..bit..Not$GT$3not17h689895e787d899c8E","name":"not","decl_file":199,"decl_line":61,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u32$u20$as$u20$core..ops..bit..Shr$GT$3shr17h31dc4237107672f4E","name":"shr","decl_file":199,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$u32$u20$as$u20$core..ops..bit..BitAnd$GT$6bitand17ha07f1a935ca489adE","name":"bitand","decl_file":199,"decl_line":145,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN43_$LT$u32$u20$as$u20$core..ops..bit..Shl$GT$3shl17hd437dc662e5024deE","name":"shl","decl_file":199,"decl_line":405,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u32$u20$as$u20$core..ops..bit..BitAndAssign$GT$13bitand_assign17h2d0e40b0d2e65bf8E","name":"bitand_assign","decl_file":199,"decl_line":622,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$i32$u20$as$u20$core..ops..bit..Shr$LT$u32$GT$$GT$3shr17haf2bfbec4efba0a7E","name":"shr","decl_file":199,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i32$u20$as$u20$core..ops..bit..BitXor$GT$6bitxor17h71c6e34194e3147eE","name":"bitxor","decl_file":199,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$i64$u20$as$u20$core..ops..bit..Shr$LT$u32$GT$$GT$3shr17h2f3add5b20027cd5E","name":"shr","decl_file":199,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i64$u20$as$u20$core..ops..bit..BitXor$GT$6bitxor17h982451a06ac4cc8fE","name":"bitxor","decl_file":199,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN55_$LT$i128$u20$as$u20$core..ops..bit..Shr$LT$u32$GT$$GT$3shr17h1457e199bcf6ca45E","name":"shr","decl_file":199,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN47_$LT$i128$u20$as$u20$core..ops..bit..BitXor$GT$6bitxor17h4bb95384dd2de984E","name":"bitxor","decl_file":199,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$u64$u20$as$u20$core..ops..bit..Shr$LT$u32$GT$$GT$3shr17h1c0817324283dab5E","name":"shr","decl_file":199,"decl_line":514,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$u64$u20$as$u20$core..ops..bit..BitAnd$GT$6bitand17h35cbe89976abaf5fE","name":"bitand","decl_file":199,"decl_line":145,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN54_$LT$u64$u20$as$u20$core..ops..bit..Shl$LT$u32$GT$$GT$3shl17h2805b2234bc7b51eE","name":"shl","decl_file":199,"decl_line":405,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN52_$LT$u64$u20$as$u20$core..ops..bit..BitAndAssign$GT$13bitand_assign17h808e8546d0c50d01E","name":"bitand_assign","decl_file":199,"decl_line":622,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$u32$u20$as$u20$core..ops..bit..BitOr$GT$5bitor17h78b061edf8ae5a06E","name":"bitor","decl_file":199,"decl_line":229,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN45_$LT$u64$u20$as$u20$core..ops..bit..BitOr$GT$5bitor17h96e7ef584465df34E","name":"bitor","decl_file":199,"decl_line":229,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i32$u20$as$u20$core..ops..bit..BitAnd$GT$6bitand17h739a5879b9ae2a14E","name":"bitand","decl_file":199,"decl_line":145,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$i64$u20$as$u20$core..ops..bit..BitAnd$GT$6bitand17hf85e4d8e81766256E","name":"bitand","decl_file":199,"decl_line":145,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$u32$u20$as$u20$core..ops..bit..BitXor$GT$6bitxor17h66095b1322da9a05E","name":"bitxor","decl_file":199,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN60_$LT$u32$u20$as$u20$core..ops..bit..ShlAssign$LT$i32$GT$$GT$10shl_assign17hd8af5682bb1164fbE","name":"shl_assign","decl_file":199,"decl_line":768,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u32$u20$as$u20$core..ops..bit..BitOrAssign$GT$12bitor_assign17h2f1fdc9c3ade5f59E","name":"bitor_assign","decl_file":199,"decl_line":671,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN46_$LT$u64$u20$as$u20$core..ops..bit..BitXor$GT$6bitxor17h915689f27238a8eaE","name":"bitxor","decl_file":199,"decl_line":316,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN60_$LT$u64$u20$as$u20$core..ops..bit..ShlAssign$LT$i32$GT$$GT$10shl_assign17hb8966bac4d5d6b94E","name":"shl_assign","decl_file":199,"decl_line":768,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN51_$LT$u64$u20$as$u20$core..ops..bit..BitOrAssign$GT$12bitor_assign17hb064c287b000f336E","name":"bitor_assign","decl_file":199,"decl_line":671,"inline":"inlined"}]}]}]},{"tag":"namespace","name":"option","children":[{"tag":"structure_type","name":"Option<bool>","byte_size":1,"alignment":1,"children":[{"tag":"variant_part","discr":340659,"children":[{"tag":"member","type":"u8","alignment":1,"data_member_location":0,"artificial":true},{"tag":"variant","discr_value":2,"children":[{"tag":"member","name":"None","type":"None","alignment":1,"data_member_location":0}]},{"tag":"variant","children":[{"tag":"member","name":"Some","type":"Some","alignment":1,"data_member_location":0}]}]},{"tag":"structure_type","name":"None","byte_size":1,"alignment":1},{"tag":"structure_type","name":"Some","byte_size":1,"alignment":1,"children":[{"tag":"member","name":"__0","type":"bool","alignment":1,"data_member_location":0}]}]}]},{"tag":"namespace","name":"num","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15overflowing_add17h66ca9d048dce6ceeE","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$12wrapping_add17h3ea7c66fea5b380cE","name":"wrapping_add","decl_file":8,"decl_line":2877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$12wrapping_mul17hc5ddd0889789ca63E","name":"wrapping_mul","decl_file":8,"decl_line":2924,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$12wrapping_add17h991dedb2a4d93eebE","name":"wrapping_add","decl_file":8,"decl_line":2877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$11checked_div17h3d745fb1bcad7ebbE","name":"checked_div","decl_file":8,"decl_line":666,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$11checked_div17h72fccf9792eee589E","name":"checked_div","decl_file":8,"decl_line":666,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$12wrapping_mul17hc728686b51dce9d2E","name":"wrapping_mul","decl_file":8,"decl_line":1056,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$11checked_div17hd0c1db232c5fadbbE","name":"checked_div","decl_file":8,"decl_line":666,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$12wrapping_mul17h925f8f3a0e6dc693E","name":"wrapping_mul","decl_file":8,"decl_line":2924,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$12wrapping_mul17h7fed6b3cf0d710c4E","name":"wrapping_mul","decl_file":8,"decl_line":1056,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$12wrapping_add17hbd3e23b571b89612E","name":"wrapping_add","decl_file":8,"decl_line":1009,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$11checked_div17hddafd872e990d60aE","name":"checked_div","decl_file":8,"decl_line":2589,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$12wrapping_mul17h54571f2fecfee4e8E","name":"wrapping_mul","decl_file":8,"decl_line":2924,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$12wrapping_sub17h1a9dd2393e92c829E","name":"wrapping_sub","decl_file":8,"decl_line":1033,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$11checked_div17h61bb943ee75afe49E","name":"checked_div","decl_file":8,"decl_line":2589,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$12wrapping_sub17h0b55ce027f2b6f41E","name":"wrapping_sub","decl_file":8,"decl_line":1033,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_div17h322076d1988d2871E","name":"checked_div","decl_file":8,"decl_line":2589,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$11checked_rem17h404e68f6cc06d874E","name":"checked_rem","decl_file":8,"decl_line":2636,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$11checked_rem17h723a785fb1f051aeE","name":"checked_rem","decl_file":8,"decl_line":2636,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$12wrapping_mul17h3b7b10f0f3651b80E","name":"wrapping_mul","decl_file":8,"decl_line":1056,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$12wrapping_sub17h86ee3b6b314da0f9E","name":"wrapping_sub","decl_file":8,"decl_line":1033,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$11checked_rem17h948422afb50b9c5aE","name":"checked_rem","decl_file":8,"decl_line":2636,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$13leading_zeros17hca621d001bea7388E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$12wrapping_sub17h3d292b0f7aba09a4E","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num64_$LT$impl$u20$core..convert..From$LT$u32$GT$$u20$for$u20$u64$GT$4from17ha74e3344875e4dafE","name":"from","decl_file":8,"decl_line":4817,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$15is_power_of_two17he0b3daf4de313fa5E","name":"is_power_of_two","decl_file":8,"decl_line":3551,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$14trailing_zeros17h39a966dd36d6cca4E","name":"trailing_zeros","decl_file":8,"decl_line":2279,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$12wrapping_sub17h7edcf3e4625cae22E","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$13leading_zeros17hfd479c54b9990532E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$15is_power_of_two17hf7bf669457f58bb4E","name":"is_power_of_two","decl_file":8,"decl_line":3551,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$14trailing_zeros17hdf9e459448e3ed2bE","name":"trailing_zeros","decl_file":8,"decl_line":2279,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$12wrapping_sub17hec282bb7195289e0E","name":"wrapping_sub","decl_file":8,"decl_line":2900,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$15overflowing_add17h9bd1317d1913fe35E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$12wrapping_add17h38bd2965f12c62a4E","name":"wrapping_add","decl_file":8,"decl_line":1009,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$12wrapping_shl17hba7f25b36316a905E","name":"wrapping_shl","decl_file":8,"decl_line":1220,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$15overflowing_add17hc6e05ec943b4c298E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$11checked_rem17h5b09877e23a5ded8E","name":"checked_rem","decl_file":8,"decl_line":719,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$13leading_zeros17h5e4246a3af0574afE","name":"leading_zeros","decl_file":8,"decl_line":327,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$12wrapping_shl17h88bf0d9c4ac360c8E","name":"wrapping_shl","decl_file":8,"decl_line":1220,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$15overflowing_add17h8423313cc7fb3a41E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$11checked_rem17hdd56dbab8e64b91bE","name":"checked_rem","decl_file":8,"decl_line":719,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$13leading_zeros17h65efd149139c90d5E","name":"leading_zeros","decl_file":8,"decl_line":327,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$12wrapping_add17h7b96240ea57163cbE","name":"wrapping_add","decl_file":8,"decl_line":2877,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$15overflowing_add17h7a016696c662fe58E","name":"overflowing_add","decl_file":8,"decl_line":3163,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$12wrapping_add17ha7d2a2f54f7d77b2E","name":"wrapping_add","decl_file":8,"decl_line":1009,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$12wrapping_shl17h5cd92d05f20bf1a1E","name":"wrapping_shl","decl_file":8,"decl_line":1220,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$15overflowing_add17h25711300b3eb5a53E","name":"overflowing_add","decl_file":8,"decl_line":1346,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$11checked_rem17ha16e143c4ae05d9fE","name":"checked_rem","decl_file":8,"decl_line":719,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$13leading_zeros17h59a836c365cf80b0E","name":"leading_zeros","decl_file":8,"decl_line":2258,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$i128$GT$13leading_zeros17h55b0d9b84dd7ed2cE","name":"leading_zeros","decl_file":8,"decl_line":327,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u32$GT$12wrapping_shl17h2cf133d7f4b418dfE","name":"wrapping_shl","decl_file":8,"decl_line":3068,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$u64$GT$12wrapping_shl17h787becd39fe61252E","name":"wrapping_shl","decl_file":8,"decl_line":3068,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num22_$LT$impl$u20$u128$GT$12wrapping_shl17h951829fb37617d6fE","name":"wrapping_shl","decl_file":8,"decl_line":3068,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$15overflowing_neg17h4818fe07a2111f21E","name":"overflowing_neg","decl_file":8,"decl_line":1563,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i32$GT$12wrapping_neg17h21a3c6f03d6c125fE","name":"wrapping_neg","decl_file":8,"decl_line":1194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$15overflowing_neg17hdd67ac24b25262b7E","name":"overflowing_neg","decl_file":8,"decl_line":1563,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num21_$LT$impl$u20$i64$GT$12wrapping_neg17ha6bb2b2be60be963E","name":"wrapping_neg","decl_file":8,"decl_line":1194,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3num64_$LT$impl$u20$core..convert..From$LT$i32$GT$$u20$for$u20$f64$GT$4from17h9420e7734be12a37E","name":"from","decl_file":8,"decl_line":4817,"inline":"inlined"}]}]},{"tag":"namespace","name":"f32","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$7to_bits17h7ae4a2df075644e0E","name":"to_bits","decl_file":134,"decl_line":429,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$9from_bits17h3b81a8c027d590a3E","name":"from_bits","decl_file":134,"decl_line":473,"inline":"inlined"},{"tag":"subprogram","linkage_name":"_ZN4core3f3221_$LT$impl$u20$f32$GT$6is_nan17h9bc679c34a464fb8E","name":"is_nan","decl_file":134,"decl_line":170,"inline":"inlined"}]}]},{"tag":"namespace","name":"convert","children":[{"tag":"namespace","name":"{{impl}}","children":[{"tag":"subprogram","linkage_name":"_ZN50_$LT$T$u20$as$u20$core..convert..Into$LT$U$GT$$GT$4into17h2a94774572c44f2fE","name":"into<i32,f64>","decl_file":1,"decl_line":455,"inline":"inlined"}]}]}]},{"tag":"base_type","name":"usize","encoding":"unsigned","byte_size":4},{"tag":"base_type","name":"bool","encoding":"boolean","byte_size":1}]}],"code_section_offset":572}}