Rust.rs

// https://www.rust-lang.org/
// https://doc.rust-lang.org/book/
// https://doc.rust-lang.org/reference/index.html
// Rust 1.91 https://doc.rust-lang.org/std/index.html

//! Keywords		===========================================================
// https://doc.rust-lang.org/std/index.html#keywords
// https://doc.rust-lang.org/reference/keywords.html
as async await
break
const continue crate
dyn
else enum extern
fn for
gen // 2024
if impl in
let loop
match mod move mut
pub
ref return
static struct
trait type
union unsafe use
where while

false self Self super true

// Weak keywords
//raw safe

//! Reserved Keywords	=======================================================
// https://doc.rust-lang.org/reference/keywords.html#reserved-keywords
abstract
become box
do
final
macro
override
priv
typeof try
unsized
virtual
yield

//! Primitive Types		=======================================================
// https://doc.rust-lang.org/std/index.html#primitives
array
bool
char
f16 f32 f64 f128
i8 i16 i32 i64 i128 isize
pointer
reference
slice str
tuple
u8 u16 u32 u64 u128 unit usize
never

//! Macros			===========================================================
// https://doc.rust-lang.org/reference/macros.html
// https://doc.rust-lang.org/std/index.html#macros
macro_rules!
assert!()
assert_eq!()
assert_ne!()
cfg!()
column!()
compile_error!()
concat!()
dbg!()
debug_assert!()
debug_assert_eq!()
debug_assert_ne!()
env!()
eprint!()
eprintln!()
file!()
format!()
format_args!()
include!()
include_bytes!()
include_str!()
is_x86_feature_detected!()
line!()
matches!()
module_path!()
option_env!()
panic!()
print!()
println!()
stringify!()
thread_local!()
unimplemented!()
unreachable!()
vec!()
write!()
writeln!()
cfg_select!()
concat_bytes!()
const_format_args!()
format_args_nl!()
log_syntax!()
trace_macros!()

//! Attribute		===========================================================
// https://doc.rust-lang.org/reference/attributes.html#built-in-attributes-index
// Conditional compilation
#[cfg(target_arch, target_feature, target_os, target_family, unix, windows, target_env, target_abi, target_endian, target_pointer_width, target_vendor,
target_has_atomic, test, debug_assertions, proc_macro, panic)]
#[cfg(all(), any(), not())]
#[cfg_attr()]
// Testing
#[test]
#[ignore]
#[should_panic(expected)]
// Derive
#[derive()]
// Macros
#[macro_export]
#[macro_export(local_inner_macros)]
#[macro_use]
#[macro_use(lazy_static)]
#[proc_macro]
#[proc_macro_derive()]
#[proc_macro_attribute]
// Diagnostics
#[allow()]
#[expect()]
#[warn()]
#[deny()]
#[forbid()]
#[deprecated]
#[deprecated()]
#[must_use]
// ABI, linking, symbols, and FFI
#[link(name, kind)]
#[link_name]
#[link_ordinal()]
#[no_link]
#[repr(C, align(), packed())]
#![crate_type]
#![no_main]
#[export_name]
#[link_section]
#[no_mangle]
#[used]
#![crate_name]
// Code generation
#[inline]
#[inline(always, never)]
#[cold]
#[naked]
#[no_builtins]
#[target_feature(enable)]
#[track_caller]
#[instruction_set()]
// Documentation
#[doc]
// Preludes
#![no_std]
#![no_implicit_prelude]
// Modules
#[path]
// Limits
#![recursion_limit]
#![type_length_limit]
// Runtime
#[panic_handler]
#[global_allocator]
#![windows_subsystem]
// Features
#[feature()]
// Type System
#[non_exhaustive]
// Debugger
#![debugger_visualizer()]
#[collapse_debuginfo()]

//! Modules			===========================================================
// https://doc.rust-lang.org/std/index.html#modules

mod std::alloc {
	struct Layout {
		fn from_size_align(size: usize, align: usize) -> Result<Layout, LayoutErr>
		const unsafe fn from_size_align_unchecked(size: usize, align: usize) -> Layout
		fn size(&self) -> usize
		fn align(&self) -> usize
		fn new<T>() -> Layout
		fn for_value<T>(t: &T) -> Layout
	}
	struct LayoutErr;
	struct System;
	unsafe trait GlobalAlloc {
		unsafe fn alloc(&self, layout: Layout) -> *mut u8
		unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout)
		unsafe fn alloc_zeroed(&self, layout: Layout) -> *mut u8
		unsafe fn realloc(&self, ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8
	}
	unsafe fn alloc(layout: Layout) -> *mut u8
	unsafe fn alloc_zeroed(layout: Layout) -> *mut u8
	unsafe fn dealloc(ptr: *mut u8, layout: Layout)
	fn handle_alloc_error(layout: Layout) -> !
	unsafe fn realloc(ptr: *mut u8, layout: Layout, new_size: usize) -> *mut u8
}

mod std::any {
	struct TypeId {
		fn of<T>() -> TypeId
	}
	trait Any: 'static {
		fn type_id(&self) -> TypeId
		fn is<T>(&self) -> bool
		fn downcast_ref<T>(&self) -> Option<&T>
		fn downcast_mut<T>(&mut self) -> Option<&mut T>
	}
}

mod std::array {
	struct TryFromSliceError;
}

mod std::ascii {
	struct EscapeDefault {}
	fn escape_default(c: u8) -> EscapeDefault
}

mod std::borrow {
	enum Cow<'a, B> {
		Borrowed(&'a B),
		Owned(<B as ToOwned>::Owned),
		fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned
		fn into_owned(self) -> <B as ToOwned>::Owned
	}
	trait Borrow<Borrowed> {
		fn borrow(&self) -> &Borrowed
	}
	trait BorrowMut<Borrowed>: Borrow<Borrowed> {
		fn borrow_mut(&mut self) -> &mut Borrowed
	}
	trait ToOwned {
		type Owned: Borrow<Self>;
		fn to_owned(&self) -> Self::Owned
	}
}

mod std::boxed {
	struct Box<T> {
		fn new(x: T) -> Box<T>
		fn pin(x: T) -> Pin<Box<T>>
		unsafe fn from_raw(raw: *mut T) -> Box<T>
		fn into_raw(b: Box<T>) -> *mut T
		fn leak<'a>(b: Box<T>) -> &'a mut T
		fn downcast<T>(self) -> Result<Box<T>, Box<dyn Any + 'static>>
	}
}

mod std::cell {
	struct BorrowError;
	struct BorrowMutError
	struct Cell<T> {
		fn get(&self) -> T
		const fn new(value: T) -> Cell<T>
		fn set(&self, val: T)
		fn swap(&self, other: &Cell<T>)
		fn replace(&self, val: T) -> T
		fn into_inner(self) -> T
		const fn as_ptr(&self) -> *mut T
		fn get_mut(&mut self) -> &mut T
		fn from_mut(t: &mut T) -> &Cell<T>
		fn take(&self) -> T
		fn as_slice_of_cells(&self) -> &[Cell<T>]
	}
	struct Ref<'b, T> {
		fn clone(orig: &Ref<'b, T>) -> Ref<'b, T>
		fn map<U, F>(orig: Ref<'b, T>, f: F) -> Ref<'b, U>
		fn map_split<U, V, F>(orig: Ref<'b, T>, f: F) -> (Ref<'b, U>, Ref<'b, V>)
	}
	struct RefCell<T> {
		const fn new(value: T) -> RefCell<T>
		fn into_inner(self) -> T
		fn replace(&self, t: T) -> T
		fn replace_with<F>(&self, f: F) -> T
		fn swap(&self, other: &RefCell<T>)
		fn borrow(&self) -> Ref<T>
		fn try_borrow(&self) -> Result<Ref<T>, BorrowError>
		fn borrow_mut(&self) -> RefMut<T>
		fn try_borrow_mut(&self) -> Result<RefMut<T>, BorrowMutError>
		fn as_ptr(&self) -> *mut T
		fn get_mut(&mut self) -> &mut T
		unsafe fn try_borrow_unguarded(&self) -> Result<&T, BorrowError>
	}
	struct RefMut<'b, T> {
		fn map<U, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U>
		fn map_split<U, V, F>(orig: RefMut<'b, T>, f: F) -> (RefMut<'b, U>, RefMut<'b, V>)
	}
	struct UnsafeCell<T> {
		const fn new(value: T) -> UnsafeCell<T>
		fn into_inner(self) -> T
		const fn get(&self) -> *mut T
	}
}

mod std::char {
	// Primitive Type
	fn is_digit(self, radix: u32) -> bool
	fn to_digit(self, radix: u32) -> Option<u32>
	fn escape_unicode(self) -> EscapeUnicode
	fn escape_debug(self) -> EscapeDebug
	fn escape_default(self) -> EscapeDefault
	fn len_utf8(self) -> usize
	fn len_utf16(self) -> usize
	fn encode_utf8(self, dst: &mut [u8]) -> &mut str
	fn encode_utf16(self, dst: &mut [u16]) -> &mut [u16]
	fn is_alphabetic(self) -> bool
	fn is_lowercase(self) -> bool
	fn is_uppercase(self) -> bool
	fn is_whitespace(self) -> bool
	fn is_alphanumeric(self) -> bool
	fn is_control(self) -> bool
	fn is_numeric(self) -> bool
	fn to_lowercase(self) -> ToLowercase
	fn to_uppercase(self) -> ToUppercase
	const fn is_ascii(&self) -> bool
	fn to_ascii_uppercase(&self) -> char
	fn to_ascii_lowercase(&self) -> char
	fn eq_ignore_ascii_case(&self, other: &char) -> bool
	fn make_ascii_uppercase(&mut self)
	fn make_ascii_lowercase(&mut self)
	fn is_ascii_alphabetic(&self) -> bool
	fn is_ascii_uppercase(&self) -> bool
	fn is_ascii_lowercase(&self) -> bool
	fn is_ascii_alphanumeric(&self) -> bool
	fn is_ascii_digit(&self) -> bool
	fn is_ascii_hexdigit(&self) -> bool
	fn is_ascii_punctuation(&self) -> bool
	fn is_ascii_graphic(&self) -> bool
	fn is_ascii_whitespace(&self) -> bool
	fn is_ascii_control(&self) -> bool

	// Module
	struct CharTryFromError;
	struct DecodeUtf16<I> {}
	struct DecodeUtf16Error {
		fn unpaired_surrogate(&self) -> u16
	}
	struct EscapeDebug;
	struct EscapeDefault;
	struct EscapeUnicode;
	struct ParseCharError;
	struct ToLowercase;
	struct ToUppercase;
	const MAX: char
	const REPLACEMENT_CHARACTER: char
	fn decode_utf16<I>(iter: I) -> DecodeUtf16<<I as IntoIterator>::IntoIter>
	fn from_digit(num: u32, radix: u32) -> Option<char>
	fn from_u32(i: u32) -> Option<char>
	unsafe fn from_u32_unchecked(i: u32) -> char
}

mod std::clone {
	trait Clone {
		fn clone(&self) -> Self
		fn clone_from(&mut self, source: &Self)
	}
}

mod std::cmp {
	struct Reverse<T>(pub T);
	enum Ordering {
		Less,
		Equal,
		Greater,
		fn reverse(self) -> Ordering
		fn then(self, other: Ordering) -> Ordering
		fn then_with<F>(self, f: F) -> Ordering
	}
	trait Eq: PartialEq<Self> {}
	trait Ord: Eq + PartialOrd<Self> {
		fn cmp(&self, other: &Self) -> Ordering
		fn max(self, other: Self) -> Self
		fn min(self, other: Self) -> Self
	}
	trait PartialEq<Rhs = Self> {
		fn eq(&self, other: &Rhs) -> bool
		fn ne(&self, other: &Rhs) -> bool
	}
	trait PartialOrd<Rhs = Self>: PartialEq<Rhs> {
		fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>
		fn lt(&self, other: &Rhs) -> bool
		fn le(&self, other: &Rhs) -> bool
		fn gt(&self, other: &Rhs) -> bool
		fn ge(&self, other: &Rhs) -> bool
	}
	fn max<T>(v1: T, v2: T) -> T
	fn min<T>(v1: T, v2: T) -> T
}

mod std::collections {
	struct BTreeMap<K, V> {
		fn new() -> BTreeMap<K, V>
		fn clear(&mut self)
		fn get<Q>(&self, key: &Q) -> Option<&V>
		fn contains_key<Q>(&self, key: &Q) -> bool
		fn get_mut<Q>(&mut self, key: &Q) -> Option<&mut V>
		fn insert(&mut self, key: K, value: V) -> Option<V>
		fn remove<Q>(&mut self, key: &Q) -> Option<V>
		fn append(&mut self, other: &mut BTreeMap<K, V>)
		fn range<T, R>(&self, range: R) -> Range<K, V>
		fn range_mut<T, R>(&mut self, range: R) -> RangeMut<K, V>
		fn entry(&mut self, key: K) -> Entry<K, V>
		fn split_off<Q>(&mut self, key: &Q) -> BTreeMap<K, V>
		fn iter(&self) -> Iter<K, V>
		fn iter_mut(&mut self) -> IterMut<K, V>
		fn keys(&'a self) -> Keys<'a, K, V>
		fn values(&'a self) -> Values<'a, K, V>
		fn values_mut(&mut self) -> ValuesMut<K, V>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
	}
	struct BTreeSet<T> {
		fn new() -> BTreeSet<T>
		fn range<K, R>(&self, range: R) -> Range<T>
		fn difference(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T>
		fn symmetric_difference(&'a self, other: &'a BTreeSet<T>) -> SymmetricDifference<'a, T>
		fn intersection(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T>
		fn union(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T>
		fn clear(&mut self)
		fn contains<Q>(&self, value: &Q) -> bool
		fn get<Q>(&self, value: &Q) -> Option<&T>
		fn is_disjoint(&self, other: &BTreeSet<T>) -> bool
		fn is_subset(&self, other: &BTreeSet<T>) -> bool
		fn is_superset(&self, other: &BTreeSet<T>) -> bool
		fn insert(&mut self, value: T) -> bool
		fn replace(&mut self, value: T) -> Option<T>
		fn remove<Q>(&mut self, value: &Q) -> bool
		fn take<Q>(&mut self, value: &Q) -> Option<T>
		fn append(&mut self, other: &mut BTreeSet<T>)
		fn split_off<Q>(&mut self, key: &Q) -> BTreeSet<T>
		fn iter(&self) -> Iter<T>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
	}
	struct BinaryHeap<T> {
		fn new() -> BinaryHeap<T>
		fn with_capacity(capacity: usize) -> BinaryHeap<T>
		fn peek_mut(&mut self) -> Option<PeekMut<T>>
		fn pop(&mut self) -> Option<T>
		fn push(&mut self, item: T)
		fn into_sorted_vec(self) -> Vec<T>
		fn append(&mut self, other: &mut BinaryHeap<T>)
		fn iter(&self) -> Iter<T>
		fn peek(&self) -> Option<&T>
		fn capacity(&self) -> usize
		fn reserve_exact(&mut self, additional: usize)
		fn reserve(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn into_vec(self) -> Vec<T>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn drain(&mut self) -> Drain<T>
		fn clear(&mut self)
	}
	struct HashMap<K, V, S = RandomState> {
		fn new() -> HashMap<K, V, RandomState>
		fn with_capacity(capacity: usize) -> HashMap<K, V, RandomState>
		fn capacity(&self) -> usize
		fn keys(&self) -> Keys<K, V>
		fn values(&self) -> Values<K, V>
		fn values_mut(&mut self) -> ValuesMut<K, V>
		fn iter(&self) -> Iter<K, V>
		fn iter_mut(&mut self) -> IterMut<K, V>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn drain(&mut self) -> Drain<K, V>
		fn clear(&mut self)
		fn with_hasher(hash_builder: S) -> HashMap<K, V, S>
		fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S>
		fn hasher(&self) -> &S
		fn reserve(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn entry(&mut self, key: K) -> Entry<K, V>
		fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
		fn contains_key<Q: ?Sized>(&self, k: &Q) -> bool
		fn get_mut<Q: ?Sized>(&mut self, k: &Q) -> Option<&mut V>
		fn insert(&mut self, k: K, v: V) -> Option<V>
		fn remove<Q: ?Sized>(&mut self, k: &Q) -> Option<V>
		fn remove_entry<Q: ?Sized>(&mut self, k: &Q) -> Option<(K, V)>
		fn retain<F>(&mut self, f: F)
	}
	struct HashSet<T, S = RandomState> {
		fn new() -> HashSet<T, RandomState>
		fn with_capacity(capacity: usize) -> HashSet<T, RandomState>
		fn capacity(&self) -> usize
		fn iter(&self) -> Iter<T>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn drain(&mut self) -> Drain<T>
		fn clear(&mut self)
		fn with_hasher(hasher: S) -> HashSet<T, S>
		fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S>
		fn hasher(&self) -> &S
		fn reserve(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S>
		fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, S>) -> SymmetricDifference<'a, T, S>
		fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S>
		fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S>
		fn contains<Q: ?Sized>(&self, value: &Q) -> bool
		fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
		fn is_disjoint(&self, other: &HashSet<T, S>) -> bool
		fn is_subset(&self, other: &HashSet<T, S>) -> bool
		fn is_superset(&self, other: &HashSet<T, S>) -> bool
		fn insert(&mut self, value: T) -> bool
		fn replace(&mut self, value: T) -> Option<T>
		fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
		fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
		fn retain<F>(&mut self, f: F)
	}
	struct LinkedList<T> {
		fn new() -> LinkedList<T>
		fn append(&mut self, other: &mut LinkedList<T>)
		fn iter(&self) -> Iter<T>
		fn iter_mut(&mut self) -> IterMut<T>
		fn is_empty(&self) -> bool
		fn len(&self) -> usize
		fn clear(&mut self)
		fn contains(&self, x: &T) -> bool
		fn front(&self) -> Option<&T>
		fn front_mut(&mut self) -> Option<&mut T>
		fn back(&self) -> Option<&T>
		fn back_mut(&mut self) -> Option<&mut T>
		fn push_front(&mut self, elt: T)
		fn pop_front(&mut self) -> Option<T>
		fn push_back(&mut self, elt: T)
		fn pop_back(&mut self) -> Option<T>
		fn split_off(&mut self, at: usize) -> LinkedList<T>
	}
	struct VecDeque<T> {
		fn new() -> VecDeque<T>
		fn with_capacity(capacity: usize) -> VecDeque<T>
		fn get(&self, index: usize) -> Option<&T>
		fn get_mut(&mut self, index: usize) -> Option<&mut T>
		fn swap(&mut self, i: usize, j: usize)
		fn capacity(&self) -> usize
		fn reserve_exact(&mut self, additional: usize)
		fn reserve(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn truncate(&mut self, len: usize)
		fn iter(&self) -> Iter<T>
		fn iter_mut(&mut self) -> IterMut<T>
		fn as_slices(&self) -> (&[T], &[T])
		fn as_mut_slices(&mut self) -> (&mut [T], &mut [T])
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn drain<R>(&mut self, range: R) -> Drain<T>
		fn clear(&mut self)
		fn contains(&self, x: &T) -> bool
		fn front(&self) -> Option<&T>
		fn front_mut(&mut self) -> Option<&mut T>
		fn back(&self) -> Option<&T>
		fn back_mut(&mut self) -> Option<&mut T>
		fn pop_front(&mut self) -> Option<T>
		fn push_front(&mut self, value: T)
		fn push_back(&mut self, value: T)
		fn pop_back(&mut self) -> Option<T>
		fn swap_remove_back(&mut self, index: usize) -> Option<T>
		fn swap_remove_front(&mut self, index: usize) -> Option<T>
		fn insert(&mut self, index: usize, value: T)
		fn remove(&mut self, index: usize) -> Option<T>
		fn split_off(&mut self, at: usize) -> VecDeque<T>
		fn append(&mut self, other: &mut VecDeque<T>)
		fn retain<F>(&mut self, f: F)
		fn resize_with<impl FnMut() -> T>(&mut self, new_len: usize, generator: impl FnMut() -> T)
		fn rotate_left(&mut self, mid: usize)
		fn rotate_right(&mut self, k: usize)
		fn resize(&mut self, new_len: usize, value: T)
	}
}

mod std::convert {
	enum Infallible;
	trait AsMut<T> {
		fn as_mut(&mut self) -> &mut T
	}
	trait AsRef<T> {
		fn as_ref(&self) -> &T
	}
	trait From<T> {
		fn from(T) -> Self
	}
	trait Into<T> {
		fn into(self) -> T
	}
	trait TryFrom<T> {
		type Error;
		fn try_from(value: T) -> Result<Self, Self::Error>
	}
	trait TryInto<T> {
		type Error;
		 fn try_into(self) -> Result<T, Self::Error>
	}
	const fn identity<T>(x: T) -> T
}

mod std::default {
	trait Default {
		fn default() -> Self;
	}
}

mod std::env {
	mod consts {
		const ARCH: &str
		const DLL_EXTENSION: &str
		const DLL_PREFIX: &str
		const DLL_SUFFIX: &str
		const EXE_EXTENSION: &str
		const EXE_SUFFIX: &str
		const FAMILY: &str
		const OS: &str
	}
	struct Args;
	struct ArgsOs;
	struct JoinPathsError;
	struct SplitPaths<'a>;
	struct Vars;
	struct VarsOs;
	enum VarError {
		NotPresent,
		NotUnicode(OsString),
	}
	fn args() -> Args
	fn args_os() -> ArgsOs
	fn current_dir() -> Result<PathBuf>
	fn current_exe() -> Result<PathBuf>
	fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
	fn remove_var<K: AsRef<OsStr>>(k: K)
	fn set_current_dir<P: AsRef<Path>>(path: P) -> Result<()>
	fn set_var<K: AsRef<OsStr>, V: AsRef<OsStr>>(k: K, v: V)
	fn split_paths<T: AsRef<OsStr> + ?Sized>(unparsed: &T) -> SplitPaths
	fn temp_dir() -> PathBuf
	fn var<K: AsRef<OsStr>>(key: K) -> Result<String, VarError>
	fn var_os<K: AsRef<OsStr>>(key: K) -> Option<OsString>
	fn vars() -> Vars
	fn vars_os() -> VarsOs
}

mod std::error {
	trait Error: Debug + Display {
		fn description(&self) -> &str
		fn source(&self) -> Option<&(dyn Error + 'static)>
	}
}

mod std::f32 {
	const DIGITS: u32
	const EPSILON: f32
	const INFINITY: f32
	const MANTISSA_DIGITS: u32
	const MAX: f32
	const MAX_10_EXP: i32
	const MAX_EXP: i32
	const MIN: f32
	const MIN_10_EXP: i32
	const MIN_EXP: i32
	const MIN_POSITIVE: f32
	const NAN: f32
	const NEG_INFINITY: f32
	const RADIX: u32
}

mod std::f64 {
	// Primitive Type
	fn floor(self) -> f64
	fn ceil(self) -> f64
	fn round(self) -> f64
	fn trunc(self) -> f64
	fn fract(self) -> f64
	fn abs(self) -> f64
	fn signum(self) -> f64
	fn copysign(self, sign: f64) -> f64
	fn mul_add(self, a: f64, b: f64) -> f64
	fn div_euclid(self, rhs: f64) -> f64
	fn rem_euclid(self, rhs: f64) -> f64
	fn powi(self, n: i32) -> f64
	fn powf(self, n: f64) -> f64
	fn sqrt(self) -> f64
	fn exp(self) -> f64
	fn exp2(self) -> f64
	fn ln(self) -> f64
	fn log(self, base: f64) -> f64
	fn log2(self) -> f64
	fn log10(self) -> f64
	fn cbrt(self) -> f64
	fn hypot(self, other: f64) -> f64
	fn sin(self) -> f64
	fn cos(self) -> f64
	fn tan(self) -> f64
	fn asin(self) -> f64
	fn acos(self) -> f64
	fn atan(self) -> f64
	fn atan2(self, other: f64) -> f64
	fn sin_cos(self) -> (f64, f64)
	fn exp_m1(self) -> f64
	fn ln_1p(self) -> f64
	fn sinh(self) -> f64
	fn cosh(self) -> f64
	fn tanh(self) -> f64
	fn asinh(self) -> f64
	fn acosh(self) -> f64
	fn atanh(self) -> f64
	fn is_nan(self) -> bool
	fn is_infinite(self) -> bool
	fn is_finite(self) -> bool
	fn is_normal(self) -> bool
	fn classify(self) -> FpCategory
	fn is_sign_positive(self) -> bool
	fn is_sign_negative(self) -> bool
	fn recip(self) -> f64
	fn to_degrees(self) -> f64
	fn to_radians(self) -> f64
	fn max(self, other: f64) -> f64
	fn min(self, other: f64) -> f64
	fn to_bits(self) -> u64
	fn from_bits(v: u64) -> f64

	// Module
	const DIGITS: u32
	const EPSILON: f64
	const INFINITY: f64
	const MANTISSA_DIGITS: u32
	const MAX: f64
	const MAX_10_EXP: i32
	const MAX_EXP: i32
	const MIN: f64
	const MIN_10_EXP: i32
	const MIN_EXP: i32
	const MIN_POSITIVE: f64
	const NAN: f64
	const NEG_INFINITY: f64
	const RADIX: u32
}

mod std::ffi {
	struct CStr {
		unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr
		fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError>
		const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr
		const fn as_ptr(&self) -> *const c_char
		fn to_bytes(&self) -> &[u8]
		fn to_bytes_with_nul(&self) -> &[u8]
		fn to_str(&self) -> Result<&str, Utf8Error>
		fn to_string_lossy(&self) -> Cow<str>
		fn into_c_string(self: Box<CStr>) -> CString
	}
	struct CString {
		fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError>
		unsafe fn from_vec_unchecked(v: Vec<u8>) -> CString
		unsafe fn from_raw(ptr: *mut c_char) -> CString
		fn into_raw(self) -> *mut c_char
		fn into_string(self) -> Result<String, IntoStringError>
		fn into_bytes(self) -> Vec<u8>
		fn into_bytes_with_nul(self) -> Vec<u8>
		fn as_bytes(&self) -> &[u8]
		fn as_bytes_with_nul(&self) -> &[u8]
		fn as_c_str(&self) -> &CStr
		fn into_boxed_c_str(self) -> Box<CStr>
		// Methods from Deref<Target = CStr>
	}
	struct FromBytesWithNulError;
	struct IntoStringError {
		fn into_cstring(self) -> CString
		fn utf8_error(&self) -> Utf8Error
	}
	struct NulError {
		fn nul_position(&self) -> usize
		fn into_vec(self) -> Vec<u8>
	}
	struct OsStr {
		fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr
		fn to_str(&self) -> Option<&str>
		fn to_string_lossy(&self) -> Cow<str>
		fn to_os_string(&self) -> OsString
		fn is_empty(&self) -> bool
		fn len(&self) -> usize
		fn into_os_string(self: Box<OsStr>) -> OsString
	}
	struct OsString {
		fn new() -> OsString
		fn as_os_str(&self) -> &OsStr
		fn into_string(self) -> Result<String, OsString>
		fn push<T: AsRef<OsStr>>(&mut self, s: T)
		fn with_capacity(capacity: usize) -> OsString
		fn clear(&mut self)
		fn capacity(&self) -> usize
		fn reserve(&mut self, additional: usize)
		fn reserve_exact(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn into_boxed_os_str(self) -> Box<OsStr>
		// Methods from Deref<Target = OsStr>
	}
	enum c_void;
}

mod std::fmt {
	struct Arguments<'a>;
	struct DebugList<'a, 'b> {
		fn entry(&mut self, entry: &dyn Debug) -> &mut DebugList<'a, 'b>
		fn entries<D, I>(&mut self, entries: I) -> &mut DebugList<'a, 'b>
		fn finish(&mut self) -> Result<(), Error>
	}
	struct DebugMap<'a, 'b> {
		fn entry(&mut self, key: &dyn Debug, value: &dyn Debug) -> &mut DebugMap<'a, 'b>
		fn entries<K, V, I>(&mut self, entries: I) -> &mut DebugMap<'a, 'b>
		fn finish(&mut self) -> Result<(), Error>
	}
	struct DebugSet<'a, 'b> {
		fn entry(&mut self, entry: &dyn Debug) -> &mut DebugSet<'a, 'b>
		fn entries<D, I>(&mut self, entries: I) -> &mut DebugSet<'a, 'b>
		fn finish(&mut self) -> Result<(), Error>
	}
	struct DebugStruct<'a, 'b> {
		fn field(&mut self, name: &str, value: &dyn Debug) -> &mut DebugStruct<'a, 'b>
		fn finish(&mut self) -> Result<(), Error>
	}
	struct DebugTuple<'a, 'b> {
		fn field(&mut self, value: &dyn Debug) -> &mut DebugTuple<'a, 'b>
		fn finish(&mut self) -> Result<(), Error>
	}
	struct Error;
	struct Formatter<'a> {
		fn pad_integral(&mut self, is_nonnegative: bool, prefix: &str, buf: &str) -> Result<(), Error>
		fn pad(&mut self, s: &str) -> Result<(), Error>
		fn write_str(&mut self, data: &str) -> Result<(), Error>
		fn write_fmt(&mut self, fmt: Arguments) -> Result<(), Error>
		fn fill(&self) -> char
		fn align(&self) -> Option<Alignment>
		fn width(&self) -> Option<usize>
		fn precision(&self) -> Option<usize>
		fn sign_plus(&self) -> bool
		fn sign_minus(&self) -> bool
		fn alternate(&self) -> bool
		fn sign_aware_zero_pad(&self) -> bool
		fn debug_struct(&'b mut self, name: &str) -> DebugStruct<'b, 'a>
		fn debug_tuple(&'b mut self, name: &str) -> DebugTuple<'b, 'a>
		fn debug_list(&'b mut self) -> DebugList<'b, 'a>
		fn debug_set(&'b mut self) -> DebugSet<'b, 'a>
		fn debug_map(&'b mut self) -> DebugMap<'b, 'a>
	}
	enum Alignment {
		Left,
		Right,
		Center,
	}
	trait Binary {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
	}
	trait Debug {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait Display {
		fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait LowerExp {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
	}
	trait LowerHex {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>;
	}
	trait Octal {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait Pointer {
		fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait UpperExp {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait UpperHex {
		fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
	}
	trait Write {
		fn write_str(&mut self, s: &str) -> Result<(), Error>
		fn write_char(&mut self, c: char) -> Result<(), Error>
		fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>
	}
	fn format(args: Arguments) -> String
	fn write(output: &mut dyn Write, args: Arguments) -> Result<(), Error>
	type Result = Result<(), Error>;
}

mod std::fs {
	struct DirBuilder {
		fn new() -> DirBuilder
		fn recursive(&mut self, recursive: bool) -> &mut Self
		fn create<P: AsRef<Path>>(&self, path: P) -> Result<()>
	}
	struct DirEntry {
		fn path(&self) -> PathBuf
		fn metadata(&self) -> Result<Metadata>
		fn file_type(&self) -> Result<FileType>
		fn file_name(&self) -> OsString
	}
	struct File {
		fn open<P: AsRef<Path>>(path: P) -> Result<File>
		fn create<P: AsRef<Path>>(path: P) -> Result<File>
		fn sync_all(&self) -> Result<()>
		fn sync_data(&self) -> Result<()>
		fn set_len(&self, size: u64) -> Result<()>
		fn metadata(&self) -> Result<Metadata>
		fn try_clone(&self) -> Result<File>
		fn set_permissions(&self, perm: Permissions) -> Result<()>
	}
	struct FileType {
		fn is_dir(&self) -> bool
		fn is_file(&self) -> bool
		fn is_symlink(&self) -> bool
	}
	struct Metadata {
		fn file_type(&self) -> FileType
		fn is_dir(&self) -> bool
		fn is_file(&self) -> bool
		fn len(&self) -> u64
		fn permissions(&self) -> Permissions
		fn modified(&self) -> Result<SystemTime>
		fn accessed(&self) -> Result<SystemTime>
		fn created(&self) -> Result<SystemTime>
	}
	struct OpenOptions {
		fn new() -> OpenOptions
		fn read(&mut self, read: bool) -> &mut OpenOptions
		fn write(&mut self, write: bool) -> &mut OpenOptions
		fn append(&mut self, append: bool) -> &mut OpenOptions
		fn truncate(&mut self, truncate: bool) -> &mut OpenOptions
		fn create(&mut self, create: bool) -> &mut OpenOptions
		fn create_new(&mut self, create_new: bool) -> &mut OpenOptions
		fn open<P: AsRef<Path>>(&self, path: P) -> Result<File>
	}
	struct Permissions {
		fn readonly(&self) -> bool
		fn set_readonly(&mut self, readonly: bool)
	}
	struct ReadDir;
	fn canonicalize<P: AsRef<Path>>(path: P) -> Result<PathBuf>
	fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<u64>
	fn create_dir<P: AsRef<Path>>(path: P) -> Result<()>
	fn create_dir_all<P: AsRef<Path>>(path: P) -> Result<()>
	fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> Result<()>
	fn metadata<P: AsRef<Path>>(path: P) -> Result<Metadata>
	fn read<P: AsRef<Path>>(path: P) -> Result<Vec<u8>>
	fn read_dir<P: AsRef<Path>>(path: P) -> Result<ReadDir>
	fn read_link<P: AsRef<Path>>(path: P) -> Result<PathBuf>
	fn read_to_string<P: AsRef<Path>>(path: P) -> Result<String>
	fn remove_dir<P: AsRef<Path>>(path: P) -> Result<()>
	fn remove_dir_all<P: AsRef<Path>>(path: P) -> Result<()>
	fn remove_file<P: AsRef<Path>>(path: P) -> Result<()>
	fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> Result<()>
	fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) -> Result<()>
	fn symlink_metadata<P: AsRef<Path>>(path: P) -> Result<Metadata>
	fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> Result<()>
}

mod std::future {
	trait Future {
		type Output;
		fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>
	}
}

mod std::hash {
	struct BuildHasherDefault<H>;
	trait BuildHasher {
		type Hasher: Hasher;
		fn build_hasher(&self) -> Self::Hasher
	}
	trait Hash {
		fn hash<H>(&self, state: &mut H)
		fn hash_slice<H>(data: &[Self], state: &mut H)
	}
	trait Hasher {
		fn finish(&self) -> u64
		fn write(&mut self, bytes: &[u8])
		fn write_u8(&mut self, i: u8)
		fn write_u16(&mut self, i: u16)
		fn write_u32(&mut self, i: u32)
		fn write_u64(&mut self, i: u64)
		fn write_u128(&mut self, i: u128)
		fn write_usize(&mut self, i: usize)
		fn write_i8(&mut self, i: i8)
		fn write_i16(&mut self, i: i16)
		fn write_i32(&mut self, i: i32)
		fn write_i64(&mut self, i: i64)
		fn write_i128(&mut self, i: i128)
		fn write_isize(&mut self, i: isize)
	}
}

mod std::hint {
	unsafe fn unreachable_unchecked() -> !
}

mod std::i8 {
	const MAX: i8
	const MIN: i8
}

mod std::i16 {
	const MAX: i16
	const MIN: i16
}

mod std::i32 {
	const MAX: i32
	const MIN: i32
}

mod std::i64 {
	const MAX: i64
	const MIN: i64
}

mod std::i128 {
	// Primitive Type
	const fn min_value() -> i128
	const fn max_value() -> i128
	fn from_str_radix(src: &str, radix: u32) -> Result<i128, ParseIntError>
	const fn count_ones(self) -> u32
	const fn count_zeros(self) -> u32
	const fn leading_zeros(self) -> u32
	const fn trailing_zeros(self) -> u32
	const fn rotate_left(self, n: u32) -> i128
	const fn rotate_right(self, n: u32) -> i128
	const fn swap_bytes(self) -> i128
	const fn reverse_bits(self) -> i128
	const fn from_be(x: i128) -> i128
	const fn from_le(x: i128) -> i128
	const fn to_be(self) -> i128
	const fn to_le(self) -> i128
	fn checked_add(self, rhs: i128) -> Option<i128>
	fn checked_sub(self, rhs: i128) -> Option<i128>
	fn checked_mul(self, rhs: i128) -> Option<i128>
	fn checked_div(self, rhs: i128) -> Option<i128>
	fn checked_div_euclid(self, rhs: i128) -> Option<i128>
	fn checked_rem(self, rhs: i128) -> Option<i128>
	fn checked_rem_euclid(self, rhs: i128) -> Option<i128>
	fn checked_neg(self) -> Option<i128>
	fn checked_shl(self, rhs: u32) -> Option<i128>
	fn checked_shr(self, rhs: u32) -> Option<i128>
	fn checked_abs(self) -> Option<i128>
	fn checked_pow(self, exp: u32) -> Option<i128>
	fn saturating_add(self, rhs: i128) -> i128
	fn saturating_sub(self, rhs: i128) -> i128
	fn saturating_mul(self, rhs: i128) -> i128
	fn saturating_pow(self, exp: u32) -> i128
	const fn wrapping_add(self, rhs: i128) -> i128
	const fn wrapping_sub(self, rhs: i128) -> i128
	const fn wrapping_mul(self, rhs: i128) -> i128
	fn wrapping_div(self, rhs: i128) -> i128
	fn wrapping_div_euclid(self, rhs: i128) -> i128
	fn wrapping_rem(self, rhs: i128) -> i128
	fn wrapping_rem_euclid(self, rhs: i128) -> i128
	const fn wrapping_neg(self) -> i128
	const fn wrapping_shl(self, rhs: u32) -> i128
	const fn wrapping_shr(self, rhs: u32) -> i128
	fn wrapping_abs(self) -> i128
	fn wrapping_pow(self, exp: u32) -> i128
	const fn overflowing_add(self, rhs: i128) -> (i128, bool)
	const fn overflowing_sub(self, rhs: i128) -> (i128, bool)
	const fn overflowing_mul(self, rhs: i128) -> (i128, bool)
	fn overflowing_div(self, rhs: i128) -> (i128, bool)
	fn overflowing_div_euclid(self, rhs: i128) -> (i128, bool)
	fn overflowing_rem(self, rhs: i128) -> (i128, bool)
	fn overflowing_rem_euclid(self, rhs: i128) -> (i128, bool)
	const fn overflowing_neg(self) -> (i128, bool)
	const fn overflowing_shl(self, rhs: u32) -> (i128, bool)
	const fn overflowing_shr(self, rhs: u32) -> (i128, bool)
	fn overflowing_abs(self) -> (i128, bool)
	fn overflowing_pow(self, exp: u32) -> (i128, bool)
	fn pow(self, exp: u32) -> i128
	fn div_euclid(self, rhs: i128) -> i128
	fn rem_euclid(self, rhs: i128) -> i128
	fn abs(self) -> i128
	fn signum(self) -> i128
	const fn is_positive(self) -> bool
	const fn is_negative(self) -> bool
	fn to_be_bytes(self) -> [u8; 16]
	fn to_le_bytes(self) -> [u8; 16]
	fn to_ne_bytes(self) -> [u8; 16]
	fn from_be_bytes(bytes: [u8; 16]) -> i128
	fn from_le_bytes(bytes: [u8; 16]) -> i128
	fn from_ne_bytes(bytes: [u8; 16]) -> i128

	// Module
	const MAX: i128
	const MIN: i128
}

mod std::io {
	struct BufReader<R> {
		fn new(inner: R) -> BufReader<R>
		fn with_capacity(capacity: usize, inner: R) -> BufReader<R>
		fn get_ref(&self) -> &R
		fn get_mut(&mut self) -> &mut R
		fn buffer(&self) -> &[u8]
		fn into_inner(self) -> R
	}
	struct BufWriter<W: Write> {
		fn new(inner: W) -> BufWriter<W>
		fn with_capacity(capacity: usize, inner: W) -> BufWriter<W>
		fn get_ref(&self) -> &W
		fn get_mut(&mut self) -> &mut W
		fn buffer(&self) -> &[u8]
		fn into_inner(self) -> Result<W, IntoInnerError<BufWriter<W>>>
	}
	struct Bytes<R>;
	struct Chain<T, U> {
		fn into_inner(self) -> (T, U)
		fn get_ref(&self) -> (&T, &U)
		fn get_mut(&mut self) -> (&mut T, &mut U)
	}
	struct Cursor<T> {
		fn new(inner: T) -> Cursor<T>
		fn into_inner(self) -> T
		fn get_ref(&self) -> &T
		fn get_mut(&mut self) -> &mut T
		fn position(&self) -> u64
		fn set_position(&mut self, pos: u64)
	}
	struct Empty;
	struct Error {
		fn new<E>(kind: ErrorKind, error: E) -> Error
		fn last_os_error() -> Error
		fn from_raw_os_error(code: i32) -> Error
		fn raw_os_error(&self) -> Option<i32>
		fn get_ref(&self) -> Option<&(dyn Error + Send + Sync + 'static)>
		fn get_mut(&mut self) -> Option<&mut (dyn Error + Send + Sync + 'static)>
		fn into_inner(self) -> Option<Box<dyn Error + Send + Sync>>
		fn kind(&self) -> ErrorKind
	}
	struct IntoInnerError<W> {
		fn error(&self) -> &Error
		fn into_inner(self) -> W
	}
	struct IoSlice<'a> {
		fn new(buf: &'a [u8]) -> IoSlice<'a>
		// Methods from Deref<Target = [u8]>
	}
	struct IoSliceMut<'a> {
		fn new(buf: &'a mut [u8]) -> IoSliceMut<'a>
		// Methods from Deref<Target = [u8]>
	}
	struct LineWriter<W: Write> {
		fn new(inner: W) -> LineWriter<W>
		fn with_capacity(capacity: usize, inner: W) -> LineWriter<W>
		fn get_ref(&self) -> &W
		fn get_mut(&mut self) -> &mut W
		fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>>
	}
	struct Lines<B>;
	struct Repeat;
	struct Sink;
	struct Split<B>;
	struct Stderr {
		fn lock(&self) -> StderrLock
	}
	struct StderrLock<'a>;
	struct Stdin {
		fn lock(&self) -> StdinLock
		fn read_line(&self, buf: &mut String) -> Result<usize>
	}
	struct StdinLock<'a>;
	struct Stdout {
		fn lock(&self) -> StdoutLock
	}
	struct StdoutLock<'a>;
	struct Take<T> {
		fn limit(&self) -> u64
		fn set_limit(&mut self, limit: u64)
		fn into_inner(self) -> T
		fn get_ref(&self) -> &T
		fn get_mut(&mut self) -> &mut T
	}

	enum ErrorKind {
		NotFound,
		PermissionDenied,
		ConnectionRefused,
		ConnectionReset,
		ConnectionAborted,
		NotConnected,
		AddrInUse,
		AddrNotAvailable,
		BrokenPipe,
		AlreadyExists,
		WouldBlock,
		InvalidInput,
		InvalidData,
		TimedOut,
		WriteZero,
		Interrupted,
		Other,
		UnexpectedEof,
	}
	enum SeekFrom {
		Start(u64),
		End(i64),
		Current(i64),
	}
	trait BufRead: Read {
		fn fill_buf(&mut self) -> Result<&[u8]>
		fn consume(&mut self, amt: usize)
		fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>
		fn read_line(&mut self, buf: &mut String) -> Result<usize>
		fn split(self, byte: u8) -> Split<Self>
		fn lines(self) -> Lines<Self>
	}
	trait Read {
		fn read(&mut self, buf: &mut [u8]) -> Result<usize>
		fn read_vectored(&mut self, bufs: &mut [IoSliceMut]) -> Result<usize>
		fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>
		fn read_to_string(&mut self, buf: &mut String) -> Result<usize>
		fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>
		fn by_ref(&mut self) -> &mut Self
		fn bytes(self) -> Bytes<Self>
		fn chain<R: Read>(self, next: R) -> Chain<Self, R>
		fn take(self, limit: u64) -> Take<Self>
	}
	trait Seek {
		fn seek(&mut self, pos: SeekFrom) -> Result<u64>
	}
	trait Write {
		fn write(&mut self, buf: &[u8]) -> Result<usize>
		fn flush(&mut self) -> Result<()>
		fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize>
		fn write_all(&mut self, buf: &[u8]) -> Result<()>
		fn write_fmt(&mut self, fmt: Arguments) -> Result<()>
		fn by_ref(&mut self) -> &mut Self
	}
	fn copy<R: ?Sized, W: ?Sized>(reader: &mut R, writer: &mut W) -> Result<u64>
	fn empty() -> Empty
	fn repeat(byte: u8) -> Repeat
	fn sink() -> Sink
	fn stderr() -> Stderr
	fn stdin() -> Stdin
	fn stdout() -> Stdout
	type Result<T> = Result<T, Error>;
}

mod std::isize {
	const MAX: isize
	const MIN: isize
}

mod std::iter {
	struct Chain<A, B>;
	struct Cloned<I>;
	struct Copied<I>;
	struct Cycle<I>;
	struct Empty<T>;
	struct Enumerate<I>;
	struct Filter<I, P>;
	struct FilterMap<I, F>;
	struct FlatMap<I, U, F>;
	struct Flatten<I>;
	struct FromFn<F>;
	struct Fuse<I>;
	struct Inspect<I, F>;
	struct Map<I, F>;
	struct Once<T>;
	struct Peekable<I> {
		fn peek(&mut self) -> Option<&<I as Iterator>::Item>
	}
	struct Repeat<A>;
	struct RepeatWith<F>;
	struct Rev<T>;
	struct Scan<I, St, F>;
	struct Skip<I>;
	struct SkipWhile<I, P>;
	struct StepBy<I>;
	struct Successors<T, F>;
	struct Take<I>;
	struct TakeWhile<I, P>;
	struct Zip<A, B>;
	trait DoubleEndedIterator: Iterator {
		fn next_back(&mut self) -> Option<Self::Item>
		fn nth_back(&mut self, n: usize) -> Option<Self::Item>
		fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
		fn rfold<B, F>(self, accum: B, f: F) -> B
		fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item>
	}
	trait ExactSizeIterator: Iterator {
		fn len(&self) -> usize
	}
	trait Extend<A> {
		fn extend<T>(&mut self, iter: T)
	}
	trait FromIterator<A> {
		fn from_iter<T>(iter: T) -> Self
	}
	trait FusedIterator: Iterator;
	trait IntoIterator {
		type Item;
		type IntoIter: Iterator;
		fn into_iter(self) -> Self::IntoIter
	}
	trait Iterator {
		type Item;
		fn next(&mut self) -> Option<Self::Item>
		fn size_hint(&self) -> (usize, Option<usize>)
		fn count(self) -> usize
		fn last(self) -> Option<Self::Item>
		fn nth(&mut self, n: usize) -> Option<Self::Item>
		fn step_by(self, step: usize) -> StepBy<Self>
		fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>
		fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>
		fn map<B, F>(self, f: F) -> Map<Self, F>
		fn for_each<F>(self, f: F)
		fn filter<P>(self, predicate: P) -> Filter<Self, P>
		fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
		fn enumerate(self) -> Enumerate<Self>
		fn peekable(self) -> Peekable<Self>
		fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>
		fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>
		fn skip(self, n: usize) -> Skip<Self>
		fn take(self, n: usize) -> Take<Self>
		fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
		fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
		fn flatten(self) -> Flatten<Self>
		fn fuse(self) -> Fuse<Self>
		fn inspect<F>(self, f: F) -> Inspect<Self, F>
		fn by_ref(&mut self) -> &mut Self
		fn collect<B>(self) -> B
		fn partition<B, F>(self, f: F) -> (B, B)
		fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
		fn try_for_each<F, R>(&mut self, f: F) -> R
		fn fold<B, F>(self, init: B, f: F) -> B
		fn all<F>(&mut self, f: F) -> bool
		fn any<F>(&mut self, f: F) -> bool
		fn find<P>(&mut self, predicate: P) -> Option<Self::Item>
		fn find_map<B, F>(&mut self, f: F) -> Option<B>
		fn position<P>(&mut self, predicate: P) -> Option<usize>
		fn rposition<P>(&mut self, predicate: P) -> Option<usize>
		fn max(self) -> Option<Self::Item>
		fn min(self) -> Option<Self::Item>
		fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
		fn max_by<F>(self, compare: F) -> Option<Self::Item>
		fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
		fn min_by<F>(self, compare: F) -> Option<Self::Item>
		fn rev(self) -> Rev<Self>
		fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
		fn copied<'a, T>(self) -> Copied<Self>
		fn cloned<'a, T>(self) -> Cloned<Self>
		fn cycle(self) -> Cycle<Self>
		fn sum<S>(self) -> S
		fn product<P>(self) -> P
		fn cmp<I>(self, other: I) -> Ordering
		fn partial_cmp<I>(self, other: I) -> Option<Ordering>
		fn eq<I>(self, other: I) -> bool
		fn ne<I>(self, other: I) -> bool
		fn lt<I>(self, other: I) -> bool
		fn le<I>(self, other: I) -> bool
		fn gt<I>(self, other: I) -> bool
		fn ge<I>(self, other: I) -> bool
	}
	trait Product<A = Self> {
		fn product<I>(iter: I) -> Self
	}
	trait Sum<A = Self> {
		fn sum<I>(iter: I) -> Self
	}
	const fn empty<T>() -> Empty<T>
	fn from_fn<T, F>(f: F) -> FromFn<F>
	fn once<T>(value: T) -> Once<T>
	fn repeat<T>(elt: T) -> Repeat<T>
	fn repeat_with<A, F>(repeater: F) -> RepeatWith<F>
	fn successors<T, F>(first: Option<T>, succ: F) -> Successors<T, F>
}

mod std::marker {
	struct PhantomData<T>;
	struct PhantomPinned;
	trait Copy: Clone;
	unsafe auto trait Send;
	trait Sized;
	unsafe auto trait Sync;
	auto trait Unpin;
}

mod std::mem {
	struct Discriminant<T>;
	struct ManuallyDrop<T> {
		const fn new(value: T) -> ManuallyDrop<T>
		const fn into_inner(slot: ManuallyDrop<T>) -> T
		unsafe fn drop(slot: &mut ManuallyDrop<T>)
	}
	const fn align_of<T>() -> usize
	fn align_of_val<T>(val: &T) -> usize
	fn discriminant<T>(v: &T) -> Discriminant<T>
	fn drop<T>(_x: T)
	fn forget<T>(t: T)
	const fn needs_drop<T>() -> bool
	fn replace<T>(dest: &mut T, src: T) -> T
	const fn size_of<T>() -> usize
	fn size_of_val<T>(val: &T) -> usize
	fn swap<T>(x: &mut T, y: &mut T)
	unsafe extern "rust-intrinsic" fn transmute<T, U>(e: T) -> U
	unsafe fn transmute_copy<T, U>(src: &T) -> U
	unsafe fn zeroed<T>() -> T
	union MaybeUninit<T> {
		const fn new(val: T) -> MaybeUninit<T>
		const fn uninit() -> MaybeUninit<T>
		fn zeroed() -> MaybeUninit<T>
		fn as_ptr(&self) -> *const T
		fn as_mut_ptr(&mut self) -> *mut T
		unsafe fn assume_init(self) -> T
	}
}

mod std::net {
	struct AddrParseError;
	struct Incoming<'a>;
	struct Ipv4Addr {
		const fn new(a: u8, b: u8, c: u8, d: u8) -> Ipv4Addr
		const LOCALHOST: Self
		const UNSPECIFIED: Self
		const BROADCAST: Self
		fn octets(&self) -> [u8; 4]
		const fn is_unspecified(&self) -> bool
		fn is_loopback(&self) -> bool
		fn is_private(&self) -> bool
		fn is_link_local(&self) -> bool
		fn is_multicast(&self) -> bool
		fn is_broadcast(&self) -> bool
		fn is_documentation(&self) -> bool
		fn to_ipv6_compatible(&self) -> Ipv6Addr
		fn to_ipv6_mapped(&self) -> Ipv6Addr
	}
	struct Ipv6Addr {
		const fn new(a: u16, b: u16, c: u16, d: u16, e: u16, f: u16, g: u16, h: u16) -> Ipv6Addr
		const LOCALHOST: Self
		const UNSPECIFIED: Self
		fn segments(&self) -> [u16; 8]
		fn is_unspecified(&self) -> bool
		fn is_loopback(&self) -> bool
		fn is_multicast(&self) -> bool
		fn to_ipv4(&self) -> Option<Ipv4Addr>
		const fn octets(&self) -> [u8; 16]
	}
	struct SocketAddrV4 {
		fn new(ip: Ipv4Addr, port: u16) -> SocketAddrV4
		fn ip(&self) -> &Ipv4Addr
		fn set_ip(&mut self, new_ip: Ipv4Addr)
		fn port(&self) -> u16
		fn set_port(&mut self, new_port: u16)
	}
	struct SocketAddrV6 {
		fn new(ip: Ipv6Addr, port: u16, flowinfo: u32, scope_id: u32) -> SocketAddrV6
		fn ip(&self) -> &Ipv6Addr
		fn set_ip(&mut self, new_ip: Ipv6Addr)
		fn port(&self) -> u16
		fn set_port(&mut self, new_port: u16)
		fn flowinfo(&self) -> u32
		fn set_flowinfo(&mut self, new_flowinfo: u32)
		fn scope_id(&self) -> u32
		fn set_scope_id(&mut self, new_scope_id: u32)
	}
	struct TcpListener {
		fn bind<A: ToSocketAddrs>(addr: A) -> Result<TcpListener>
		fn local_addr(&self) -> Result<SocketAddr>
		fn try_clone(&self) -> Result<TcpListener>
		fn accept(&self) -> Result<(TcpStream, SocketAddr)>
		fn incoming(&self) -> Incoming
		fn set_ttl(&self, ttl: u32) -> Result<()>
		fn ttl(&self) -> Result<u32>
		fn take_error(&self) -> Result<Option<Error>>
		fn set_nonblocking(&self, nonblocking: bool) -> Result<()>
	}
	struct TcpStream {
		fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream>
		fn connect_timeout(addr: &SocketAddr, timeout: Duration) -> Result<TcpStream>
		fn peer_addr(&self) -> Result<SocketAddr>
		fn local_addr(&self) -> Result<SocketAddr>
		fn shutdown(&self, how: Shutdown) -> Result<()>
		fn try_clone(&self) -> Result<TcpStream>
		fn set_read_timeout(&self, dur: Option<Duration>) -> Result<()>
		fn set_write_timeout(&self, dur: Option<Duration>) -> Result<()>
		fn read_timeout(&self) -> Result<Option<Duration>>
		fn write_timeout(&self) -> Result<Option<Duration>>
		fn peek(&self, buf: &mut [u8]) -> Result<usize>
		fn set_nodelay(&self, nodelay: bool) -> Result<()>
		fn nodelay(&self) -> Result<bool>
		fn set_ttl(&self, ttl: u32) -> Result<()>
		fn ttl(&self) -> Result<u32>
		fn take_error(&self) -> Result<Option<Error>>
		fn set_nonblocking(&self, nonblocking: bool) -> Result<()>
	}
	struct UdpSocket {
		fn bind<A: ToSocketAddrs>(addr: A) -> Result<UdpSocket>
		fn recv_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>
		fn peek_from(&self, buf: &mut [u8]) -> Result<(usize, SocketAddr)>
		fn send_to<A: ToSocketAddrs>(&self, buf: &[u8], addr: A) -> Result<usize>
		fn local_addr(&self) -> Result<SocketAddr>
		fn try_clone(&self) -> Result<UdpSocket>
		fn set_read_timeout(&self, dur: Option<Duration>) -> Result<()>
		fn set_write_timeout(&self, dur: Option<Duration>) -> Result<()>
		fn read_timeout(&self) -> Result<Option<Duration>>
		fn write_timeout(&self) -> Result<Option<Duration>>
		fn set_broadcast(&self, broadcast: bool) -> Result<()>
		fn broadcast(&self) -> Result<bool>
		fn set_multicast_loop_v4(&self, multicast_loop_v4: bool) -> Result<()>
		fn multicast_loop_v4(&self) -> Result<bool>
		fn set_multicast_ttl_v4(&self, multicast_ttl_v4: u32) -> Result<()>
		fn multicast_ttl_v4(&self) -> Result<u32>
		fn set_multicast_loop_v6(&self, multicast_loop_v6: bool) -> Result<()>
		fn multicast_loop_v6(&self) -> Result<bool>
		fn set_ttl(&self, ttl: u32) -> Result<()>
		fn ttl(&self) -> Result<u32>
		fn join_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> Result<()>
		fn join_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> Result<()>
		fn leave_multicast_v4(&self, multiaddr: &Ipv4Addr, interface: &Ipv4Addr) -> Result<()>
		fn leave_multicast_v6(&self, multiaddr: &Ipv6Addr, interface: u32) -> Result<()>
		fn take_error(&self) -> Result<Option<Error>>
		fn connect<A: ToSocketAddrs>(&self, addr: A) -> Result<()>
		fn send(&self, buf: &[u8]) -> Result<usize>
		fn recv(&self, buf: &mut [u8]) -> Result<usize>
		fn peek(&self, buf: &mut [u8]) -> Result<usize>
		fn set_nonblocking(&self, nonblocking: bool) -> Result<()>
	}
	enum IpAddr {
		V4(Ipv4Addr),
		V6(Ipv6Addr),
		fn is_unspecified(&self) -> bool
		fn is_loopback(&self) -> bool
		fn is_multicast(&self) -> bool
		fn is_ipv4(&self) -> bool
		fn is_ipv6(&self) -> bool
	}
	enum Shutdown {
		Read,
		Write,
		Both,
	}
	enum SocketAddr {
		V4(SocketAddrV4),
		V6(SocketAddrV6),
		fn new(ip: IpAddr, port: u16) -> SocketAddr
		fn ip(&self) -> IpAddr
		fn set_ip(&mut self, new_ip: IpAddr)
		fn port(&self) -> u16
		fn set_port(&mut self, new_port: u16)
		fn is_ipv4(&self) -> bool
		fn is_ipv6(&self) -> bool
	}
	trait ToSocketAddrs {
		type Iter: Iterator<Item = SocketAddr>;
		fn to_socket_addrs(&self) -> Result<Self::Iter>
	}
}

mod std::num {
	struct NonZeroI8;
	struct NonZeroI16;
	struct NonZeroI32;
	struct NonZeroI64;
	struct NonZeroI128 {
		const unsafe fn new_unchecked(n: i128) -> NonZeroI128
		fn new(n: i128) -> Option<NonZeroI128>
		const fn get(self) -> i128
	}
	struct NonZeroIsize;
	struct NonZeroU8;
	struct NonZeroU16;
	struct NonZeroU32;
	struct NonZeroU64;
	struct NonZeroU128;
	struct NonZeroUsize;
	struct ParseFloatError;
	struct ParseIntError;
	struct TryFromIntError;
	struct Wrapping<T>;
	enum FpCategory {
		Nan,
		Infinite,
		Zero,
		Subnormal,
		Normal,
	}
}

mod std::ops {
	struct Range<Idx> {
		pub start: Idx,
		pub end: Idx,
		fn contains<U>(&self, item: &U) -> bool
	}
	struct RangeFrom<Idx> {
		pub start: Idx,
		fn contains<U>(&self, item: &U) -> bool
	}
	struct RangeFull;
	struct RangeInclusive<Idx> {
		const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx>
		const fn start(&self) -> &Idx
		const fn end(&self) -> &Idx
		fn into_inner(self) -> (Idx, Idx)
		fn contains<U>(&self, item: &U) -> bool
	}
	struct RangeTo<Idx> {
		pub end: Idx,
		fn contains<U>(&self, item: &U) -> bool
	}
	struct RangeToInclusive<Idx> {
		pub end: Idx,
		fn contains<U>(&self, item: &U) -> bool
	}
	enum Bound<T> {
		Included(T),
		Excluded(T),
		Unbounded,
	}
	trait Add<Rhs = Self> {
		type Output;
		fn add(self, rhs: Rhs) -> Self::Output
	}
	trait AddAssign<Rhs = Self> {
		fn add_assign(&mut self, rhs: Rhs)
	}
	trait BitAnd<Rhs = Self> {
		type Output;
		fn bitand(self, rhs: Rhs) -> Self::Output
	}
	trait BitAndAssign<Rhs = Self> {
		fn bitand_assign(&mut self, rhs: Rhs)
	}
	trait BitOr<Rhs = Self> {
		type Output;
		fn bitor(self, rhs: Rhs) -> Self::Output
	}
	trait BitOrAssign<Rhs = Self> {
		fn bitor_assign(&mut self, rhs: Rhs)
	}
	trait BitXor<Rhs = Self> {
		type Output;
		fn bitxor(self, rhs: Rhs) -> Self::Output
	}
	trait BitXorAssign<Rhs = Self> {
		fn bitxor_assign(&mut self, rhs: Rhs)
	}
	trait Deref {
		type Target: ?Sized;
		fn deref(&self) -> &Self::Target
	}
	trait DerefMut: Deref {
		fn deref_mut(&mut self) -> &mut Self::Target
	}
	trait Div<Rhs = Self> {
		type Output;
		fn div(self, rhs: Rhs) -> Self::Output
	}
	trait DivAssign<Rhs = Self> {
		fn div_assign(&mut self, rhs: Rhs)
	}
	trait Drop {
		fn drop(&mut self)
	}
	trait Fn<Args>: FnMut<Args>;
	trait FnMut<Args>: FnOnce<Args>;
	trait FnOnce<Args> {
		type Output;
	}
	trait Index<Idx> {
		type Output: ?Sized;
		fn index(&self, index: Idx) -> &Self::Output
	}
	trait IndexMut<Idx>: Index<Idx> {
		fn index_mut(&mut self, index: Idx) -> &mut Self::Output
	}
	trait Mul<Rhs = Self> {
		type Output;
		fn mul(self, rhs: Rhs) -> Self::Output
	}
	trait MulAssign<Rhs = Self> {
		fn mul_assign(&mut self, rhs: Rhs)
	}
	trait Neg {
		type Output;
		fn neg(self) -> Self::Output
	}
	trait Not {
		type Output;
		fn not(self) -> Self::Output
	}
	trait RangeBounds<T> {
		fn start_bound(&self) -> Bound<&T>
		fn end_bound(&self) -> Bound<&T>
		fn contains<U>(&self, item: &U) -> bool
	}
	trait Rem<Rhs = Self> {
		type Output;
		fn rem(self, rhs: Rhs) -> Self::Output
	}
	trait RemAssign<Rhs = Self> {
		fn rem_assign(&mut self, rhs: Rhs)
	}
	trait Shl<Rhs = Self> {
		type Output;
		fn shl(self, rhs: Rhs) -> Self::Output
	}
	trait ShlAssign<Rhs = Self> {
		fn shl_assign(&mut self, rhs: Rhs)
	}
	trait Shr<Rhs = Self> {
		type Output;
		fn shr(self, rhs: Rhs) -> Self::Output
	}
	trait ShrAssign<Rhs = Self> {
		fn shr_assign(&mut self, rhs: Rhs)
	}
	trait Sub<Rhs = Self> {
		type Output;
		fn sub(self, rhs: Rhs) -> Self::Output
	}
	trait SubAssign<Rhs = Self> {
		fn sub_assign(&mut self, rhs: Rhs);
	}
}

mod std::option {
	struct IntoIter<A>;
	struct Iter<'a, A>;
	struct IterMut<'a, A>;
	enum Option<T> {
		None,
		Some(T),
		fn is_some(&self) -> bool
		fn is_none(&self) -> bool
		fn as_ref(&self) -> Option<&T>
		fn as_mut(&mut self) -> Option<&mut T>
		fn as_pin_ref(self: Pin<&'a Option<T>>) -> Option<Pin<&'a T>>
		fn as_pin_mut(self: Pin<&'a mut Option<T>>) -> Option<Pin<&'a mut T>>
		fn expect(self, msg: &str) -> T
		fn unwrap(self) -> T
		fn unwrap_or(self, def: T) -> T
		fn unwrap_or_else<F>(self, f: F) -> T
		fn map<U, F>(self, f: F) -> Option<U>
		fn map_or<U, F>(self, default: U, f: F) -> U
		fn map_or_else<U, D, F>(self, default: D, f: F) -> U
		fn ok_or<E>(self, err: E) -> Result<T, E>
		fn ok_or_else<E, F>(self, err: F) -> Result<T, E>
		fn iter(&self) -> Iter<T>
		fn iter_mut(&mut self) -> IterMut<T>
		fn and<U>(self, optb: Option<U>) -> Option<U>
		fn and_then<U, F>(self, f: F) -> Option<U>
		fn filter<P>(self, predicate: P) -> Option<T>
		fn or(self, optb: Option<T>) -> Option<T>
		fn or_else<F>(self, f: F) -> Option<T>
		fn xor(self, optb: Option<T>) -> Option<T>
		fn get_or_insert(&mut self, v: T) -> &mut T
		fn get_or_insert_with<F>(&mut self, f: F) -> &mut T
		fn take(&mut self) -> Option<T>
		fn replace(&mut self, value: T) -> Option<T>
		fn copied(self) -> Option<T>
		fn cloned(self) -> Option<T>
		fn unwrap_or_default(self) -> T
		fn transpose(self) -> Result<Option<T>, E>
	}
}

mod std::os::raw {
	type c_char = i8;
	type c_double = f64;
	type c_float = f32;
	type c_int = i32;
	type c_long = i64;
	type c_longlong = i64;
	type c_schar = i8;
	type c_short = i16;
	type c_uchar = u8;
	type c_uint = u32;
	type c_ulong = u64;
	type c_ulonglong = u64;
	type c_ushort = u16;
}
// platform-specific extensions

mod std::panic {
	struct AssertUnwindSafe<T>;
	struct Location<'a> {
		fn file(&self) -> &str
		fn line(&self) -> u32
		fn column(&self) -> u32
	}
	struct PanicInfo<'a> {
		fn payload(&self) -> &(dyn Any + 'static + Send)
		fn location(&self) -> Option<&Location>
	}
	auto trait RefUnwindSafe;
	auto trait UnwindSafe;
	fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R>
	fn resume_unwind(payload: Box<dyn Any + Send>) -> !
	fn set_hook(hook: Box<dyn Fn(&PanicInfo) + Sync + Send + 'static>)
	fn take_hook() -> Box<dyn Fn(&PanicInfo) + Sync + Send + 'static>
}

mod std::path {
	struct Ancestors<'a>;
	struct Components<'a> {
		fn as_path(&self) -> &'a Path
	}
	struct Display<'a>;
	struct Iter<'a> {
		fn as_path(&self) -> &'a Path
	}
	struct Path {
		fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &Path
		fn as_os_str(&self) -> &OsStr
		fn to_str(&self) -> Option<&str>
		fn to_string_lossy(&self) -> Cow<str>
		fn to_path_buf(&self) -> PathBuf
		fn is_absolute(&self) -> bool
		fn is_relative(&self) -> bool
		fn has_root(&self) -> bool
		fn parent(&self) -> Option<&Path>
		fn ancestors(&self) -> Ancestors
		fn file_name(&self) -> Option<&OsStr>
		fn strip_prefix<P>(&self, base: P) -> Result<&Path, StripPrefixError>
		fn starts_with<P: AsRef<Path>>(&self, base: P) -> bool
		fn ends_with<P: AsRef<Path>>(&self, child: P) -> bool
		fn file_stem(&self) -> Option<&OsStr>
		fn extension(&self) -> Option<&OsStr>
		fn join<P: AsRef<Path>>(&self, path: P) -> PathBuf
		fn with_file_name<S: AsRef<OsStr>>(&self, file_name: S) -> PathBuf
		fn with_extension<S: AsRef<OsStr>>(&self, extension: S) -> PathBuf
		fn components(&self) -> Components
		fn iter(&self) -> Iter
		fn display(&self) -> Display
		fn metadata(&self) -> Result<Metadata>
		fn symlink_metadata(&self) -> Result<Metadata>
		fn canonicalize(&self) -> Result<PathBuf>
		fn read_link(&self) -> Result<PathBuf>
		fn read_dir(&self) -> Result<ReadDir>
		fn exists(&self) -> bool
		fn is_file(&self) -> bool
		fn is_dir(&self) -> bool
		fn into_path_buf(self: Box<Path>) -> PathBuf
	}
	struct PathBuf {
		fn new() -> PathBuf
		fn as_path(&self) -> &Path
		fn push<P: AsRef<Path>>(&mut self, path: P)
		fn pop(&mut self) -> bool
		fn set_file_name<S: AsRef<OsStr>>(&mut self, file_name: S)
		fn set_extension<S: AsRef<OsStr>>(&mut self, extension: S) -> bool
		fn into_os_string(self) -> OsString
		fn into_boxed_path(self) -> Box<Path>
		// Methods from Deref<Target = Path>
	}
	struct PrefixComponent<'a> {
		fn kind(&self) -> Prefix<'a>
		fn as_os_str(&self) -> &'a OsStr
	}
	struct StripPrefixError;
	enum Component<'a> {
		Prefix(PrefixComponent<'a>),
		RootDir,
		CurDir,
		ParentDir,
		Normal(&'a OsStr),
		fn as_os_str(self) -> &'a OsStr
	}
	enum Prefix<'a> {
		Verbatim(&'a OsStr),
		VerbatimUNC(&'a OsStr, &'a OsStr),
		VerbatimDisk(u8),
		DeviceNS(&'a OsStr),
		UNC(&'a OsStr, &'a OsStr),
		Disk(u8),
		fn is_verbatim(&self) -> bool
	}
	const MAIN_SEPARATOR: char
	fn is_separator(c: char) -> bool
}

mod std::pin {
	struct Pin<P> {
		fn new(pointer: P) -> Pin<P>
		unsafe fn new_unchecked(pointer: P) -> Pin<P>
		fn as_ref(&self) -> Pin<&<P as Deref>::Target>
		fn as_mut(&mut self) -> Pin<&mut <P as Deref>::Target>
		fn set(&mut self, value: <P as Deref>::Target)
		unsafe fn map_unchecked<U, F>(self, func: F) -> Pin<&'a U>
		fn get_ref(self) -> &'a T
		fn into_ref(self) -> Pin<&'a T>
		fn get_mut(self) -> &'a mut T
		unsafe fn get_unchecked_mut(self) -> &'a mut T
		unsafe fn map_unchecked_mut<U, F>(self, func: F) -> Pin<&'a mut U>
	}
}

mod std::prelude {}

mod std::process {
	struct Child {
		pub stdin: Option<ChildStdin>
		pub stdout: Option<ChildStdout>
		pub stderr: Option<ChildStderr>
		fn kill(&mut self) -> Result<()>
		fn id(&self) -> u32
		fn wait(&mut self) -> Result<ExitStatus>
		fn try_wait(&mut self) -> Result<Option<ExitStatus>>
		fn wait_with_output(self) -> Result<Output>
	}
	struct ChildStderr;
	struct ChildStdin;
	struct ChildStdout;
	struct Command {
		fn new<S: AsRef<OsStr>>(program: S) -> Command
		fn arg<S: AsRef<OsStr>>(&mut self, arg: S) -> &mut Command
		fn args<I, S>(&mut self, args: I) -> &mut Command
		fn env<K, V>(&mut self, key: K, val: V) -> &mut Command
		fn envs<I, K, V>(&mut self, vars: I) -> &mut Command
		fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Command
		fn env_clear(&mut self) -> &mut Command
		fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Command
		fn stdin<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command
		fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command
		fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Command
		fn spawn(&mut self) -> Result<Child>
		fn output(&mut self) -> Result<Output>
		fn status(&mut self) -> Result<ExitStatus>
	}
	struct ExitStatus {
		fn success(&self) -> bool
		fn code(&self) -> Option<i32>
	}
	struct Output {
		pub status: ExitStatus
		pub stdout: Vec<u8>
		pub stderr: Vec<u8>
	}
	struct Stdio {
		fn piped() -> Stdio
		fn inherit() -> Stdio
		fn null() -> Stdio
	}
	fn abort() -> !
	fn exit(code: i32) -> !
	fn id() -> u32
}

mod std::ptr {
	// Primitive Type pointer
	// impl<T> *const T
	fn is_null(self) -> bool
	const fn cast<U>(self) -> *const U
	unsafe fn as_ref<'a>(self) -> Option<&'a T>
	unsafe fn offset(self, count: isize) -> *const T
	fn wrapping_offset(self, count: isize) -> *const T
	unsafe fn add(self, count: usize) -> *const T
	unsafe fn sub(self, count: usize) -> *const T
	fn wrapping_add(self, count: usize) -> *const T
	fn wrapping_sub(self, count: usize) -> *const T
	unsafe fn read(self) -> T
	unsafe fn read_volatile(self) -> T
	unsafe fn read_unaligned(self) -> T
	unsafe fn copy_to(self, dest: *mut T, count: usize)
	unsafe fn copy_to_nonoverlapping(self, dest: *mut T, count: usize)
	fn align_offset(self, align: usize) -> usize
	// impl<T> *mut T
	unsafe fn as_mut<'a>(self) -> Option<&'a mut T>
	unsafe fn copy_from(self, src: *const T, count: usize)
	unsafe fn copy_from_nonoverlapping(self, src: *const T, count: usize)
	unsafe fn drop_in_place(self)
	unsafe fn write(self, val: T)
	unsafe fn write_bytes(self, val: u8, count: usize)
	unsafe fn write_volatile(self, val: T)
	unsafe fn write_unaligned(self, val: T)
	unsafe fn replace(self, src: T) -> T
	unsafe fn swap(self, with: *mut T)

	// Module
	struct NonNull<T> {
		const fn dangling() -> NonNull<T>
		const unsafe fn new_unchecked(ptr: *mut T) -> NonNull<T>
		fn new(ptr: *mut T) -> Option<NonNull<T>>
		const fn as_ptr(self) -> *mut T
		unsafe fn as_ref(&self) -> &T
		unsafe fn as_mut(&mut self) -> &mut T
		const fn cast<U>(self) -> NonNull<U>
	}
	unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize)
	unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize)
	unsafe fn drop_in_place<T>(to_drop: *mut T)
	fn eq<T>(a: *const T, b: *const T) -> bool
	fn hash<T, S>(hashee: *const T, into: &mut S)
	const fn null<T>() -> *const T
	const fn null_mut<T>() -> *mut T
	unsafe fn read<T>(src: *const T) -> T
	unsafe fn read_unaligned<T>(src: *const T) -> T
	unsafe fn read_volatile<T>(src: *const T) -> T
	unsafe fn replace<T>(dst: *mut T, src: T) -> T
	unsafe fn swap<T>(x: *mut T, y: *mut T)
	unsafe fn swap_nonoverlapping<T>(x: *mut T, y: *mut T, count: usize)
	unsafe fn write<T>(dst: *mut T, src: T)
	unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize)
	unsafe fn write_unaligned<T>(dst: *mut T, src: T)
	unsafe fn write_volatile<T>(dst: *mut T, src: T)
}

mod std::rc {
	struct Rc<T> {
		fn new(value: T) -> Rc<T>
		fn pin(value: T) -> Pin<Rc<T>>
		fn try_unwrap(this: Rc<T>) -> Result<T, Rc<T>>
		fn into_raw(this: Rc<T>) -> *const T
		unsafe fn from_raw(ptr: *const T) -> Rc<T>
		fn downgrade(this: &Rc<T>) -> Weak<T>
		fn weak_count(this: &Rc<T>) -> usize
		fn strong_count(this: &Rc<T>) -> usize
		fn get_mut(this: &mut Rc<T>) -> Option<&mut T>
		fn ptr_eq(this: &Rc<T>, other: &Rc<T>) -> bool
		fn make_mut(this: &mut Rc<T>) -> &mut T
		fn downcast<T>(self) -> Result<Rc<T>, Rc<dyn Any + 'static>>
	}
	struct Weak<T> {
		fn new() -> Weak<T>
		fn upgrade(&self) -> Option<Rc<T>>
	}
}

mod std::result {
	struct IntoIter<T>;
	struct Iter<'a, T>;
	struct IterMut<'a, T>;
	enum Result<T, E> {
		Ok(T),
		Err(E),
		fn is_ok(&self) -> bool
		fn is_err(&self) -> bool
		fn ok(self) -> Option<T>
		fn err(self) -> Option<E>
		fn as_ref(&self) -> Result<&T, &E>
		fn as_mut(&mut self) -> Result<&mut T, &mut E>
		fn map<U, F>(self, op: F) -> Result<U, E>
		fn map_err<F, O>(self, op: O) -> Result<T, F>
		fn iter(&self) -> Iter<T>
		fn iter_mut(&mut self) -> IterMut<T>
		fn and<U>(self, res: Result<U, E>) -> Result<U, E>
		fn and_then<U, F>(self, op: F) -> Result<U, E>
		fn or<F>(self, res: Result<T, F>) -> Result<T, F>
		fn or_else<F, O>(self, op: O) -> Result<T, F>
		fn unwrap_or(self, optb: T) -> T
		fn unwrap_or_else<F>(self, op: F) -> T
		fn unwrap(self) -> T
		fn expect(self, msg: &str) -> T
		fn unwrap_err(self) -> E
		fn expect_err(self, msg: &str) -> E
		fn unwrap_or_default(self) -> T
		fn transpose(self) -> Option<Result<T, E>>
	}
}

mod std::slice {
	// Primitive Type
	fn len(&self) -> usize
	fn is_empty(&self) -> bool
	fn first(&self) -> Option<&T>
	fn first_mut(&mut self) -> Option<&mut T>
	fn split_first(&self) -> Option<(&T, &[T])>
	fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>
	fn split_last(&self) -> Option<(&T, &[T])>
	fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>
	fn last(&self) -> Option<&T>
	fn last_mut(&mut self) -> Option<&mut T>
	fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>
	fn get_mut<I>(&mut self, index: I) -> Option<&mut <I as SliceIndex<[T]>>::Output>
	unsafe fn get_unchecked<I>(&self, index: I) -> &<I as SliceIndex<[T]>>::Output
	unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut <I as SliceIndex<[T]>>::Output
	const fn as_ptr(&self) -> *const T
	fn as_mut_ptr(&mut self) -> *mut T
	fn swap(&mut self, a: usize, b: usize)
	fn reverse(&mut self)
	fn iter(&self) -> Iter<T>
	fn iter_mut(&mut self) -> IterMut<T>
	fn windows(&self, size: usize) -> Windows<T>
	fn chunks(&self, chunk_size: usize) -> Chunks<T>
	fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>
	fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<T>
	fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<T>
	fn rchunks(&self, chunk_size: usize) -> RChunks<T>
	fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<T>
	fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<T>
	fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<T>
	fn split_at(&self, mid: usize) -> (&[T], &[T])
	fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
	fn split<F>(&self, pred: F) -> Split<T, F>
	fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F>
	fn rsplit<F>(&self, pred: F) -> RSplit<T, F>
	fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F>
	fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>
	fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>
	fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>
	fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F>
	fn contains(&self, x: &T) -> bool
	fn starts_with(&self, needle: &[T]) -> bool
	fn ends_with(&self, needle: &[T]) -> bool
	fn binary_search(&self, x: &T) -> Result<usize, usize>
	fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
	fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
	fn sort_unstable(&mut self)
	fn sort_unstable_by<F>(&mut self, compare: F)
	fn sort_unstable_by_key<K, F>(&mut self, f: F)
	fn rotate_left(&mut self, mid: usize)
	fn rotate_right(&mut self, k: usize)
	fn clone_from_slice(&mut self, src: &[T])
	fn copy_from_slice(&mut self, src: &[T])
	fn copy_within<R>(&mut self, src: R, dest: usize)
	fn swap_with_slice(&mut self, other: &mut [T])
	unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])
	unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])
	// impl [u8]
	fn is_ascii(&self) -> bool
	fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
	fn make_ascii_uppercase(&mut self)
	fn make_ascii_lowercase(&mut self)
	fn to_ascii_uppercase(&self) -> Vec<u8>
	fn to_ascii_lowercase(&self) -> Vec<u8>
	// impl<T> [T]
	fn sort(&mut self)
	fn sort_by<F>(&mut self, compare: F)
	fn sort_by_key<K, F>(&mut self, f: F)
	fn sort_by_cached_key<K, F>(&mut self, f: F)
	fn to_vec(&self) -> Vec<T>
	fn into_vec(self: Box<[T]>) -> Vec<T>
	fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output
	fn join<Separator>(&self, sep: Separator) -> <[T] as Join<Separator>>::Output

	// Module
	struct Chunks<'a, T>;
	struct ChunksExact<'a, T> {
		fn remainder(&self) -> &'a [T]
	}
	struct ChunksExactMut<'a, T> {
		fn into_remainder(self) -> &'a mut [T]
	}
	struct ChunksMut<'a, T>;
	struct Iter<'a, T> {
		fn as_slice(&self) -> &'a [T]
	}
	struct IterMut<'a, T> {
		fn into_slice(self) -> &'a mut [T]
	}
	struct RChunks<'a, T>;
	struct RChunksExact<'a, T> {
		fn remainder(&self) -> &'a [T]
	}
	struct RChunksExactMut<'a, T> {
		fn into_remainder(self) -> &'a mut [T]
	}
	struct RChunksMut<'a, T>;
	struct RSplit<'a, T, P>;
	struct RSplitMut<'a, T, P>;
	struct RSplitN<'a, T, P>;
	struct RSplitNMut<'a, T, P>;
	struct Split<'a, T, P>;
	struct SplitMut<'a, T, P>;
	struct SplitN<'a, T, P>;
	struct SplitNMut<'a, T, P>;
	struct Windows<'a, T>;
	trait SliceIndex<T>: Sealed {
		type Output: ?Sized
	}
	fn from_mut<T>(s: &mut T) -> &mut [T]
	unsafe fn from_raw_parts<'a, T>(data: *const T, len: usize) -> &'a [T]
	unsafe fn from_raw_parts_mut<'a, T>(data: *mut T, len: usize) -> &'a mut [T]
	fn from_ref<T>(s: &T) -> &[T]
}

mod std::str {
	// Primitive Type
	fn len(&self) -> usize
	fn is_empty(&self) -> bool
	fn is_char_boundary(&self, index: usize) -> bool
	fn as_bytes(&self) -> &[u8]
	unsafe fn as_bytes_mut(&mut self) -> &mut [u8]
	const fn as_ptr(&self) -> *const u8
	fn as_mut_ptr(&mut self) -> *mut u8
	fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>
	fn get_mut<I>(&mut self, i: I) -> Option<&mut <I as SliceIndex<str>>::Output>
	unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Output
	unsafe fn get_unchecked_mut<I>(&mut self, i: I) -> &mut <I as SliceIndex<str>>::Output
	fn split_at(&self, mid: usize) -> (&str, &str)
	fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)
	fn chars(&self) -> Chars
	fn char_indices(&self) -> CharIndices
	fn bytes(&self) -> Bytes
	fn split_whitespace(&self) -> SplitWhitespace
	fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace
	fn lines(&self) -> Lines
	fn encode_utf16(&self) -> EncodeUtf16
	fn contains<'a, P>(&'a self, pat: P) -> bool
	fn starts_with<'a, P>(&'a self, pat: P) -> bool
	fn ends_with<'a, P>(&'a self, pat: P) -> bool
	fn find<'a, P>(&'a self, pat: P) -> Option<usize>
	fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>
	fn split<'a, P>(&'a self, pat: P) -> Split<'a, P>
	fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P>
	fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P>
	fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P>
	fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P>
	fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P>
	fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P>
	fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P>
	fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P>
	fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P>
	fn trim(&self) -> &str
	fn trim_start(&self) -> &str
	fn trim_end(&self) -> &str
	fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str
	fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str
	fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str
	fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>
	fn is_ascii(&self) -> bool
	fn eq_ignore_ascii_case(&self, other: &str) -> bool
	fn make_ascii_uppercase(&mut self)
	fn make_ascii_lowercase(&mut self)
	fn escape_debug(&self) -> EscapeDebug
	fn escape_default(&self) -> EscapeDefault
	fn escape_unicode(&self) -> EscapeUnicode
	fn into_boxed_bytes(self: Box<str>) -> Box<[u8]>
	fn replace<'a, P>(&'a self, from: P, to: &str) -> String
	fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String
	fn to_lowercase(&self) -> String
	fn to_uppercase(&self) -> String
	fn into_string(self: Box<str>) -> String
	fn repeat(&self, n: usize) -> String
	fn to_ascii_uppercase(&self) -> String
	fn to_ascii_lowercase(&self) -> String

	// Module
	struct Bytes<'a>;
	struct CharIndices<'a> {
		fn as_str(&self) -> &'a str
	}
	struct Chars<'a> {
		fn as_str(&self) -> &'a str
	}
	struct EncodeUtf16<'a>;
	struct EscapeDebug<'a>;
	struct EscapeDefault<'a>;
	struct EscapeUnicode<'a>;
	struct Lines<'a>;
	struct MatchIndices<'a, P>;
	struct Matches<'a, P>;
	struct ParseBoolError;
	struct RMatchIndices<'a, P>;
	struct RMatches<'a, P>;
	struct RSplit<'a, P>;
	struct RSplitN<'a, P>;
	struct RSplitTerminator<'a, P>;
	struct Split<'a, P>;
	struct SplitAsciiWhitespace<'a>;
	struct SplitN<'a, P>;
	struct SplitTerminator<'a, P>;
	struct SplitWhitespace<'a>;
	struct Utf8Error {
		fn valid_up_to(&self) -> usize
		fn error_len(&self) -> Option<usize>
	}
	trait FromStr {
		type Err;
		fn from_str(s: &str) -> Result<Self, Self::Err>
	}
	unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str>
	fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error>
	unsafe fn from_utf8_unchecked(v: &[u8]) -> &str
	fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error>
	unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str
}

mod std::string {
	struct Drain<'a>;
	struct FromUtf8Error {
		fn as_bytes(&self) -> &[u8]
		fn into_bytes(self) -> Vec<u8>
		fn utf8_error(&self) -> Utf8Error
	}
	struct FromUtf16Error;
	struct String {
		fn new() -> String
		fn with_capacity(capacity: usize) -> String
		fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
		fn from_utf8_lossy(v: &'a [u8]) -> Cow<'a, str>
		fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
		fn from_utf16_lossy(v: &[u16]) -> String
		unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String
		unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
		fn into_bytes(self) -> Vec<u8>
		fn as_str(&self) -> &str
		fn as_mut_str(&mut self) -> &mut str
		fn push_str(&mut self, string: &str)
		fn capacity(&self) -> usize
		fn reserve(&mut self, additional: usize)
		fn reserve_exact(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn push(&mut self, ch: char)
		fn as_bytes(&self) -> &[u8]
		fn truncate(&mut self, new_len: usize)
		fn pop(&mut self) -> Option<char>
		fn remove(&mut self, idx: usize) -> char
		fn retain<F>(&mut self, f: F)
		fn insert(&mut self, idx: usize, ch: char)
		fn insert_str(&mut self, idx: usize, string: &str)
		unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn split_off(&mut self, at: usize) -> String
		fn clear(&mut self)
		fn drain<R>(&mut self, range: R) -> Drain
		fn replace_range<R>(&mut self, range: R, replace_with: &str)
		fn into_boxed_str(self) -> Box<str>
		// Methods from Deref<Target = str>
	}
	trait ToString {
		fn to_string(&self) -> String
	}
	type ParseError = Infallible;
}

mod std::sync {
	struct Arc<T> {
		fn new(data: T) -> Arc<T>
		fn pin(data: T) -> Pin<Arc<T>>
		fn try_unwrap(this: Arc<T>) -> Result<T, Arc<T>>
		fn into_raw(this: Arc<T>) -> *const T
		unsafe fn from_raw(ptr: *const T) -> Arc<T>
		fn downgrade(this: &Arc<T>) -> Weak<T>
		fn weak_count(this: &Arc<T>) -> usize
		fn strong_count(this: &Arc<T>) -> usize
		fn ptr_eq(this: &Arc<T>, other: &Arc<T>) -> bool
		fn make_mut(this: &mut Arc<T>) -> &mut T
		fn get_mut(this: &mut Arc<T>) -> Option<&mut T>
		fn downcast<T>(self) -> Result<Arc<T>, Arc<dyn Any + 'static + Send + Sync>>
	}
	struct Barrier {
		fn new(n: usize) -> Barrier
		fn wait(&self) -> BarrierWaitResult
	}
	struct BarrierWaitResult {
		fn is_leader(&self) -> bool
	}
	struct Condvar {
		fn new() -> Condvar
		fn wait<'a, T>(&self, guard: MutexGuard<'a, T>) -> LockResult<MutexGuard<'a, T>>
		fn wait_timeout<'a, T>(&self, guard: MutexGuard<'a, T>, dur: Duration) -> LockResult<(MutexGuard<'a, T>, WaitTimeoutResult)>
		fn notify_one(&self)
		fn notify_all(&self)
	}
	struct Mutex<T: ?Sized> {
		fn new(t: T) -> Mutex<T>
		fn lock(&self) -> LockResult<MutexGuard<T>>
		fn try_lock(&self) -> TryLockResult<MutexGuard<T>>
		fn is_poisoned(&self) -> bool
		fn into_inner(self) -> LockResult<T>
		fn get_mut(&mut self) -> LockResult<&mut T>
	}
	struct MutexGuard<'a, T: ?Sized + 'a>;
	struct Once {
		const fn new() -> Once
		fn call_once<F>(&self, f: F)
	}
	struct PoisonError<T> {
		fn new(guard: T) -> PoisonError<T>
		fn into_inner(self) -> T
		fn get_ref(&self) -> &T
		fn get_mut(&mut self) -> &mut T
	}
	struct RwLock<T: ?Sized> {
		fn new(t: T) -> RwLock<T>
		fn read(&self) -> LockResult<RwLockReadGuard<T>>
		fn try_read(&self) -> TryLockResult<RwLockReadGuard<T>>
		fn write(&self) -> LockResult<RwLockWriteGuard<T>>
		fn try_write(&self) -> TryLockResult<RwLockWriteGuard<T>>
		fn is_poisoned(&self) -> bool
		fn into_inner(self) -> LockResult<T>
		fn get_mut(&mut self) -> LockResult<&mut T>
	}
	struct RwLockReadGuard<'a, T: ?Sized + 'a>;
	struct RwLockWriteGuard<'a, T: ?Sized + 'a>;
	struct WaitTimeoutResult {
		fn timed_out(&self) -> bool
	}
	struct Weak<T> {
		fn new() -> Weak<T>
		fn upgrade(&self) -> Option<Arc<T>>
	}
	enum TryLockError<T> {
		Poisoned(PoisonError<T>),
		WouldBlock,
	}
	type LockResult<Guard> = Result<Guard, PoisonError<Guard>>;
	type TryLockResult<Guard> = Result<Guard, TryLockError<Guard>>;
}

mod std::sync::atomic {
	struct AtomicBool;
	struct AtomicI8;
	struct AtomicI16;
	struct AtomicI32;
	struct AtomicI64;
	struct AtomicIsize {
		const fn new(v: isize) -> AtomicIsize
		fn get_mut(&mut self) -> &mut isize
		fn into_inner(self) -> isize
		fn load(&self, order: Ordering) -> isize
		fn store(&self, val: isize, order: Ordering)
		fn swap(&self, val: isize, order: Ordering) -> isize
		fn compare_and_swap(&self, current: isize, new: isize, order: Ordering) -> isize
		fn compare_exchange(&self, current: isize, new: isize, success: Ordering, failure: Ordering) -> Result<isize, isize>
		fn compare_exchange_weak(&self, current: isize, new: isize, success: Ordering, failure: Ordering) -> Result<isize, isize>
		fn fetch_add(&self, val: isize, order: Ordering) -> isize
		fn fetch_sub(&self, val: isize, order: Ordering) -> isize
		fn fetch_and(&self, val: isize, order: Ordering) -> isize
		fn fetch_nand(&self, val: isize, order: Ordering) -> isize
		fn fetch_or(&self, val: isize, order: Ordering) -> isize
		fn fetch_xor(&self, val: isize, order: Ordering) -> isize
	}
	struct AtomicPtr<T>;
	struct AtomicU8;
	struct AtomicU16;
	struct AtomicU32;
	struct AtomicU64;
	struct AtomicUsize;
	enum Ordering {
		Relaxed,
		Release,
		Acquire,
		AcqRel,
		SeqCst,
	}
	fn compiler_fence(order: Ordering)
	fn fence(order: Ordering)
	fn spin_loop_hint()
}

mod std::sync::mpsc {
	struct IntoIter<T>;
	struct Iter<'a, T: 'a>;
	struct Receiver<T> {
		fn try_recv(&self) -> Result<T, TryRecvError>
		fn recv(&self) -> Result<T, RecvError>
		fn recv_timeout(&self, timeout: Duration) -> Result<T, RecvTimeoutError>
		fn iter(&self) -> Iter<T>
		fn try_iter(&self) -> TryIter<T>
	}
	struct RecvError;
	struct SendError<T>;
	struct Sender<T> {
		fn send(&self, t: T) -> Result<(), SendError<T>>
	}
	struct SyncSender<T> {
		fn send(&self, t: T) -> Result<(), SendError<T>>
		fn try_send(&self, t: T) -> Result<(), TrySendError<T>>
	}
	struct TryIter<'a, T: 'a>;
	enum RecvTimeoutError {
		Timeout,
		Disconnected,
	}
	enum TryRecvError {
		Empty,
		Disconnected,
	}
	enum TrySendError<T> {
		Full(T),
		Disconnected(T),
	}
	fn channel<T>() -> (Sender<T>, Receiver<T>)
	fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>)
}

mod std::task {
	struct Context<'a> {
		fn from_waker(waker: &'a Waker) -> Context<'a>
		fn waker(&self) -> &'a Waker
	}
	struct RawWaker {
		const fn new(data: *const (), vtable: &'static RawWakerVTable) -> RawWaker
	}
	struct RawWakerVTable {
		const fn new(clone: unsafe fn(*const ()) -> RawWaker, wake: unsafe fn(*const ()), wake_by_ref: unsafe fn(*const ()), drop: unsafe fn(*const ())) -> RawWakerVTable
	}
	struct Waker {
		fn wake(self)
		fn wake_by_ref(&self)
		fn will_wake(&self, other: &Waker) -> bool
		unsafe fn from_raw(waker: RawWaker) -> Waker
	}
	enum Poll<T> {
		Ready(T),
		Pending,
		fn map<U, F>(self, f: F) -> Poll<U>
		fn is_ready(&self) -> bool
		fn is_pending(&self) -> bool
		fn map_ok<U, F>(self, f: F) -> Poll<Result<U, E>>
		fn map_err<U, F>(self, f: F) -> Poll<Result<T, U>>
	}
}

mod std::thread {
	struct AccessError;
	struct Builder {
		fn new() -> Builder
		fn name(self, name: String) -> Builder
		fn stack_size(self, size: usize) -> Builder
		fn spawn<F, T>(self, f: F) -> Result<JoinHandle<T>>
	}
	struct JoinHandle<T> {
		fn thread(&self) -> &Thread
		fn join(self) -> Result<T>
	}
	struct LocalKey<T: 'static> {
		fn with<F, R>(&'static self, f: F) -> R
		fn try_with<F, R>(&'static self, f: F) -> Result<R, AccessError>
	}
	struct Thread {
		fn unpark(&self)
		fn id(&self) -> ThreadId
		fn name(&self) -> Option<&str>
	}
	struct ThreadId;
	fn current() -> Thread
	fn panicking() -> bool
	fn park()
	fn park_timeout(dur: Duration)
	fn sleep(dur: Duration)
	fn spawn<F, T>(f: F) -> JoinHandle<T>
	fn yield_now()
	type Result<T> = Result<T, Box<dyn Any + Send + 'static>>;
}

mod std::time {
	struct Duration {
		fn new(secs: u64, nanos: u32) -> Duration
		const fn from_secs(secs: u64) -> Duration
		const fn from_millis(millis: u64) -> Duration
		const fn from_micros(micros: u64) -> Duration
		const fn from_nanos(nanos: u64) -> Duration
		const fn as_secs(&self) -> u64
		const fn subsec_millis(&self) -> u32
		const fn subsec_micros(&self) -> u32
		const fn subsec_nanos(&self) -> u32
		const fn as_millis(&self) -> u128
		const fn as_micros(&self) -> u128
		const fn as_nanos(&self) -> u128
		fn checked_add(self, rhs: Duration) -> Option<Duration>
		fn checked_sub(self, rhs: Duration) -> Option<Duration>
		fn checked_mul(self, rhs: u32) -> Option<Duration>
		fn checked_div(self, rhs: u32) -> Option<Duration>
		fn as_secs_f64(&self) -> f64
		fn as_secs_f32(&self) -> f32
		fn from_secs_f64(secs: f64) -> Duration
		fn from_secs_f32(secs: f32) -> Duration
		fn mul_f64(self, rhs: f64) -> Duration
		fn mul_f32(self, rhs: f32) -> Duration
		fn div_f64(self, rhs: f64) -> Duration
		fn div_f32(self, rhs: f32) -> Duration
	}
	struct Instant {
		fn now() -> Instant
		fn duration_since(&self, earlier: Instant) -> Duration
		fn elapsed(&self) -> Duration
		fn checked_add(&self, duration: Duration) -> Option<Instant>
		fn checked_sub(&self, duration: Duration) -> Option<Instant>
	}
	struct SystemTime {
		const UNIX_EPOCH: SystemTime
		fn now() -> SystemTime
		fn duration_since(&self, earlier: SystemTime) -> Result<Duration, SystemTimeError>
		fn elapsed(&self) -> Result<Duration, SystemTimeError>
		fn checked_add(&self, duration: Duration) -> Option<SystemTime>
		fn checked_sub(&self, duration: Duration) -> Option<SystemTime>
	}
	struct SystemTimeError {
		fn duration(&self) -> Duration
	}
	const UNIX_EPOCH: SystemTime
}

mod std::u8 {
	// Primitive Type
	fn is_ascii(&self) -> bool
	fn to_ascii_uppercase(&self) -> u8
	fn to_ascii_lowercase(&self) -> u8
	fn eq_ignore_ascii_case(&self, other: &u8) -> bool
	fn make_ascii_uppercase(&mut self)
	fn make_ascii_lowercase(&mut self)
	fn is_ascii_alphabetic(&self) -> bool
	fn is_ascii_uppercase(&self) -> bool
	fn is_ascii_lowercase(&self) -> bool
	fn is_ascii_alphanumeric(&self) -> bool
	fn is_ascii_digit(&self) -> bool
	fn is_ascii_hexdigit(&self) -> bool
	fn is_ascii_punctuation(&self) -> bool
	fn is_ascii_graphic(&self) -> bool
	fn is_ascii_whitespace(&self) -> bool
	fn is_ascii_control(&self) -> bool

	// Module
	const MAX: u8
	const MIN: u8
}

mod std::u16 {
	const MAX: u16
	const MIN: u16
}

mod std::u32 {
	const MAX: u32
	const MIN: u32
}

mod std::u64 {
	const MAX: u64
	const MIN: u64
}

mod std::u128 {
	// Primitive Type
	fn is_power_of_two(self) -> bool
	fn next_power_of_two(self) -> u128
	fn checked_next_power_of_two(self) -> Option<u128>

	// Module
	const MAX: u128
	const MIN: u128
}

mod std::usize {
	const MAX: usize
	const MIN: usize
}

mod std::vec {
	struct Drain<'a, T> {}
	struct IntoIter<T> {
		fn as_slice(&self) -> &[T]
		fn as_mut_slice(&mut self) -> &mut [T]
	}
	struct Splice<'a, I>;
	struct Vec<T> {
		fn new() -> Vec<T>
		fn with_capacity(capacity: usize) -> Vec<T>
		unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Vec<T>
		fn capacity(&self) -> usize
		fn reserve(&mut self, additional: usize)
		fn reserve_exact(&mut self, additional: usize)
		fn shrink_to_fit(&mut self)
		fn into_boxed_slice(self) -> Box<[T]>
		fn truncate(&mut self, len: usize)
		fn as_slice(&self) -> &[T]
		fn as_mut_slice(&mut self) -> &mut [T]
		fn as_ptr(&self) -> *const T
		fn as_mut_ptr(&mut self) -> *mut T
		unsafe fn set_len(&mut self, new_len: usize)
		fn swap_remove(&mut self, index: usize) -> T
		fn insert(&mut self, index: usize, element: T)
		fn remove(&mut self, index: usize) -> T
		fn retain<F>(&mut self, f: F)
		fn dedup_by_key<F, K>(&mut self, key: F)
		fn dedup_by<F>(&mut self, same_bucket: F)
		fn push(&mut self, value: T)
		fn pop(&mut self) -> Option<T>
		fn append(&mut self, other: &mut Vec<T>)
		fn drain<R>(&mut self, range: R) -> Drain<T>
		fn clear(&mut self)
		fn len(&self) -> usize
		fn is_empty(&self) -> bool
		fn split_off(&mut self, at: usize) -> Vec<T>
		fn resize_with<F>(&mut self, new_len: usize, f: F)
		fn resize(&mut self, new_len: usize, value: T)
		fn extend_from_slice(&mut self, other: &[T])
		fn dedup(&mut self)
		fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<<I as IntoIterator>::IntoIter>
		fn first(&self) -> Option<&T>
		// Methods from Deref<Target = [T]>
	}
}

mod std::intrinsics {
}

mod std::raw {
}