/rust/registry/src/index.crates.io-1949cf8c6b5b557f/data-encoding-2.10.0/src/lib.rs

Line	Count	Source
1		//! Efficient and customizable data-encoding functions like base64, base32, and hex
2		//!
3		//! This [crate] provides little-endian ASCII base-conversion encodings for
4		//! bases of size 2, 4, 8, 16, 32, and 64. It supports:
5		//!
6		//! - [padding] for streaming
7		//! - canonical encodings (e.g. [trailing bits] are checked)
8		//! - in-place [encoding] and [decoding] functions
9		//! - partial [decoding] functions (e.g. for error recovery)
10		//! - character [translation] (e.g. for case-insensitivity)
11		//! - most and least significant [bit-order]
12		//! - [ignoring] characters when decoding (e.g. for skipping newlines)
13		//! - [wrapping] the output when encoding
14		//! - no-std environments with `default-features = false, features = ["alloc"]`
15		//! - no-alloc environments with `default-features = false`
16		//!
17		//! You may use the [binary] or the [website] to play around.
18		//!
19		//! # Examples
20		//!
21		//! This crate provides predefined encodings as [constants]. These constants are of type
22		//! [`Encoding`]. This type provides encoding and decoding functions with in-place or allocating
23		//! variants. Here is an example using the allocating encoding function of [`BASE64`]:
24		//!
25		//! ```rust
26		//! use data_encoding::BASE64;
27		//! assert_eq!(BASE64.encode(b"Hello world"), "SGVsbG8gd29ybGQ=");
28		//! ```
29		//!
30		//! Here is an example using the in-place decoding function of [`BASE32`]:
31		//!
32		//! ```rust
33		//! use data_encoding::BASE32;
34		//! let input = b"JBSWY3DPEB3W64TMMQ======";
35		//! let mut output = vec![0; BASE32.decode_len(input.len()).unwrap()];
36		//! let len = BASE32.decode_mut(input, &mut output).unwrap();
37		//! assert_eq!(&output[0 .. len], b"Hello world");
38		//! ```
39		//!
40		//! You are not limited to the predefined encodings. You may define your own encodings (with the
41		//! same correctness and performance properties as the predefined ones) using the [`Specification`]
42		//! type:
43		//!
44		//! ```rust
45		//! use data_encoding::Specification;
46		//! let hex = {
47		//! let mut spec = Specification::new();
48		//! spec.symbols.push_str("0123456789abcdef");
49		//! spec.encoding().unwrap()
50		//! };
51		//! assert_eq!(hex.encode(b"hello"), "68656c6c6f");
52		//! ```
53		//!
54		//! You may use the [macro] library to define a compile-time custom encoding:
55		//!
56		//! ```rust,ignore
57		//! use data_encoding::Encoding;
58		//! use data_encoding_macro::new_encoding;
59		//! const HEX: Encoding = new_encoding!{
60		//! symbols: "0123456789abcdef",
61		//! translate_from: "ABCDEF",
62		//! translate_to: "abcdef",
63		//! };
64		//! const BASE64: Encoding = new_encoding!{
65		//! symbols: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
66		//! padding: '=',
67		//! };
68		//! ```
69		//!
70		//! # Properties
71		//!
72		//! The [`HEXUPPER`], [`BASE32`], [`BASE32HEX`], [`BASE64`], and [`BASE64URL`] predefined encodings
73		//! conform to [RFC4648].
74		//!
75		//! In general, the encoding and decoding functions satisfy the following properties:
76		//!
77		//! - They are deterministic: their output only depends on their input
78		//! - They have no side-effects: they do not modify any hidden mutable state
79		//! - They are correct: encoding followed by decoding gives the initial data
80		//! - They are canonical (unless [`is_canonical`] returns false): decoding followed by encoding
81		//! gives the initial data
82		//!
83		//! This last property is usually not satisfied by base64 implementations. This is a matter of
84		//! choice and this crate has made the choice to let the user choose. Support for canonical encoding
85		//! as described by the [RFC][canonical] is provided. But it is also possible to disable checking
86		//! trailing bits, to add characters translation, to decode concatenated padded inputs, and to
87		//! ignore some characters. Note that non-canonical encodings may be an attack vector as described
88		//! in [Base64 Malleability in Practice](https://eprint.iacr.org/2022/361.pdf).
89		//!
90		//! Since the RFC specifies the encoding function on all inputs and the decoding function on all
91		//! possible encoded outputs, the differences between implementations come from the decoding
92		//! function which may be more or less permissive. In this crate, the decoding function of canonical
93		//! encodings rejects all inputs that are not a possible output of the encoding function. Here are
94		//! some concrete examples of decoding differences between this crate, the `base64` crate, and the
95		//! `base64` GNU program:
96		//!
97		//! \| Input \| `data-encoding` \| `base64` \| GNU `base64` \|
98		//! \| ---------- \| --------------- \| --------- \| ------------- \|
99		//! \| `AAB=` \| `Trailing(2)` \| `Last(2)` \| `\x00\x00` \|
100		//! \| `AA\nB=` \| `Length(4)` \| `Byte(2)` \| `\x00\x00` \|
101		//! \| `AAB` \| `Length(0)` \| `Padding` \| Invalid input \|
102		//! \| `AAA` \| `Length(0)` \| `Padding` \| Invalid input \|
103		//! \| `A\rA\nB=` \| `Length(4)` \| `Byte(1)` \| Invalid input \|
104		//! \| `-_\r\n` \| `Symbol(0)` \| `Byte(0)` \| Invalid input \|
105		//! \| `AA==AA==` \| `[0, 0]` \| `Byte(2)` \| `\x00\x00` \|
106		//!
107		//! We can summarize these discrepancies as follows:
108		//!
109		//! \| Discrepancy \| `data-encoding` \| `base64` \| GNU `base64` \|
110		//! \| -------------------------- \| --------------- \| -------- \| ------------ \|
111		//! \| Check trailing bits \| Yes \| Yes \| No \|
112		//! \| Ignored characters \| None \| None \| `\n` \|
113		//! \| Translated characters \| None \| None \| None \|
114		//! \| Check padding \| Yes \| No \| Yes \|
115		//! \| Support concatenated input \| Yes \| No \| Yes \|
116		//!
117		//! This crate permits to disable checking trailing bits. It permits to ignore some characters. It
118		//! permits to translate characters. It permits to use unpadded encodings. However, for padded
119		//! encodings, support for concatenated inputs cannot be disabled. This is simply because it doesn't
120		//! make sense to use padding if it is not to support concatenated inputs.
121		//!
122		//! [RFC4648]: https://tools.ietf.org/html/rfc4648
123		//! [`BASE32HEX`]: constant.BASE32HEX.html
124		//! [`BASE32`]: constant.BASE32.html
125		//! [`BASE64URL`]: constant.BASE64URL.html
126		//! [`BASE64`]: constant.BASE64.html
127		//! [`Encoding`]: struct.Encoding.html
128		//! [`HEXUPPER`]: constant.HEXUPPER.html
129		//! [`Specification`]: struct.Specification.html
130		//! [`is_canonical`]: struct.Encoding.html#method.is_canonical
131		//! [binary]: https://crates.io/crates/data-encoding-bin
132		//! [bit-order]: struct.Specification.html#structfield.bit_order
133		//! [canonical]: https://tools.ietf.org/html/rfc4648#section-3.5
134		//! [constants]: index.html#constants
135		//! [crate]: https://crates.io/crates/data-encoding
136		//! [decoding]: struct.Encoding.html#method.decode_mut
137		//! [encoding]: struct.Encoding.html#method.encode_mut
138		//! [ignoring]: struct.Specification.html#structfield.ignore
139		//! [macro]: https://crates.io/crates/data-encoding-macro
140		//! [padding]: struct.Specification.html#structfield.padding
141		//! [trailing bits]: struct.Specification.html#structfield.check_trailing_bits
142		//! [translation]: struct.Specification.html#structfield.translate
143		//! [website]: https://data-encoding.rs
144		//! [wrapping]: struct.Specification.html#structfield.wrap
145
146		#![no_std]
147		#![cfg_attr(docsrs, feature(doc_cfg))]
148
149		#[cfg(feature = "alloc")]
150		extern crate alloc;
151		#[cfg(feature = "std")]
152		extern crate std;
153
154		#[cfg(feature = "alloc")]
155		use alloc::borrow::{Cow, ToOwned};
156		#[cfg(feature = "alloc")]
157		use alloc::string::String;
158		#[cfg(feature = "alloc")]
159		use alloc::vec;
160		#[cfg(feature = "alloc")]
161		use alloc::vec::Vec;
162		use core::convert::TryInto;
163		use core::debug_assert as safety_assert;
164
165		macro_rules! check {
166		($e: expr, $c: expr) => {
167		if !$c {
168		return Err($e);
169		}
170		};
171		}
172
173		trait Static<T: Copy>: Copy {
174		fn val(self) -> T;
175		}
176
177		macro_rules! define {
178		($name: ident: $type: ty = $val: expr) => {
179		#[derive(Copy, Clone)]
180		struct $name;
181		impl Static<$type> for $name {
182	0	fn val(self) -> $type {
183		$val
184	0	} Unexecuted instantiation: <data_encoding::Bf as data_encoding::Static<bool>>::val Unexecuted instantiation: <data_encoding::Bt as data_encoding::Static<bool>>::val Unexecuted instantiation: <data_encoding::N1 as data_encoding::Static<usize>>::val Unexecuted instantiation: <data_encoding::N2 as data_encoding::Static<usize>>::val Unexecuted instantiation: <data_encoding::N3 as data_encoding::Static<usize>>::val Unexecuted instantiation: <data_encoding::N4 as data_encoding::Static<usize>>::val Unexecuted instantiation: <data_encoding::N5 as data_encoding::Static<usize>>::val Unexecuted instantiation: <data_encoding::N6 as data_encoding::Static<usize>>::val
185		}
186		};
187		}
188
189		define!(Bf: bool = false);
190		define!(Bt: bool = true);
191		define!(N1: usize = 1);
192		define!(N2: usize = 2);
193		define!(N3: usize = 3);
194		define!(N4: usize = 4);
195		define!(N5: usize = 5);
196		define!(N6: usize = 6);
197
198		#[derive(Copy, Clone)]
199		struct On;
200
201		impl<T: Copy> Static<Option<T>> for On {
202	0	fn val(self) -> Option<T> {
203	0	None
204	0	} Unexecuted instantiation: <data_encoding::On as data_encoding::Static<core::option::Option<(usize, &[u8])>>>::val Unexecuted instantiation: <data_encoding::On as data_encoding::Static<core::option::Option<u8>>>::val
205		}
206
207		#[derive(Copy, Clone)]
208		struct Os<T>(T);
209
210		impl<T: Copy> Static<Option<T>> for Os<T> {
211	0	fn val(self) -> Option<T> {
212	0	Some(self.0)
213	0	} Unexecuted instantiation: <data_encoding::Os<(usize, &[u8])> as data_encoding::Static<core::option::Option<(usize, &[u8])>>>::val Unexecuted instantiation: <data_encoding::Os<u8> as data_encoding::Static<core::option::Option<u8>>>::val
214		}
215
216		macro_rules! dispatch {
217		(let $var: ident: bool = $val: expr; $($body: tt)*) => {
218		if $val {
219		let $var = Bt; dispatch!($($body)*)
220		} else {
221		let $var = Bf; dispatch!($($body)*)
222		}
223		};
224		(let $var: ident: usize = $val: expr; $($body: tt)*) => {
225		match $val {
226		1 => { let $var = N1; dispatch!($($body)*) },
227		2 => { let $var = N2; dispatch!($($body)*) },
228		3 => { let $var = N3; dispatch!($($body)*) },
229		4 => { let $var = N4; dispatch!($($body)*) },
230		5 => { let $var = N5; dispatch!($($body)*) },
231		6 => { let $var = N6; dispatch!($($body)*) },
232		_ => panic!(),
233		}
234		};
235		(let $var: ident: Option<$type: ty> = $val: expr; $($body: tt)*) => {
236		match $val {
237		None => { let $var = On; dispatch!($($body)*) },
238		Some(x) => { let $var = Os(x); dispatch!($($body)*) },
239		}
240		};
241		($body: expr) => { $body };
242		}
243
244	0	fn chunk_unchecked<T>(x: &[T], n: usize, i: usize) -> &[T] {
245	0	safety_assert!((i + 1) * n <= x.len());
246		// SAFETY: Ensured by correctness requirements (and asserted above).
247	0	unsafe { core::slice::from_raw_parts(x.as_ptr().add(n * i), n) }
248	0	}
249
250	0	fn chunk_mut_unchecked<T>(x: &mut [T], n: usize, i: usize) -> &mut [T] {
251	0	safety_assert!((i + 1) * n <= x.len());
252		// SAFETY: Ensured by correctness requirements (and asserted above).
253	0	unsafe { core::slice::from_raw_parts_mut(x.as_mut_ptr().add(n * i), n) }
254	0	}
255
256	0	fn div_ceil(x: usize, m: usize) -> usize {
257	0	(x + m - 1) / m
258	0	}
259
260	0	fn floor(x: usize, m: usize) -> usize {
261	0	x / m * m
262	0	}
263
264		#[inline]
265	0	fn vectorize<F: FnMut(usize)>(n: usize, bs: usize, mut f: F) {
266	0	for k in 0 .. n / bs {
267	0	for i in k * bs .. (k + 1) * bs {
268	0	f(i);
269	0	}
270		}
271	0	for i in floor(n, bs) .. n {
272	0	f(i);
273	0	}
274	0	} Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N1, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N1, data_encoding::Bt>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N2, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N2, data_encoding::Bt>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N3, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N3, data_encoding::Bt>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N4, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N4, data_encoding::Bt>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N5, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N5, data_encoding::Bt>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N6, data_encoding::Bf>::{closure#0}> Unexecuted instantiation: data_encoding::vectorize::<data_encoding::encode_mut<data_encoding::N6, data_encoding::Bt>::{closure#0}>
275
276		/// Decoding error kind
277		#[derive(Debug, Copy, Clone, PartialEq, Eq)]
278		pub enum DecodeKind {
279		/// Invalid length
280		Length,
281
282		/// Invalid symbol
283		Symbol,
284
285		/// Non-zero trailing bits
286		Trailing,
287
288		/// Invalid padding length
289		Padding,
290		}
291
292		impl core::fmt::Display for DecodeKind {
293	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
294	0	let description = match self {
295	0	DecodeKind::Length => "invalid length",
296	0	DecodeKind::Symbol => "invalid symbol",
297	0	DecodeKind::Trailing => "non-zero trailing bits",
298	0	DecodeKind::Padding => "invalid padding length",
299		};
300	0	write!(f, "{}", description)
301	0	}
302		}
303
304		/// Decoding error
305		#[derive(Debug, Copy, Clone, PartialEq, Eq)]
306		pub struct DecodeError {
307		/// Error position
308		///
309		/// This position is always a valid input position and represents the first encountered error.
310		pub position: usize,
311
312		/// Error kind
313		pub kind: DecodeKind,
314		}
315
316		#[cfg(feature = "std")]
317		impl std::error::Error for DecodeError {}
318
319		impl core::fmt::Display for DecodeError {
320	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
321	0	write!(f, "{} at {}", self.kind, self.position)
322	0	}
323		}
324
325		/// Decoding error with partial result
326		#[derive(Debug, Copy, Clone, PartialEq, Eq)]
327		pub struct DecodePartial {
328		/// Number of bytes read from input
329		///
330		/// This number does not exceed the error position: `read <= error.position`.
331		pub read: usize,
332
333		/// Number of bytes written to output
334		///
335		/// This number does not exceed the decoded length: `written <= decode_len(read)`.
336		pub written: usize,
337
338		/// Decoding error
339		pub error: DecodeError,
340		}
341
342		const INVALID: u8 = 128;
343		const IGNORE: u8 = 129;
344		const PADDING: u8 = 130;
345
346	0	fn order(msb: bool, n: usize, i: usize) -> usize {
347	0	if msb {
348	0	n - 1 - i
349		} else {
350	0	i
351		}
352	0	}
353
354		#[inline]
355	0	fn enc(bit: usize) -> usize {
356	0	match bit {
357	0	1 \| 2 \| 4 => 1,
358	0	3 \| 6 => 3,
359	0	5 => 5,
360	0	_ => unreachable!(),
361		}
362	0	}
363
364		#[inline]
365	0	fn dec(bit: usize) -> usize {
366	0	enc(bit) * 8 / bit
367	0	}
368
369	0	fn encode_len<B: Static<usize>>(bit: B, len: usize) -> usize {
370	0	div_ceil(8 * len, bit.val())
371	0	} Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N1> Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N2> Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N3> Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N4> Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N5> Unexecuted instantiation: data_encoding::encode_len::<data_encoding::N6>
372
373	0	fn encode_block<B: Static<usize>, M: Static<bool>>(
374	0	bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
375	0	) {
376	0	debug_assert!(input.len() <= enc(bit.val()));
377	0	debug_assert_eq!(output.len(), encode_len(bit, input.len()));
378	0	let bit = bit.val();
379	0	let msb = msb.val();
380	0	let mut x = 0u64;
381	0	for (i, input) in input.iter().enumerate() {
382	0	x \|= u64::from(input) << (8 order(msb, enc(bit), i));
383	0	}
384	0	for (i, output) in output.iter_mut().enumerate() {
385	0	let y = x >> (bit * order(msb, dec(bit), i));
386	0	*output = symbols[(y & 0xff) as usize];
387	0	}
388	0	} Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_block::<data_encoding::N6, data_encoding::Bt>
389
390	0	fn encode_mut<B: Static<usize>, M: Static<bool>>(
391	0	bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
392	0	) {
393	0	debug_assert_eq!(output.len(), encode_len(bit, input.len()));
394	0	let enc = enc(bit.val());
395	0	let dec = dec(bit.val());
396	0	let n = input.len() / enc;
397	0	let bs = match bit.val() {
398	0	5 => 2,
399	0	6 => 4,
400	0	_ => 1,
401		};
402	0	vectorize(n, bs, \|i\| {
403	0	let input = chunk_unchecked(input, enc, i);
404	0	let output = chunk_mut_unchecked(output, dec, i);
405	0	encode_block(bit, msb, symbols, input, output);
406	0	}); Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N1, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N1, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N2, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N2, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N3, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N3, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N4, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N4, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N5, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N5, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N6, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N6, data_encoding::Bt>::{closure#0}
407	0	encode_block(bit, msb, symbols, &input[enc * n ..], &mut output[dec * n ..]);
408	0	} Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_mut::<data_encoding::N6, data_encoding::Bt>
409
410		// Fails if an input character does not translate to a symbol. The error is the
411		// lowest index of such character. The output is not written to.
412	0	fn decode_block<B: Static<usize>, M: Static<bool>>(
413	0	bit: B, msb: M, values: &[u8; 256], input: &[u8], output: &mut [u8],
414	0	) -> Result<(), usize> {
415	0	debug_assert!(output.len() <= enc(bit.val()));
416	0	debug_assert_eq!(input.len(), encode_len(bit, output.len()));
417	0	let bit = bit.val();
418	0	let msb = msb.val();
419	0	let mut x = 0u64;
420	0	for j in 0 .. input.len() {
421	0	let y = values[input[j] as usize];
422	0	check!(j, y < 1 << bit);
423	0	x \|= u64::from(y) << (bit * order(msb, dec(bit), j));
424		}
425	0	for (j, output) in output.iter_mut().enumerate() {
426	0	output = ((x >> (8 order(msb, enc(bit), j))) & 0xff) as u8;
427	0	}
428	0	Ok(())
429	0	} Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_block::<data_encoding::N6, data_encoding::Bt>
430
431		// Fails if an input character does not translate to a symbol. The error `pos`
432		// is the lowest index of such character. The output is valid up to `pos / dec *
433		// enc` excluded.
434	0	fn decode_mut<B: Static<usize>, M: Static<bool>>(
435	0	bit: B, msb: M, values: &[u8; 256], input: &[u8], output: &mut [u8],
436	0	) -> Result<(), usize> {
437	0	debug_assert_eq!(input.len(), encode_len(bit, output.len()));
438	0	let enc = enc(bit.val());
439	0	let dec = dec(bit.val());
440	0	let n = input.len() / dec;
441	0	for i in 0 .. n {
442	0	let input = chunk_unchecked(input, dec, i);
443	0	let output = chunk_mut_unchecked(output, enc, i);
444	0	decode_block(bit, msb, values, input, output).map_err(\|e\| dec * i + e)?; Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bt>::{closure#0}
445		}
446	0	decode_block(bit, msb, values, &input[dec * n ..], &mut output[enc * n ..])
447	0	.map_err(\|e\| dec * n + e) Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bt>::{closure#1}
448	0	} Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_mut::<data_encoding::N6, data_encoding::Bt>
449
450		// Fails if there are non-zero trailing bits.
451	0	fn check_trail<B: Static<usize>, M: Static<bool>>(
452	0	bit: B, msb: M, ctb: bool, values: &[u8; 256], input: &[u8],
453	0	) -> Result<(), ()> {
454	0	if 8 % bit.val() == 0 \|\| !ctb {
455	0	return Ok(());
456	0	}
457	0	let trail = bit.val() * input.len() % 8;
458	0	if trail == 0 {
459	0	return Ok(());
460	0	}
461	0	let mut mask = (1 << trail) - 1;
462	0	if !msb.val() {
463	0	mask <<= bit.val() - trail;
464	0	}
465	0	check!((), values[input[input.len() - 1] as usize] & mask == 0);
466	0	Ok(())
467	0	} Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::check_trail::<data_encoding::N6, data_encoding::Bt>
468
469		// Fails if the padding length is invalid. The error is the index of the first
470		// padding character.
471	0	fn check_pad<B: Static<usize>>(bit: B, values: &[u8; 256], input: &[u8]) -> Result<usize, usize> {
472	0	let bit = bit.val();
473	0	debug_assert_eq!(input.len(), dec(bit));
474	0	let is_pad = \|x: &&u8\| values[**x as usize] == PADDING; Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N1>::{closure#0} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N2>::{closure#0} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N3>::{closure#0} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N4>::{closure#0} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N5>::{closure#0} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N6>::{closure#0}
475	0	let count = input.iter().rev().take_while(is_pad).count();
476	0	let len = input.len() - count;
477	0	check!(len, len > 0 && bit * len % 8 < bit);
478	0	Ok(len)
479	0	} Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N1> Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N2> Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N3> Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N4> Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N5> Unexecuted instantiation: data_encoding::check_pad::<data_encoding::N6>
480
481	0	fn encode_base_len<B: Static<usize>>(bit: B, len: usize) -> usize {
482	0	encode_len(bit, len)
483	0	} Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N1> Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N2> Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N3> Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N4> Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N5> Unexecuted instantiation: data_encoding::encode_base_len::<data_encoding::N6>
484
485	0	fn encode_base<B: Static<usize>, M: Static<bool>>(
486	0	bit: B, msb: M, symbols: &[u8; 256], input: &[u8], output: &mut [u8],
487	0	) {
488	0	debug_assert_eq!(output.len(), encode_base_len(bit, input.len()));
489	0	encode_mut(bit, msb, symbols, input, output);
490	0	} Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::encode_base::<data_encoding::N6, data_encoding::Bt>
491
492	0	fn encode_pad_len<B: Static<usize>, P: Static<Option<u8>>>(bit: B, pad: P, len: usize) -> usize {
493	0	match pad.val() {
494	0	None => encode_base_len(bit, len),
495	0	Some(_) => div_ceil(len, enc(bit.val())) * dec(bit.val()),
496		}
497	0	} Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N1, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N1, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N2, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N2, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N3, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N3, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N4, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N4, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N5, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N5, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N6, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad_len::<data_encoding::N6, data_encoding::On>
498
499	0	fn encode_pad<B: Static<usize>, M: Static<bool>, P: Static<Option<u8>>>(
500	0	bit: B, msb: M, symbols: &[u8; 256], spad: P, input: &[u8], output: &mut [u8],
501	0	) {
502	0	let pad = match spad.val() {
503	0	None => return encode_base(bit, msb, symbols, input, output),
504	0	Some(pad) => pad,
505		};
506	0	debug_assert_eq!(output.len(), encode_pad_len(bit, spad, input.len()));
507	0	let olen = encode_base_len(bit, input.len());
508	0	encode_base(bit, msb, symbols, input, &mut output[.. olen]);
509	0	for output in output.iter_mut().skip(olen) {
510	0	*output = pad;
511	0	}
512	0	} Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N1, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N1, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N1, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N1, data_encoding::Bt, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N2, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N2, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N2, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N2, data_encoding::Bt, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N3, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N3, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N3, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N3, data_encoding::Bt, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N4, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N4, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N4, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N4, data_encoding::Bt, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N5, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N5, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N5, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N5, data_encoding::Bt, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N6, data_encoding::Bf, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N6, data_encoding::Bf, data_encoding::On> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N6, data_encoding::Bt, data_encoding::Os<u8>> Unexecuted instantiation: data_encoding::encode_pad::<data_encoding::N6, data_encoding::Bt, data_encoding::On>
513
514	0	fn encode_wrap_len<
515	0	'a,
516	0	B: Static<usize>,
517	0	P: Static<Option<u8>>,
518	0	W: Static<Option<(usize, &'a [u8])>>,
519	0	>(
520	0	bit: B, pad: P, wrap: W, ilen: usize,
521	0	) -> usize {
522	0	let olen = encode_pad_len(bit, pad, ilen);
523	0	match wrap.val() {
524	0	None => olen,
525	0	Some((col, end)) => olen + end.len() * div_ceil(olen, col),
526		}
527	0	} Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N1, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N1, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N1, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N1, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N2, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N2, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N2, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N2, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N3, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N3, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N3, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N3, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N4, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N4, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N4, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N4, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N5, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N5, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N5, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N5, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N6, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N6, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N6, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_len::<data_encoding::N6, data_encoding::On, data_encoding::Os<(usize, &[u8])>>
528
529	0	fn encode_wrap_mut<
530	0	'a,
531	0	B: Static<usize>,
532	0	M: Static<bool>,
533	0	P: Static<Option<u8>>,
534	0	W: Static<Option<(usize, &'a [u8])>>,
535	0	>(
536	0	bit: B, msb: M, symbols: &[u8; 256], pad: P, wrap: W, input: &[u8], output: &mut [u8],
537	0	) {
538	0	let (col, end) = match wrap.val() {
539	0	None => return encode_pad(bit, msb, symbols, pad, input, output),
540	0	Some((col, end)) => (col, end),
541		};
542	0	debug_assert_eq!(output.len(), encode_wrap_len(bit, pad, wrap, input.len()));
543	0	debug_assert_eq!(col % dec(bit.val()), 0);
544	0	let col = col / dec(bit.val());
545	0	let enc = col * enc(bit.val());
546	0	let dec = col * dec(bit.val()) + end.len();
547	0	let olen = dec - end.len();
548	0	let n = input.len() / enc;
549	0	for i in 0 .. n {
550	0	let input = chunk_unchecked(input, enc, i);
551	0	let output = chunk_mut_unchecked(output, dec, i);
552	0	encode_base(bit, msb, symbols, input, &mut output[.. olen]);
553	0	output[olen ..].copy_from_slice(end);
554	0	}
555	0	if input.len() > enc * n {
556	0	let olen = dec * n + encode_pad_len(bit, pad, input.len() - enc * n);
557	0	encode_pad(bit, msb, symbols, pad, &input[enc * n ..], &mut output[dec * n .. olen]);
558	0	output[olen ..].copy_from_slice(end);
559	0	}
560	0	} Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::On, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::Os<(usize, &[u8])>> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Os<u8>, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::On, data_encoding::On> Unexecuted instantiation: data_encoding::encode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::On, data_encoding::Os<(usize, &[u8])>>
561
562		// Returns the longest valid input length and associated output length.
563	0	fn decode_wrap_len<B: Static<usize>, P: Static<bool>>(
564	0	bit: B, pad: P, len: usize,
565	0	) -> (usize, usize) {
566	0	let bit = bit.val();
567	0	if pad.val() {
568	0	(floor(len, dec(bit)), len / dec(bit) * enc(bit))
569		} else {
570	0	let trail = bit * len % 8;
571	0	(len - trail / bit, bit * len / 8)
572		}
573	0	} Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_len::<data_encoding::N6, data_encoding::Bt>
574
575		// Fails with Length if length is invalid. The error is the largest valid
576		// length.
577	0	fn decode_pad_len<B: Static<usize>, P: Static<bool>>(
578	0	bit: B, pad: P, len: usize,
579	0	) -> Result<usize, DecodeError> {
580	0	let (ilen, olen) = decode_wrap_len(bit, pad, len);
581	0	check!(DecodeError { position: ilen, kind: DecodeKind::Length }, ilen == len);
582	0	Ok(olen)
583	0	} Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_len::<data_encoding::N6, data_encoding::Bt>
584
585		// Fails with Length if length is invalid. The error is the largest valid
586		// length.
587	0	fn decode_base_len<B: Static<usize>>(bit: B, len: usize) -> Result<usize, DecodeError> {
588	0	decode_pad_len(bit, Bf, len)
589	0	} Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N1> Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N2> Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N3> Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N4> Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N5> Unexecuted instantiation: data_encoding::decode_base_len::<data_encoding::N6>
590
591		// Fails with Symbol if an input character does not translate to a symbol. The
592		// error is the lowest index of such character.
593		// Fails with Trailing if there are non-zero trailing bits.
594	0	fn decode_base_mut<B: Static<usize>, M: Static<bool>>(
595	0	bit: B, msb: M, ctb: bool, values: &[u8; 256], input: &[u8], output: &mut [u8],
596	0	) -> Result<usize, DecodePartial> {
597	0	debug_assert_eq!(Ok(output.len()), decode_base_len(bit, input.len()));
598	0	let fail = \|pos, kind\| DecodePartial {
599	0	read: pos / dec(bit.val()) * dec(bit.val()),
600	0	written: pos / dec(bit.val()) * enc(bit.val()),
601	0	error: DecodeError { position: pos, kind },
602	0	}; Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bt>::{closure#0}
603	0	decode_mut(bit, msb, values, input, output).map_err(\|pos\| fail(pos, DecodeKind::Symbol))?; Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bt>::{closure#1}
604	0	check_trail(bit, msb, ctb, values, input)
605	0	.map_err(\|()\| fail(input.len() - 1, DecodeKind::Trailing))?; Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bt>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bt>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bt>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bt>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bt>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bf>::{closure#2} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bt>::{closure#2}
606	0	Ok(output.len())
607	0	} Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N1, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N2, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N3, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N4, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N5, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_base_mut::<data_encoding::N6, data_encoding::Bt>
608
609		// Fails with Symbol if an input character does not translate to a symbol. The
610		// error is the lowest index of such character.
611		// Fails with Padding if some padding length is invalid. The error is the index
612		// of the first padding character of the invalid padding.
613		// Fails with Trailing if there are non-zero trailing bits.
614	0	fn decode_pad_mut<B: Static<usize>, M: Static<bool>, P: Static<bool>>(
615	0	bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, input: &[u8], output: &mut [u8],
616	0	) -> Result<usize, DecodePartial> {
617	0	if !pad.val() {
618	0	return decode_base_mut(bit, msb, ctb, values, input, output);
619	0	}
620	0	debug_assert_eq!(Ok(output.len()), decode_pad_len(bit, pad, input.len()));
621	0	let enc = enc(bit.val());
622	0	let dec = dec(bit.val());
623	0	let mut inpos = 0;
624	0	let mut outpos = 0;
625	0	let mut outend = output.len();
626	0	while inpos < input.len() {
627	0	match decode_base_mut(
628	0	bit,
629	0	msb,
630	0	ctb,
631	0	values,
632	0	&input[inpos ..],
633	0	&mut output[outpos .. outend],
634	0	) {
635	0	Ok(written) => {
636	0	if cfg!(debug_assertions) {
637	0	inpos = input.len();
638	0	}
639	0	outpos += written;
640	0	break;
641		}
642	0	Err(partial) => {
643	0	inpos += partial.read;
644	0	outpos += partial.written;
645	0	}
646		}
647	0	let inlen =
648	0	check_pad(bit, values, &input[inpos .. inpos + dec]).map_err(\|pos\| DecodePartial {
649	0	read: inpos,
650	0	written: outpos,
651	0	error: DecodeError { position: inpos + pos, kind: DecodeKind::Padding },
652	0	})?; Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>::{closure#0}
653	0	let outlen = decode_base_len(bit, inlen).unwrap();
654	0	let written = decode_base_mut(
655	0	bit,
656	0	msb,
657	0	ctb,
658	0	values,
659	0	&input[inpos .. inpos + inlen],
660	0	&mut output[outpos .. outpos + outlen],
661		)
662	0	.map_err(\|partial\| {
663	0	debug_assert_eq!(partial.read, 0);
664	0	debug_assert_eq!(partial.written, 0);
665	0	DecodePartial {
666	0	read: inpos,
667	0	written: outpos,
668	0	error: DecodeError {
669	0	position: inpos + partial.error.position,
670	0	kind: partial.error.kind,
671	0	},
672	0	}
673	0	})?; Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>::{closure#1}
674	0	debug_assert_eq!(written, outlen);
675	0	inpos += dec;
676	0	outpos += outlen;
677	0	outend -= enc - outlen;
678		}
679	0	debug_assert_eq!(inpos, input.len());
680	0	debug_assert_eq!(outpos, outend);
681	0	Ok(outend)
682	0	} Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_pad_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>
683
684	0	fn skip_ignore(values: &[u8; 256], input: &[u8], mut inpos: usize) -> usize {
685	0	while inpos < input.len() && values[input[inpos] as usize] == IGNORE {
686	0	inpos += 1;
687	0	}
688	0	inpos
689	0	}
690
691		// Returns next input and output position.
692		// Fails with Symbol if an input character does not translate to a symbol. The
693		// error is the lowest index of such character.
694		// Fails with Padding if some padding length is invalid. The error is the index
695		// of the first padding character of the invalid padding.
696		// Fails with Trailing if there are non-zero trailing bits.
697	0	fn decode_wrap_block<B: Static<usize>, M: Static<bool>, P: Static<bool>>(
698	0	bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, input: &[u8], output: &mut [u8],
699	0	) -> Result<(usize, usize), DecodeError> {
700	0	let dec = dec(bit.val());
701	0	let mut buf = [0u8; 8];
702	0	let mut shift = [0usize; 8];
703	0	let mut bufpos = 0;
704	0	let mut inpos = 0;
705	0	while bufpos < dec {
706	0	inpos = skip_ignore(values, input, inpos);
707	0	if inpos == input.len() {
708	0	break;
709	0	}
710	0	shift[bufpos] = inpos;
711	0	buf[bufpos] = input[inpos];
712	0	bufpos += 1;
713	0	inpos += 1;
714		}
715	0	let olen = decode_pad_len(bit, pad, bufpos).map_err(\|mut e\| {
716	0	e.position = shift[e.position];
717	0	e
718	0	})?; Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>::{closure#0}
719	0	let written = decode_pad_mut(bit, msb, ctb, values, pad, &buf[.. bufpos], &mut output[.. olen])
720	0	.map_err(\|partial\| {
721	0	debug_assert_eq!(partial.read, 0);
722	0	debug_assert_eq!(partial.written, 0);
723	0	DecodeError { position: shift[partial.error.position], kind: partial.error.kind }
724	0	})?; Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt>::{closure#1} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>::{closure#1}
725	0	Ok((inpos, written))
726	0	} Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_block::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf>
727
728		// Fails with Symbol if an input character does not translate to a symbol. The
729		// error is the lowest index of such character.
730		// Fails with Padding if some padding length is invalid. The error is the index
731		// of the first padding character of the invalid padding.
732		// Fails with Trailing if there are non-zero trailing bits.
733		// Fails with Length if input length (without ignored characters) is invalid.
734		#[allow(clippy::too_many_arguments)]
735	0	fn decode_wrap_mut<B: Static<usize>, M: Static<bool>, P: Static<bool>, I: Static<bool>>(
736	0	bit: B, msb: M, ctb: bool, values: &[u8; 256], pad: P, has_ignore: I, input: &[u8],
737	0	output: &mut [u8],
738	0	) -> Result<usize, DecodePartial> {
739	0	if !has_ignore.val() {
740	0	return decode_pad_mut(bit, msb, ctb, values, pad, input, output);
741	0	}
742	0	debug_assert_eq!(output.len(), decode_wrap_len(bit, pad, input.len()).1);
743	0	let mut inpos = 0;
744	0	let mut outpos = 0;
745	0	while inpos < input.len() {
746	0	let (inlen, outlen) = decode_wrap_len(bit, pad, input.len() - inpos);
747	0	match decode_pad_mut(
748	0	bit,
749	0	msb,
750	0	ctb,
751	0	values,
752	0	pad,
753	0	&input[inpos .. inpos + inlen],
754	0	&mut output[outpos .. outpos + outlen],
755	0	) {
756	0	Ok(written) => {
757	0	inpos += inlen;
758	0	outpos += written;
759	0	break;
760		}
761	0	Err(partial) => {
762	0	inpos += partial.read;
763	0	outpos += partial.written;
764	0	}
765		}
766	0	let (ipos, opos) =
767	0	decode_wrap_block(bit, msb, ctb, values, pad, &input[inpos ..], &mut output[outpos ..])
768	0	.map_err(\|mut error\| {
769	0	error.position += inpos;
770	0	DecodePartial { read: inpos, written: outpos, error }
771	0	})?; Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf>::{closure#0} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>::{closure#0}
772	0	inpos += ipos;
773	0	outpos += opos;
774		}
775	0	let inpos = skip_ignore(values, input, inpos);
776	0	if inpos == input.len() {
777	0	Ok(outpos)
778		} else {
779	0	Err(DecodePartial {
780	0	read: inpos,
781	0	written: outpos,
782	0	error: DecodeError { position: inpos, kind: DecodeKind::Length },
783	0	})
784		}
785	0	} Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N1, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N2, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N3, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N4, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N5, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bf, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bf, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt, data_encoding::Bt> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bt, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf, data_encoding::Bf> Unexecuted instantiation: data_encoding::decode_wrap_mut::<data_encoding::N6, data_encoding::Bt, data_encoding::Bf, data_encoding::Bt>
786
787		/// Order in which bits are read from a byte
788		///
789		/// The base-conversion encoding is always little-endian. This means that the least significant
790		/// byte is always first. However, we can still choose whether, within a byte, this is the most
791		/// significant or the least significant bit that is first. If the terminology is confusing,
792		/// testing on an asymmetrical example should be enough to choose the correct value.
793		///
794		/// # Examples
795		///
796		/// In the following example, we can see that a base with the `MostSignificantFirst` bit-order has
797		/// the most significant bit first in the encoded output. In particular, the output is in the same
798		/// order as the bits in the byte. The opposite happens with the `LeastSignificantFirst` bit-order.
799		/// The least significant bit is first and the output is in the reverse order.
800		///
801		/// ```rust
802		/// use data_encoding::{BitOrder, Specification};
803		/// let mut spec = Specification::new();
804		/// spec.symbols.push_str("01");
805		/// spec.bit_order = BitOrder::MostSignificantFirst; // default
806		/// let msb = spec.encoding().unwrap();
807		/// spec.bit_order = BitOrder::LeastSignificantFirst;
808		/// let lsb = spec.encoding().unwrap();
809		/// assert_eq!(msb.encode(&[0b01010011]), "01010011");
810		/// assert_eq!(lsb.encode(&[0b01010011]), "11001010");
811		/// ```
812		#[derive(Debug, Copy, Clone, PartialEq, Eq)]
813		#[cfg(feature = "alloc")]
814		pub enum BitOrder {
815		/// Most significant bit first
816		///
817		/// This is the most common and most intuitive bit-order. In particular, this is the bit-order
818		/// used by [RFC4648] and thus the usual hexadecimal, base64, base32, base64url, and base32hex
819		/// encodings. This is the default bit-order when [specifying](struct.Specification.html) a
820		/// base.
821		///
822		/// [RFC4648]: https://tools.ietf.org/html/rfc4648
823		MostSignificantFirst,
824
825		/// Least significant bit first
826		///
827		/// # Examples
828		///
829		/// DNSCurve [base32] uses least significant bit first:
830		///
831		/// ```rust
832		/// use data_encoding::BASE32_DNSCURVE;
833		/// assert_eq!(BASE32_DNSCURVE.encode(&[0x64, 0x88]), "4321");
834		/// assert_eq!(BASE32_DNSCURVE.decode(b"4321").unwrap(), vec![0x64, 0x88]);
835		/// ```
836		///
837		/// [base32]: constant.BASE32_DNSCURVE.html
838		LeastSignificantFirst,
839		}
840		#[cfg(feature = "alloc")]
841		use crate::BitOrder::*;
842
843		#[doc(hidden)]
844		#[cfg(feature = "alloc")]
845		pub type InternalEncoding = Cow<'static, [u8]>;
846
847		#[doc(hidden)]
848		#[cfg(not(feature = "alloc"))]
849		pub type InternalEncoding = &'static [u8];
850
851		/// Base-conversion encoding
852		///
853		/// See [Specification](struct.Specification.html) for technical details or how to define a new one.
854		// Required fields:
855		// 0 - 256 (256) symbols
856		// 256 - 512 (256) values
857		// 512 - 513 ( 1) padding
858		// 513 - 514 ( 1) reserved(3),ctb(1),msb(1),bit(3)
859		// Optional fields:
860		// 514 - 515 ( 1) width
861		// 515 - * ( N) separator
862		// Invariants:
863		// - symbols is 2^bit unique characters repeated 2^(8-bit) times
864		// - values[128 ..] are INVALID
865		// - values[0 .. 128] are either INVALID, IGNORE, PADDING, or < 2^bit
866		// - padding is either < 128 or INVALID
867		// - values[padding] is PADDING if padding < 128
868		// - values and symbols are inverse
869		// - ctb is true if 8 % bit == 0
870		// - width is present if there is x such that values[x] is IGNORE
871		// - width % dec(bit) == 0
872		// - for all x in separator values[x] is IGNORE
873		#[derive(Debug, Clone, PartialEq, Eq)]
874		#[repr(transparent)]
875		pub struct Encoding(#[doc(hidden)] pub InternalEncoding);
876
877		/// How to translate characters when decoding
878		///
879		/// The order matters. The first character of the `from` field is translated to the first character
880		/// of the `to` field. The second to the second. Etc.
881		///
882		/// See [Specification](struct.Specification.html) for more information.
883		#[derive(Debug, Clone)]
884		#[cfg(feature = "alloc")]
885		pub struct Translate {
886		/// Characters to translate from
887		pub from: String,
888
889		/// Characters to translate to
890		pub to: String,
891		}
892
893		/// How to wrap the output when encoding
894		///
895		/// See [Specification](struct.Specification.html) for more information.
896		#[derive(Debug, Clone)]
897		#[cfg(feature = "alloc")]
898		pub struct Wrap {
899		/// Wrapping width
900		///
901		/// Must be a multiple of:
902		///
903		/// - 8 for a bit-width of 1 (binary), 3 (octal), and 5 (base32)
904		/// - 4 for a bit-width of 2 (base4) and 6 (base64)
905		/// - 2 for a bit-width of 4 (hexadecimal)
906		///
907		/// Wrapping is disabled if null.
908		pub width: usize,
909
910		/// Wrapping characters
911		///
912		/// Wrapping is disabled if empty.
913		pub separator: String,
914		}
915
916		/// Base-conversion specification
917		///
918		/// It is possible to define custom encodings given a specification. To do so, it is important to
919		/// understand the theory first.
920		///
921		/// # Theory
922		///
923		/// Each subsection has an equivalent subsection in the [Practice](#practice) section.
924		///
925		/// ## Basics
926		///
927		/// The main idea of a [base-conversion] encoding is to see `[u8]` as numbers written in
928		/// little-endian base256 and convert them in another little-endian base. For performance reasons,
929		/// this crate restricts this other base to be of size 2 (binary), 4 (base4), 8 (octal), 16
930		/// (hexadecimal), 32 (base32), or 64 (base64). The converted number is written as `[u8]` although
931		/// it doesn't use all the 256 possible values of `u8`. This crate encodes to ASCII, so only values
932		/// smaller than 128 are allowed.
933		///
934		/// More precisely, we need the following elements:
935		///
936		/// - The bit-width N: 1 for binary, 2 for base4, 3 for octal, 4 for hexadecimal, 5 for base32, and
937		/// 6 for base64
938		/// - The [bit-order](enum.BitOrder.html): most or least significant bit first
939		/// - The symbols function S from [0, 2<sup>N</sup>) (called values and written `uN`) to symbols
940		/// (represented as `u8` although only ASCII symbols are allowed, i.e. smaller than 128)
941		/// - The values partial function V from ASCII to [0, 2<sup>N</sup>), i.e. from `u8` to `uN`
942		/// - Whether trailing bits are checked: trailing bits are leading zeros in theory, but since
943		/// numbers are little-endian they come last
944		///
945		/// For the encoding to be correct (i.e. encoding then decoding gives back the initial input),
946		/// V(S(i)) must be defined and equal to i for all i in [0, 2<sup>N</sup>). For the encoding to be
947		/// [canonical][canonical] (i.e. different inputs decode to different outputs, or equivalently,
948		/// decoding then encoding gives back the initial input), trailing bits must be checked and if V(i)
949		/// is defined then S(V(i)) is equal to i for all i.
950		///
951		/// Encoding and decoding are given by the following pipeline:
952		///
953		/// ```text
954		/// [u8] <--1--> [[bit; 8]] <--2--> [[bit; N]] <--3--> [uN] <--4--> [u8]
955		/// 1: Map bit-order between each u8 and [bit; 8]
956		/// 2: Base conversion between base 2^8 and base 2^N (check trailing bits)
957		/// 3: Map bit-order between each [bit; N] and uN
958		/// 4: Map symbols/values between each uN and u8 (values must be defined)
959		/// ```
960		///
961		/// ## Extensions
962		///
963		/// All these extensions make the encoding not canonical.
964		///
965		/// ### Padding
966		///
967		/// Padding is useful if the following conditions are met:
968		///
969		/// - the bit-width is 3 (octal), 5 (base32), or 6 (base64)
970		/// - the length of the data to encode is not known in advance
971		/// - the data must be sent without buffering
972		///
973		/// Bases for which the bit-width N does not divide 8 may not concatenate encoded data. This comes
974		/// from the fact that it is not possible to make the difference between trailing bits and encoding
975		/// bits. Padding solves this issue by adding a new character to discriminate between trailing bits
976		/// and encoding bits. The idea is to work by blocks of lcm(8, N) bits, where lcm(8, N) is the least
977		/// common multiple of 8 and N. When such block is not complete, it is padded.
978		///
979		/// To preserve correctness, the padding character must not be a symbol.
980		///
981		/// ### Ignore characters when decoding
982		///
983		/// Ignoring characters when decoding is useful if after encoding some characters are added for
984		/// convenience or any other reason (like wrapping). In that case we want to first ignore those
985		/// characters before decoding.
986		///
987		/// To preserve correctness, ignored characters must not contain symbols or the padding character.
988		///
989		/// ### Wrap output when encoding
990		///
991		/// Wrapping output when encoding is useful if the output is meant to be printed in a document where
992		/// width is limited (typically 80-columns documents). In that case, the wrapping width and the
993		/// wrapping separator have to be defined.
994		///
995		/// To preserve correctness, the wrapping separator characters must be ignored (see previous
996		/// subsection). As such, wrapping separator characters must also not contain symbols or the padding
997		/// character.
998		///
999		/// ### Translate characters when decoding
1000		///
1001		/// Translating characters when decoding is useful when encoded data may be copied by a humain
1002		/// instead of a machine. Humans tend to confuse some characters for others. In that case we want to
1003		/// translate those characters before decoding.
1004		///
1005		/// To preserve correctness, the characters we translate _from_ must not contain symbols or the
1006		/// padding character, and the characters we translate _to_ must only contain symbols or the padding
1007		/// character.
1008		///
1009		/// # Practice
1010		///
1011		/// ## Basics
1012		///
1013		/// ```rust
1014		/// use data_encoding::{Encoding, Specification};
1015		/// fn make_encoding(symbols: &str) -> Encoding {
1016		/// let mut spec = Specification::new();
1017		/// spec.symbols.push_str(symbols);
1018		/// spec.encoding().unwrap()
1019		/// }
1020		/// let binary = make_encoding("01");
1021		/// let octal = make_encoding("01234567");
1022		/// let hexadecimal = make_encoding("0123456789abcdef");
1023		/// assert_eq!(binary.encode(b"Bit"), "010000100110100101110100");
1024		/// assert_eq!(octal.encode(b"Bit"), "20464564");
1025		/// assert_eq!(hexadecimal.encode(b"Bit"), "426974");
1026		/// ```
1027		///
1028		/// The `binary` base has 2 symbols `0` and `1` with value 0 and 1 respectively. The `octal` base
1029		/// has 8 symbols `0` to `7` with value 0 to 7. The `hexadecimal` base has 16 symbols `0` to `9` and
1030		/// `a` to `f` with value 0 to 15. The following diagram gives the idea of how encoding works in the
1031		/// previous example (note that we can actually write such diagram only because the bit-order is
1032		/// most significant first):
1033		///
1034		/// ```text
1035		/// [ octal] \| 2 : 0 : 4 : 6 : 4 : 5 : 6 : 4 \|
1036		/// [ binary] \|0 1 0 0 0 0 1 0\|0 1 1 0 1 0 0 1\|0 1 1 1 0 1 0 0\|
1037		/// [hexadecimal] \| 4 : 2 \| 6 : 9 \| 7 : 4 \|
1038		/// ^-- LSB ^-- MSB
1039		/// ```
1040		///
1041		/// Note that in theory, these little-endian numbers are read from right to left (the most
1042		/// significant bit is at the right). Since leading zeros are meaningless (in our usual decimal
1043		/// notation 0123 is the same as 123), it explains why trailing bits must be zero. Trailing bits may
1044		/// occur when the bit-width of a base does not divide 8. Only binary, base4, and hexadecimal don't
1045		/// have trailing bits issues. So let's consider octal and base64, which have trailing bits in
1046		/// similar circumstances:
1047		///
1048		/// ```rust
1049		/// use data_encoding::{Specification, BASE64_NOPAD};
1050		/// let octal = {
1051		/// let mut spec = Specification::new();
1052		/// spec.symbols.push_str("01234567");
1053		/// spec.encoding().unwrap()
1054		/// };
1055		/// assert_eq!(BASE64_NOPAD.encode(b"B"), "Qg");
1056		/// assert_eq!(octal.encode(b"B"), "204");
1057		/// ```
1058		///
1059		/// We have the following diagram, where the base64 values are written between parentheses:
1060		///
1061		/// ```text
1062		/// [base64] \| Q(16) : g(32) : [has 4 zero trailing bits]
1063		/// [ octal] \| 2 : 0 : 4 : [has 1 zero trailing bit ]
1064		/// \|0 1 0 0 0 0 1 0\|0 0 0 0
1065		/// [ ascii] \| B \|
1066		/// ^-^-^-^-- leading zeros / trailing bits
1067		/// ```
1068		///
1069		/// ## Extensions
1070		///
1071		/// ### Padding
1072		///
1073		/// For octal and base64, lcm(8, 3) == lcm(8, 6) == 24 bits or 3 bytes. For base32, lcm(8, 5) is 40
1074		/// bits or 5 bytes. Let's consider octal and base64:
1075		///
1076		/// ```rust
1077		/// use data_encoding::{Specification, BASE64};
1078		/// let octal = {
1079		/// let mut spec = Specification::new();
1080		/// spec.symbols.push_str("01234567");
1081		/// spec.padding = Some('=');
1082		/// spec.encoding().unwrap()
1083		/// };
1084		/// // We start encoding but we only have "B" for now.
1085		/// assert_eq!(BASE64.encode(b"B"), "Qg==");
1086		/// assert_eq!(octal.encode(b"B"), "204=====");
1087		/// // Now we have "it".
1088		/// assert_eq!(BASE64.encode(b"it"), "aXQ=");
1089		/// assert_eq!(octal.encode(b"it"), "322720==");
1090		/// // By concatenating everything, we may decode the original data.
1091		/// assert_eq!(BASE64.decode(b"Qg==aXQ=").unwrap(), b"Bit");
1092		/// assert_eq!(octal.decode(b"204=====322720==").unwrap(), b"Bit");
1093		/// ```
1094		///
1095		/// We have the following diagrams:
1096		///
1097		/// ```text
1098		/// [base64] \| Q(16) : g(32) : = : = \|
1099		/// [ octal] \| 2 : 0 : 4 : = : = : = : = : = \|
1100		/// \|0 1 0 0 0 0 1 0\|. . . . . . . .\|. . . . . . . .\|
1101		/// [ ascii] \| B \| end of block aligned --^
1102		/// ^-- beginning of block aligned
1103		///
1104		/// [base64] \| a(26) : X(23) : Q(16) : = \|
1105		/// [ octal] \| 3 : 2 : 2 : 7 : 2 : 0 : = : = \|
1106		/// \|0 1 1 0 1 0 0 1\|0 1 1 1 0 1 0 0\|. . . . . . . .\|
1107		/// [ ascii] \| i \| t \|
1108		/// ```
1109		///
1110		/// ### Ignore characters when decoding
1111		///
1112		/// The typical use-case is to ignore newlines (`\r` and `\n`). But to keep the example small, we
1113		/// will ignore spaces.
1114		///
1115		/// ```rust
1116		/// let mut spec = data_encoding::HEXLOWER.specification();
1117		/// spec.ignore.push_str(" \t");
1118		/// let base = spec.encoding().unwrap();
1119		/// assert_eq!(base.decode(b"42 69 74"), base.decode(b"426974"));
1120		/// ```
1121		///
1122		/// ### Wrap output when encoding
1123		///
1124		/// The typical use-case is to wrap after 64 or 76 characters with a newline (`\r\n` or `\n`). But
1125		/// to keep the example small, we will wrap after 8 characters with a space.
1126		///
1127		/// ```rust
1128		/// let mut spec = data_encoding::BASE64.specification();
1129		/// spec.wrap.width = 8;
1130		/// spec.wrap.separator.push_str(" ");
1131		/// let base64 = spec.encoding().unwrap();
1132		/// assert_eq!(base64.encode(b"Hey you"), "SGV5IHlv dQ== ");
1133		/// ```
1134		///
1135		/// Note that the output always ends with the separator.
1136		///
1137		/// ### Translate characters when decoding
1138		///
1139		/// The typical use-case is to translate lowercase to uppercase or reciprocally, but it is also used
1140		/// for letters that look alike, like `O0` or `Il1`. Let's illustrate both examples.
1141		///
1142		/// ```rust
1143		/// let mut spec = data_encoding::HEXLOWER.specification();
1144		/// spec.translate.from.push_str("ABCDEFOIl");
1145		/// spec.translate.to.push_str("abcdef011");
1146		/// let base = spec.encoding().unwrap();
1147		/// assert_eq!(base.decode(b"BOIl"), base.decode(b"b011"));
1148		/// ```
1149		///
1150		/// [base-conversion]: https://en.wikipedia.org/wiki/Positional_notation#Base_conversion
1151		/// [canonical]: https://tools.ietf.org/html/rfc4648#section-3.5
1152		#[derive(Debug, Clone)]
1153		#[cfg(feature = "alloc")]
1154		pub struct Specification {
1155		/// Symbols
1156		///
1157		/// The number of symbols must be 2, 4, 8, 16, 32, or 64. Symbols must be ASCII characters
1158		/// (smaller than 128) and they must be unique.
1159		pub symbols: String,
1160
1161		/// Bit-order
1162		///
1163		/// The default is to use most significant bit first since it is the most common.
1164		pub bit_order: BitOrder,
1165
1166		/// Check trailing bits
1167		///
1168		/// The default is to check trailing bits. This field is ignored when unnecessary (i.e. for
1169		/// base2, base4, and base16).
1170		pub check_trailing_bits: bool,
1171
1172		/// Padding
1173		///
1174		/// The default is to not use padding. The padding character must be ASCII and must not be a
1175		/// symbol.
1176		pub padding: Option<char>,
1177
1178		/// Characters to ignore when decoding
1179		///
1180		/// The default is to not ignore characters when decoding. The characters to ignore must be
1181		/// ASCII and must not be symbols or the padding character.
1182		pub ignore: String,
1183
1184		/// How to wrap the output when encoding
1185		///
1186		/// The default is to not wrap the output when encoding. The wrapping characters must be ASCII
1187		/// and must not be symbols or the padding character.
1188		pub wrap: Wrap,
1189
1190		/// How to translate characters when decoding
1191		///
1192		/// The default is to not translate characters when decoding. The characters to translate from
1193		/// must be ASCII and must not have already been assigned a semantics. The characters to
1194		/// translate to must be ASCII and must have been assigned a semantics (symbol, padding
1195		/// character, or ignored character).
1196		pub translate: Translate,
1197		}
1198
1199		#[cfg(feature = "alloc")]
1200		impl Default for Specification {
1201	0	fn default() -> Self {
1202	0	Self::new()
1203	0	}
1204		}
1205
1206		impl Encoding {
1207	0	fn sym(&self) -> &[u8; 256] {
1208	0	self.0[0 .. 256].try_into().unwrap()
1209	0	}
1210
1211	0	fn val(&self) -> &[u8; 256] {
1212	0	self.0[256 .. 512].try_into().unwrap()
1213	0	}
1214
1215	0	fn pad(&self) -> Option<u8> {
1216	0	if self.0[512] < 128 {
1217	0	Some(self.0[512])
1218		} else {
1219	0	None
1220		}
1221	0	}
1222
1223	0	fn ctb(&self) -> bool {
1224	0	self.0[513] & 0x10 != 0
1225	0	}
1226
1227	0	fn msb(&self) -> bool {
1228	0	self.0[513] & 0x8 != 0
1229	0	}
1230
1231	0	fn bit(&self) -> usize {
1232	0	(self.0[513] & 0x7) as usize
1233	0	}
1234
1235		/// Minimum number of input and output blocks when encoding
1236	0	fn block_len(&self) -> (usize, usize) {
1237	0	let bit = self.bit();
1238	0	match self.wrap() {
1239	0	Some((col, end)) => (col / dec(bit) * enc(bit), col + end.len()),
1240	0	None => (enc(bit), dec(bit)),
1241		}
1242	0	}
1243
1244	0	fn wrap(&self) -> Option<(usize, &[u8])> {
1245	0	if self.0.len() <= 515 {
1246	0	return None;
1247	0	}
1248	0	Some((self.0[514] as usize, &self.0[515 ..]))
1249	0	}
1250
1251	0	fn has_ignore(&self) -> bool {
1252	0	self.0.len() >= 515
1253	0	}
1254
1255		/// Returns the encoded length of an input of length `len`
1256		///
1257		/// See [`encode_mut`] for when to use it.
1258		///
1259		/// # Panics
1260		///
1261		/// May panic if `len` is greater than `usize::MAX / 512`:
1262		/// - `len <= 8_388_607` when `target_pointer_width = "32"`
1263		/// - `len <= 36028_797018_963967` when `target_pointer_width = "64"`
1264		///
1265		/// If you need to encode an input of length greater than this limit (possibly of infinite
1266		/// length), then you must chunk your input, encode each chunk, and concatenate to obtain the
1267		/// output. The length of each input chunk must be a multiple of [`encode_align`].
1268		///
1269		/// Note that this function only _may_ panic in those cases. The function may also return the
1270		/// correct value in some cases depending on the implementation. In other words, those limits
1271		/// are the guarantee below which the function will not panic, and not the guarantee above which
1272		/// the function will panic.
1273		///
1274		/// [`encode_align`]: struct.Encoding.html#method.encode_align
1275		/// [`encode_mut`]: struct.Encoding.html#method.encode_mut
1276		#[must_use]
1277	0	pub fn encode_len(&self, len: usize) -> usize {
1278	0	assert!(len <= usize::MAX / 512);
1279	0	dispatch! {
1280	0	let bit: usize = self.bit();
1281	0	let pad: Option<u8> = self.pad();
1282	0	let wrap: Option<(usize, &[u8])> = self.wrap();
1283	0	encode_wrap_len(bit, pad, wrap, len)
1284		}
1285	0	}
1286
1287		/// Returns the minimum alignment when chunking a long input
1288		///
1289		/// See [`encode_len`] for context.
1290		///
1291		/// [`encode_len`]: struct.Encoding.html#method.encode_len
1292		#[must_use]
1293	0	pub fn encode_align(&self) -> usize {
1294	0	let bit = self.bit();
1295	0	match self.wrap() {
1296	0	None => enc(bit),
1297	0	Some((col, _)) => col * bit / 8,
1298		}
1299	0	}
1300
1301		/// Encodes `input` in `output`
1302		///
1303		/// # Panics
1304		///
1305		/// Panics if the `output` length does not match the result of [`encode_len`] for the `input`
1306		/// length.
1307		///
1308		/// # Examples
1309		///
1310		/// ```rust
1311		/// use data_encoding::BASE64;
1312		/// # let mut buffer = vec![0; 100];
1313		/// let input = b"Hello world";
1314		/// let output = &mut buffer[0 .. BASE64.encode_len(input.len())];
1315		/// BASE64.encode_mut(input, output);
1316		/// assert_eq!(output, b"SGVsbG8gd29ybGQ=");
1317		/// ```
1318		///
1319		/// [`encode_len`]: struct.Encoding.html#method.encode_len
1320		#[allow(clippy::cognitive_complexity)]
1321	0	pub fn encode_mut(&self, input: &[u8], output: &mut [u8]) {
1322	0	assert_eq!(output.len(), self.encode_len(input.len()));
1323	0	dispatch! {
1324	0	let bit: usize = self.bit();
1325	0	let msb: bool = self.msb();
1326	0	let pad: Option<u8> = self.pad();
1327	0	let wrap: Option<(usize, &[u8])> = self.wrap();
1328	0	encode_wrap_mut(bit, msb, self.sym(), pad, wrap, input, output)
1329		}
1330	0	}
1331
1332		/// Encodes `input` in `output` and returns it as a `&str`
1333		///
1334		/// It is guaranteed that `output` and the return value only differ by their type. They both
1335		/// point to the same range of memory (pointer and length).
1336		///
1337		/// # Panics
1338		///
1339		/// Panics if the `output` length does not match the result of [`encode_len`] for the `input`
1340		/// length.
1341		///
1342		/// # Examples
1343		///
1344		/// ```rust
1345		/// use data_encoding::BASE64;
1346		/// # let mut buffer = vec![0; 100];
1347		/// let input = b"Hello world";
1348		/// let output = &mut buffer[0 .. BASE64.encode_len(input.len())];
1349		/// assert_eq!(BASE64.encode_mut_str(input, output), "SGVsbG8gd29ybGQ=");
1350		/// ```
1351		///
1352		/// [`encode_len`]: struct.Encoding.html#method.encode_len
1353	0	pub fn encode_mut_str<'a>(&self, input: &[u8], output: &'a mut [u8]) -> &'a str {
1354	0	self.encode_mut(input, output);
1355	0	safety_assert!(output.is_ascii());
1356		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1357	0	unsafe { core::str::from_utf8_unchecked(output) }
1358	0	}
1359
1360		/// Appends the encoding of `input` to `output`
1361		///
1362		/// # Examples
1363		///
1364		/// ```rust
1365		/// use data_encoding::BASE64;
1366		/// # let mut buffer = vec![0; 100];
1367		/// let input = b"Hello world";
1368		/// let mut output = "Result: ".to_string();
1369		/// BASE64.encode_append(input, &mut output);
1370		/// assert_eq!(output, "Result: SGVsbG8gd29ybGQ=");
1371		/// ```
1372		#[cfg(feature = "alloc")]
1373	0	pub fn encode_append(&self, input: &[u8], output: &mut String) {
1374		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted below).
1375	0	let output = unsafe { output.as_mut_vec() };
1376	0	let output_len = output.len();
1377	0	output.resize(output_len + self.encode_len(input.len()), 0u8);
1378	0	self.encode_mut(input, &mut output[output_len ..]);
1379	0	safety_assert!(output[output_len ..].is_ascii());
1380	0	}
1381
1382		/// Returns an object to encode a fragmented input and append it to `output`
1383		///
1384		/// See the documentation of [`Encoder`] for more details and examples.
1385		#[cfg(feature = "alloc")]
1386	0	pub fn new_encoder<'a>(&'a self, output: &'a mut String) -> Encoder<'a> {
1387	0	Encoder::new(self, output)
1388	0	}
1389
1390		/// Writes the encoding of `input` to `output`
1391		///
1392		/// This allocates a buffer of 1024 bytes on the stack. If you want to control the buffer size
1393		/// and location, use [`Encoding::encode_write_buffer()`] instead.
1394		///
1395		/// # Errors
1396		///
1397		/// Returns an error when writing to the output fails.
1398	0	pub fn encode_write(
1399	0	&self, input: &[u8], output: &mut impl core::fmt::Write,
1400	0	) -> core::fmt::Result {
1401	0	self.encode_write_buffer(input, output, &mut [0; 1024])
1402	0	}
1403
1404		/// Writes the encoding of `input` to `output` using a temporary `buffer`
1405		///
1406		/// # Panics
1407		///
1408		/// Panics if the buffer is shorter than 510 bytes.
1409		///
1410		/// # Errors
1411		///
1412		/// Returns an error when writing to the output fails.
1413	0	pub fn encode_write_buffer(
1414	0	&self, input: &[u8], output: &mut impl core::fmt::Write, buffer: &mut [u8],
1415	0	) -> core::fmt::Result {
1416	0	assert!(510 <= buffer.len());
1417	0	let (enc, dec) = self.block_len();
1418	0	for input in input.chunks(buffer.len() / dec * enc) {
1419	0	let buffer = &mut buffer[.. self.encode_len(input.len())];
1420	0	self.encode_mut(input, buffer);
1421	0	safety_assert!(buffer.is_ascii());
1422		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1423	0	output.write_str(unsafe { core::str::from_utf8_unchecked(buffer) })?;
1424		}
1425	0	Ok(())
1426	0	}
1427
1428		/// Returns an object to display the encoding of `input`
1429		///
1430		/// # Examples
1431		///
1432		/// ```rust
1433		/// use data_encoding::BASE64;
1434		/// assert_eq!(
1435		/// format!("Payload: {}", BASE64.encode_display(b"Hello world")),
1436		/// "Payload: SGVsbG8gd29ybGQ=",
1437		/// );
1438		/// ```
1439		#[must_use]
1440	0	pub fn encode_display<'a>(&'a self, input: &'a [u8]) -> Display<'a> {
1441	0	Display { encoding: self, input }
1442	0	}
1443
1444		/// Returns encoded `input`
1445		///
1446		/// # Examples
1447		///
1448		/// ```rust
1449		/// use data_encoding::BASE64;
1450		/// assert_eq!(BASE64.encode(b"Hello world"), "SGVsbG8gd29ybGQ=");
1451		/// ```
1452		#[cfg(feature = "alloc")]
1453		#[must_use]
1454	0	pub fn encode(&self, input: &[u8]) -> String {
1455	0	let mut output = vec![0u8; self.encode_len(input.len())];
1456	0	self.encode_mut(input, &mut output);
1457	0	safety_assert!(output.is_ascii());
1458		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1459	0	unsafe { String::from_utf8_unchecked(output) }
1460	0	}
1461
1462		/// Returns the maximum decoded length of an input of length `len`
1463		///
1464		/// See [`decode_mut`] for when to use it. In particular, the actual decoded length might be
1465		/// smaller if the actual input contains padding or ignored characters.
1466		///
1467		/// # Panics
1468		///
1469		/// May panic if `len` is greater than `usize::MAX / 8`:
1470		/// - `len <= 536_870_911` when `target_pointer_width = "32"`
1471		/// - `len <= 2_305843_009213_693951` when `target_pointer_width = "64"`
1472		///
1473		/// If you need to decode an input of length greater than this limit (possibly of infinite
1474		/// length), then you must decode your input chunk by chunk with [`decode_mut`], making sure
1475		/// that you take into account how many bytes have been read from the input and how many bytes
1476		/// have been written to the output:
1477		/// - `Ok(written)` means all bytes have been read and `written` bytes have been written
1478		/// - `Err(DecodePartial { error, .. })` means an error occurred if `error.kind !=
1479		/// DecodeKind::Length` or this was the last input chunk
1480		/// - `Err(DecodePartial { read, written, .. })` means that `read` bytes have been read and
1481		/// `written` bytes written (the error can be ignored)
1482		///
1483		/// Note that this function only _may_ panic in those cases. The function may also return the
1484		/// correct value in some cases depending on the implementation. In other words, those limits
1485		/// are the guarantee below which the function will not panic, and not the guarantee above which
1486		/// the function will panic.
1487		///
1488		/// # Errors
1489		///
1490		/// Returns an error if `len` is invalid. The error kind is [`Length`] and the [position] is the
1491		/// greatest valid input length.
1492		///
1493		/// [`decode_mut`]: struct.Encoding.html#method.decode_mut
1494		/// [`Length`]: enum.DecodeKind.html#variant.Length
1495		/// [position]: struct.DecodeError.html#structfield.position
1496	0	pub fn decode_len(&self, len: usize) -> Result<usize, DecodeError> {
1497	0	assert!(len <= usize::MAX / 8);
1498	0	let (ilen, olen) = dispatch! {
1499	0	let bit: usize = self.bit();
1500	0	let pad: bool = self.pad().is_some();
1501	0	decode_wrap_len(bit, pad, len)
1502		};
1503	0	check!(
1504	0	DecodeError { position: ilen, kind: DecodeKind::Length },
1505	0	self.has_ignore() \|\| len == ilen
1506		);
1507	0	Ok(olen)
1508	0	}
1509
1510		/// Decodes `input` in `output`
1511		///
1512		/// Returns the length of the decoded output. This length may be smaller than the output length
1513		/// if the input contained padding or ignored characters. The output bytes after the returned
1514		/// length are not initialized and should not be read.
1515		///
1516		/// # Panics
1517		///
1518		/// Panics if the `output` length does not match the result of [`decode_len`] for the `input`
1519		/// length. Also panics if `decode_len` fails for the `input` length.
1520		///
1521		/// # Errors
1522		///
1523		/// Returns an error if `input` is invalid. See [`decode`] for more details. The are two
1524		/// differences though:
1525		///
1526		/// - [`Length`] may be returned only if the encoding allows ignored characters, because
1527		/// otherwise this is already checked by [`decode_len`].
1528		/// - The [`read`] first bytes of the input have been successfully decoded to the [`written`]
1529		/// first bytes of the output.
1530		///
1531		/// # Examples
1532		///
1533		/// ```rust
1534		/// use data_encoding::BASE64;
1535		/// # let mut buffer = vec![0; 100];
1536		/// let input = b"SGVsbA==byB3b3JsZA==";
1537		/// let output = &mut buffer[0 .. BASE64.decode_len(input.len()).unwrap()];
1538		/// let len = BASE64.decode_mut(input, output).unwrap();
1539		/// assert_eq!(&output[0 .. len], b"Hello world");
1540		/// ```
1541		///
1542		/// [`decode_len`]: struct.Encoding.html#method.decode_len
1543		/// [`decode`]: struct.Encoding.html#method.decode
1544		/// [`Length`]: enum.DecodeKind.html#variant.Length
1545		/// [`read`]: struct.DecodePartial.html#structfield.read
1546		/// [`written`]: struct.DecodePartial.html#structfield.written
1547		#[allow(clippy::cognitive_complexity)]
1548	0	pub fn decode_mut(&self, input: &[u8], output: &mut [u8]) -> Result<usize, DecodePartial> {
1549	0	assert_eq!(Ok(output.len()), self.decode_len(input.len()));
1550	0	dispatch! {
1551	0	let bit: usize = self.bit();
1552	0	let msb: bool = self.msb();
1553	0	let pad: bool = self.pad().is_some();
1554	0	let has_ignore: bool = self.has_ignore();
1555	0	decode_wrap_mut(bit, msb, self.ctb(), self.val(), pad, has_ignore,
1556	0	input, output)
1557		}
1558	0	}
1559
1560		/// Returns decoded `input`
1561		///
1562		/// # Errors
1563		///
1564		/// Returns an error if `input` is invalid. The error kind can be:
1565		///
1566		/// - [`Length`] if the input length is invalid. The [position] is the greatest valid input
1567		/// length.
1568		/// - [`Symbol`] if the input contains an invalid character. The [position] is the first invalid
1569		/// character.
1570		/// - [`Trailing`] if the input has non-zero trailing bits. This is only possible if the
1571		/// encoding checks trailing bits. The [position] is the first character containing non-zero
1572		/// trailing bits.
1573		/// - [`Padding`] if the input has an invalid padding length. This is only possible if the
1574		/// encoding uses padding. The [position] is the first padding character of the first padding
1575		/// of invalid length.
1576		///
1577		/// # Examples
1578		///
1579		/// ```rust
1580		/// use data_encoding::BASE64;
1581		/// assert_eq!(BASE64.decode(b"SGVsbA==byB3b3JsZA==").unwrap(), b"Hello world");
1582		/// ```
1583		///
1584		/// [`Length`]: enum.DecodeKind.html#variant.Length
1585		/// [`Symbol`]: enum.DecodeKind.html#variant.Symbol
1586		/// [`Trailing`]: enum.DecodeKind.html#variant.Trailing
1587		/// [`Padding`]: enum.DecodeKind.html#variant.Padding
1588		/// [position]: struct.DecodeError.html#structfield.position
1589		#[cfg(feature = "alloc")]
1590	0	pub fn decode(&self, input: &[u8]) -> Result<Vec<u8>, DecodeError> {
1591	0	let mut output = vec![0u8; self.decode_len(input.len())?];
1592	0	let len = self.decode_mut(input, &mut output).map_err(\|partial\| partial.error)?;
1593	0	output.truncate(len);
1594	0	Ok(output)
1595	0	}
1596
1597		/// Returns the bit-width
1598		#[must_use]
1599	0	pub fn bit_width(&self) -> usize {
1600	0	self.bit()
1601	0	}
1602
1603		/// Returns whether the encoding is canonical
1604		///
1605		/// An encoding is not canonical if one of the following conditions holds:
1606		///
1607		/// - trailing bits are not checked
1608		/// - padding is used
1609		/// - characters are ignored
1610		/// - characters are translated
1611		#[must_use]
1612	0	pub fn is_canonical(&self) -> bool {
1613	0	if !self.ctb() {
1614	0	return false;
1615	0	}
1616	0	let bit = self.bit();
1617	0	let sym = self.sym();
1618	0	let val = self.val();
1619	0	for i in 0 .. 256 {
1620	0	if val[i] == INVALID {
1621	0	continue;
1622	0	}
1623	0	if val[i] >= 1 << bit {
1624	0	return false;
1625	0	}
1626	0	if sym[val[i] as usize] as usize != i {
1627	0	return false;
1628	0	}
1629		}
1630	0	true
1631	0	}
1632
1633		/// Returns the encoding specification
1634		#[allow(clippy::missing_panics_doc)] // no panic
1635		#[cfg(feature = "alloc")]
1636		#[must_use]
1637	0	pub fn specification(&self) -> Specification {
1638	0	let mut specification = Specification::new();
1639	0	specification
1640	0	.symbols
1641	0	.push_str(core::str::from_utf8(&self.sym()[0 .. 1 << self.bit()]).unwrap());
1642		specification.bit_order =
1643	0	if self.msb() { MostSignificantFirst } else { LeastSignificantFirst };
1644	0	specification.check_trailing_bits = self.ctb();
1645	0	if let Some(pad) = self.pad() {
1646	0	specification.padding = Some(pad as char);
1647	0	}
1648	0	for i in 0 .. 128u8 {
1649	0	if self.val()[i as usize] != IGNORE {
1650	0	continue;
1651	0	}
1652	0	specification.ignore.push(i as char);
1653		}
1654	0	if let Some((col, end)) = self.wrap() {
1655	0	specification.wrap.width = col;
1656	0	specification.wrap.separator = core::str::from_utf8(end).unwrap().to_owned();
1657	0	}
1658	0	for i in 0 .. 128u8 {
1659	0	let canonical = if self.val()[i as usize] < 1 << self.bit() {
1660	0	self.sym()[self.val()[i as usize] as usize]
1661	0	} else if self.val()[i as usize] == PADDING {
1662	0	self.pad().unwrap()
1663		} else {
1664	0	continue;
1665		};
1666	0	if i == canonical {
1667	0	continue;
1668	0	}
1669	0	specification.translate.from.push(i as char);
1670	0	specification.translate.to.push(canonical as char);
1671		}
1672	0	specification
1673	0	}
1674
1675		#[doc(hidden)]
1676		#[must_use]
1677	0	pub const fn internal_new(implementation: &'static [u8]) -> Encoding {
1678		#[cfg(feature = "alloc")]
1679	0	let encoding = Encoding(Cow::Borrowed(implementation));
1680		#[cfg(not(feature = "alloc"))]
1681		let encoding = Encoding(implementation);
1682	0	encoding
1683	0	}
1684
1685		#[doc(hidden)]
1686		#[must_use]
1687	0	pub fn internal_implementation(&self) -> &[u8] {
1688	0	&self.0
1689	0	}
1690		}
1691
1692		/// Encodes fragmented input to an output
1693		///
1694		/// It is equivalent to use an [`Encoder`] with multiple calls to [`Encoder::append()`] than to
1695		/// first concatenate all the input and then use [`Encoding::encode_append()`]. In particular, this
1696		/// function will not introduce padding or wrapping between inputs.
1697		///
1698		/// # Examples
1699		///
1700		/// ```rust
1701		/// // This is a bit inconvenient but we can't take a long-term reference to data_encoding::BASE64
1702		/// // because it's a constant. We need to use a static which has an address instead. This will be
1703		/// // fixed in version 3 of the library.
1704		/// static BASE64: data_encoding::Encoding = data_encoding::BASE64;
1705		/// let mut output = String::new();
1706		/// let mut encoder = BASE64.new_encoder(&mut output);
1707		/// encoder.append(b"hello");
1708		/// encoder.append(b"world");
1709		/// encoder.finalize();
1710		/// assert_eq!(output, BASE64.encode(b"helloworld"));
1711		/// ```
1712		#[derive(Debug)]
1713		#[cfg(feature = "alloc")]
1714		pub struct Encoder<'a> {
1715		encoding: &'a Encoding,
1716		output: &'a mut String,
1717		buffer: [u8; 255],
1718		length: u8,
1719		}
1720
1721		#[cfg(feature = "alloc")]
1722		impl Drop for Encoder<'_> {
1723	0	fn drop(&mut self) {
1724	0	self.encoding.encode_append(&self.buffer[.. self.length as usize], self.output);
1725	0	}
1726		}
1727
1728		#[cfg(feature = "alloc")]
1729		impl<'a> Encoder<'a> {
1730	0	fn new(encoding: &'a Encoding, output: &'a mut String) -> Self {
1731	0	Encoder { encoding, output, buffer: [0; 255], length: 0 }
1732	0	}
1733
1734		/// Encodes the provided input fragment and appends the result to the output
1735	0	pub fn append(&mut self, mut input: &[u8]) {
1736		#[allow(clippy::cast_possible_truncation)] // no truncation
1737	0	let max = self.encoding.block_len().0 as u8;
1738	0	if self.length != 0 {
1739	0	let len = self.length;
1740		#[allow(clippy::cast_possible_truncation)] // no truncation
1741	0	let add = core::cmp::min((max - len) as usize, input.len()) as u8;
1742	0	self.buffer[len as usize ..][.. add as usize].copy_from_slice(&input[.. add as usize]);
1743	0	self.length += add;
1744	0	input = &input[add as usize ..];
1745	0	if self.length != max {
1746	0	debug_assert!(self.length < max);
1747	0	debug_assert!(input.is_empty());
1748	0	return;
1749	0	}
1750	0	self.encoding.encode_append(&self.buffer[.. max as usize], self.output);
1751	0	self.length = 0;
1752	0	}
1753	0	let len = floor(input.len(), max as usize);
1754	0	self.encoding.encode_append(&input[.. len], self.output);
1755	0	input = &input[len ..];
1756		#[allow(clippy::cast_possible_truncation)] // no truncation
1757	0	let len = input.len() as u8;
1758	0	self.buffer[.. len as usize].copy_from_slice(input);
1759	0	self.length = len;
1760	0	}
1761
1762		/// Makes sure all inputs have been encoded and appended to the output
1763		///
1764		/// This is equivalent to dropping the encoder and required for correctness, otherwise some
1765		/// encoded data may be missing at the end.
1766	0	pub fn finalize(self) {}
1767		}
1768
1769		/// Wraps an encoding and input for display purposes.
1770		#[derive(Debug)]
1771		pub struct Display<'a> {
1772		encoding: &'a Encoding,
1773		input: &'a [u8],
1774		}
1775
1776		impl core::fmt::Display for Display<'_> {
1777	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1778	0	self.encoding.encode_write(self.input, f)
1779	0	}
1780		}
1781
1782		#[derive(Debug, Copy, Clone)]
1783		#[cfg(feature = "alloc")]
1784		enum SpecificationErrorImpl {
1785		BadSize,
1786		NotAscii,
1787		Duplicate(u8),
1788		ExtraPadding,
1789		WrapLength,
1790		WrapWidth(u8),
1791		FromTo,
1792		Undefined(u8),
1793		}
1794		#[cfg(feature = "alloc")]
1795		use crate::SpecificationErrorImpl::*;
1796
1797		/// Specification error
1798		#[derive(Debug, Copy, Clone)]
1799		#[cfg(feature = "alloc")]
1800		pub struct SpecificationError(SpecificationErrorImpl);
1801
1802		#[cfg(feature = "alloc")]
1803		impl core::fmt::Display for SpecificationError {
1804	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1805	0	match self.0 {
1806	0	BadSize => write!(f, "invalid number of symbols"),
1807	0	NotAscii => write!(f, "non-ascii character"),
1808	0	Duplicate(c) => write!(f, "{:?} has conflicting definitions", c as char),
1809	0	ExtraPadding => write!(f, "unnecessary padding"),
1810	0	WrapLength => write!(f, "invalid wrap width or separator length"),
1811	0	WrapWidth(x) => write!(f, "wrap width not a multiple of {}", x),
1812	0	FromTo => write!(f, "translate from/to length mismatch"),
1813	0	Undefined(c) => write!(f, "{:?} is undefined", c as char),
1814		}
1815	0	}
1816		}
1817
1818		#[cfg(feature = "std")]
1819		impl std::error::Error for SpecificationError {
1820	0	fn description(&self) -> &str {
1821	0	match self.0 {
1822	0	BadSize => "invalid number of symbols",
1823	0	NotAscii => "non-ascii character",
1824	0	Duplicate(_) => "conflicting definitions",
1825	0	ExtraPadding => "unnecessary padding",
1826	0	WrapLength => "invalid wrap width or separator length",
1827	0	WrapWidth(_) => "wrap width not a multiple",
1828	0	FromTo => "translate from/to length mismatch",
1829	0	Undefined(_) => "undefined character",
1830		}
1831	0	}
1832		}
1833
1834		#[cfg(feature = "alloc")]
1835		impl Specification {
1836		/// Returns a default specification
1837		#[must_use]
1838	0	pub fn new() -> Specification {
1839	0	Specification {
1840	0	symbols: String::new(),
1841	0	bit_order: MostSignificantFirst,
1842	0	check_trailing_bits: true,
1843	0	padding: None,
1844	0	ignore: String::new(),
1845	0	wrap: Wrap { width: 0, separator: String::new() },
1846	0	translate: Translate { from: String::new(), to: String::new() },
1847	0	}
1848	0	}
1849
1850		/// Returns the specified encoding
1851		///
1852		/// # Errors
1853		///
1854		/// Returns an error if the specification is invalid.
1855	0	pub fn encoding(&self) -> Result<Encoding, SpecificationError> {
1856	0	let symbols = self.symbols.as_bytes();
1857	0	let bit: u8 = match symbols.len() {
1858	0	2 => 1,
1859	0	4 => 2,
1860	0	8 => 3,
1861	0	16 => 4,
1862	0	32 => 5,
1863	0	64 => 6,
1864	0	_ => return Err(SpecificationError(BadSize)),
1865		};
1866	0	let mut values = [INVALID; 128];
1867	0	let set = \|v: &mut [u8; 128], i: u8, x: u8\| {
1868	0	check!(SpecificationError(NotAscii), i < 128);
1869	0	if v[i as usize] == x {
1870	0	return Ok(());
1871	0	}
1872	0	check!(SpecificationError(Duplicate(i)), v[i as usize] == INVALID);
1873	0	v[i as usize] = x;
1874	0	Ok(())
1875	0	};
1876	0	for (v, symbols) in symbols.iter().enumerate() {
1877		#[allow(clippy::cast_possible_truncation)] // no truncation
1878	0	set(&mut values, *symbols, v as u8)?;
1879		}
1880	0	let msb = self.bit_order == MostSignificantFirst;
1881	0	let ctb = self.check_trailing_bits \|\| 8 % bit == 0;
1882	0	let pad = match self.padding {
1883	0	None => None,
1884	0	Some(pad) => {
1885	0	check!(SpecificationError(ExtraPadding), 8 % bit != 0);
1886	0	check!(SpecificationError(NotAscii), pad.len_utf8() == 1);
1887	0	set(&mut values, pad as u8, PADDING)?;
1888	0	Some(pad as u8)
1889		}
1890		};
1891	0	for i in self.ignore.bytes() {
1892	0	set(&mut values, i, IGNORE)?;
1893		}
1894	0	let wrap = if self.wrap.separator.is_empty() \|\| self.wrap.width == 0 {
1895	0	None
1896		} else {
1897	0	let col = self.wrap.width;
1898	0	let end = self.wrap.separator.as_bytes();
1899	0	check!(SpecificationError(WrapLength), col < 256 && end.len() < 256);
1900		#[allow(clippy::cast_possible_truncation)] // no truncation
1901	0	let col = col as u8;
1902		#[allow(clippy::cast_possible_truncation)] // no truncation
1903	0	let dec = dec(bit as usize) as u8;
1904	0	check!(SpecificationError(WrapWidth(dec)), col % dec == 0);
1905	0	for &i in end {
1906	0	set(&mut values, i, IGNORE)?;
1907		}
1908	0	Some((col, end))
1909		};
1910	0	let from = self.translate.from.as_bytes();
1911	0	let to = self.translate.to.as_bytes();
1912	0	check!(SpecificationError(FromTo), from.len() == to.len());
1913	0	for i in 0 .. from.len() {
1914	0	check!(SpecificationError(NotAscii), to[i] < 128);
1915	0	let v = values[to[i] as usize];
1916	0	check!(SpecificationError(Undefined(to[i])), v != INVALID);
1917	0	set(&mut values, from[i], v)?;
1918		}
1919	0	let mut encoding = Vec::new();
1920	0	for _ in 0 .. 256 / symbols.len() {
1921	0	encoding.extend_from_slice(symbols);
1922	0	}
1923	0	encoding.extend_from_slice(&values);
1924	0	encoding.extend_from_slice(&[INVALID; 128]);
1925	0	match pad {
1926	0	None => encoding.push(INVALID),
1927	0	Some(pad) => encoding.push(pad),
1928		}
1929	0	encoding.push(bit);
1930	0	if msb {
1931	0	encoding[513] \|= 0x08;
1932	0	}
1933	0	if ctb {
1934	0	encoding[513] \|= 0x10;
1935	0	}
1936	0	if let Some((col, end)) = wrap {
1937	0	encoding.push(col);
1938	0	encoding.extend_from_slice(end);
1939	0	} else if values.contains(&IGNORE) {
1940	0	encoding.push(0);
1941	0	}
1942	0	Ok(Encoding(Cow::Owned(encoding)))
1943	0	}
1944		}
1945
1946		/// Lowercase hexadecimal encoding
1947		///
1948		/// This encoding is a static version of:
1949		///
1950		/// ```rust
1951		/// # use data_encoding::{Specification, HEXLOWER};
1952		/// let mut spec = Specification::new();
1953		/// spec.symbols.push_str("0123456789abcdef");
1954		/// assert_eq!(HEXLOWER, spec.encoding().unwrap());
1955		/// ```
1956		///
1957		/// # Examples
1958		///
1959		/// ```rust
1960		/// use data_encoding::HEXLOWER;
1961		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
1962		/// assert_eq!(HEXLOWER.decode(b"deadbeef").unwrap(), deadbeef);
1963		/// assert_eq!(HEXLOWER.encode(&deadbeef), "deadbeef");
1964		/// ```
1965		pub const HEXLOWER: Encoding = Encoding::internal_new(HEXLOWER_IMPL);
1966		const HEXLOWER_IMPL: &[u8] = &[
1967		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
1968		55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1969		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1970		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1971		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1972		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1973		56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1974		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1975		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1976		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1977		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1978		56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1979		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1980		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 1, 2,
1981		3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1982		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1983		128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1984		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1985		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1986		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1987		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1988		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1989		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1990		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1991		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
1992		];
1993
1994		/// Lowercase hexadecimal encoding with case-insensitive decoding
1995		///
1996		/// This encoding is a static version of:
1997		///
1998		/// ```rust
1999		/// # use data_encoding::{Specification, HEXLOWER_PERMISSIVE};
2000		/// let mut spec = Specification::new();
2001		/// spec.symbols.push_str("0123456789abcdef");
2002		/// spec.translate.from.push_str("ABCDEF");
2003		/// spec.translate.to.push_str("abcdef");
2004		/// assert_eq!(HEXLOWER_PERMISSIVE, spec.encoding().unwrap());
2005		/// ```
2006		///
2007		/// # Examples
2008		///
2009		/// ```rust
2010		/// use data_encoding::HEXLOWER_PERMISSIVE;
2011		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
2012		/// assert_eq!(HEXLOWER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
2013		/// assert_eq!(HEXLOWER_PERMISSIVE.encode(&deadbeef), "deadbeef");
2014		/// ```
2015		///
2016		/// You can also define a shorter name:
2017		///
2018		/// ```rust
2019		/// use data_encoding::{Encoding, HEXLOWER_PERMISSIVE};
2020		/// const HEX: Encoding = HEXLOWER_PERMISSIVE;
2021		/// ```
2022		pub const HEXLOWER_PERMISSIVE: Encoding = Encoding::internal_new(HEXLOWER_PERMISSIVE_IMPL);
2023		const HEXLOWER_PERMISSIVE_IMPL: &[u8] = &[
2024		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
2025		55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
2026		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
2027		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
2028		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
2029		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
2030		56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
2031		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
2032		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
2033		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
2034		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
2035		56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2036		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2037		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 1, 2,
2038		3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128,
2039		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2040		128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2041		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2042		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2043		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2044		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2045		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2046		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2047		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2048		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
2049		];
2050
2051		/// Uppercase hexadecimal encoding
2052		///
2053		/// This encoding is a static version of:
2054		///
2055		/// ```rust
2056		/// # use data_encoding::{Specification, HEXUPPER};
2057		/// let mut spec = Specification::new();
2058		/// spec.symbols.push_str("0123456789ABCDEF");
2059		/// assert_eq!(HEXUPPER, spec.encoding().unwrap());
2060		/// ```
2061		///
2062		/// It is compliant with [RFC4648] and known as "base16" or "hex".
2063		///
2064		/// # Examples
2065		///
2066		/// ```rust
2067		/// use data_encoding::HEXUPPER;
2068		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
2069		/// assert_eq!(HEXUPPER.decode(b"DEADBEEF").unwrap(), deadbeef);
2070		/// assert_eq!(HEXUPPER.encode(&deadbeef), "DEADBEEF");
2071		/// ```
2072		///
2073		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-8
2074		pub const HEXUPPER: Encoding = Encoding::internal_new(HEXUPPER_IMPL);
2075		const HEXUPPER_IMPL: &[u8] = &[
2076		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2077		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2078		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2079		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2080		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2081		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2082		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2083		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2084		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2085		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2086		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 128, 128, 128, 128, 128, 128,
2087		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2088		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2089		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2090		12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2091		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2092		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2093		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2094		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2095		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2096		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2097		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2098		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2099		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
2100		];
2101
2102		/// Uppercase hexadecimal encoding with case-insensitive decoding
2103		///
2104		/// This encoding is a static version of:
2105		///
2106		/// ```rust
2107		/// # use data_encoding::{Specification, HEXUPPER_PERMISSIVE};
2108		/// let mut spec = Specification::new();
2109		/// spec.symbols.push_str("0123456789ABCDEF");
2110		/// spec.translate.from.push_str("abcdef");
2111		/// spec.translate.to.push_str("ABCDEF");
2112		/// assert_eq!(HEXUPPER_PERMISSIVE, spec.encoding().unwrap());
2113		/// ```
2114		///
2115		/// # Examples
2116		///
2117		/// ```rust
2118		/// use data_encoding::HEXUPPER_PERMISSIVE;
2119		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
2120		/// assert_eq!(HEXUPPER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
2121		/// assert_eq!(HEXUPPER_PERMISSIVE.encode(&deadbeef), "DEADBEEF");
2122		/// ```
2123		pub const HEXUPPER_PERMISSIVE: Encoding = Encoding::internal_new(HEXUPPER_PERMISSIVE_IMPL);
2124		const HEXUPPER_PERMISSIVE_IMPL: &[u8] = &[
2125		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2126		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2127		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2128		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2129		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2130		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2131		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2132		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2133		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2134		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2135		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 128, 128, 128, 128, 128, 128,
2136		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2137		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2138		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2139		12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2140		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128,
2141		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2142		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2143		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2144		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2145		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2146		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2147		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2148		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
2149		];
2150
2151		/// Padded base32 encoding
2152		///
2153		/// This encoding is a static version of:
2154		///
2155		/// ```rust
2156		/// # use data_encoding::{Specification, BASE32};
2157		/// let mut spec = Specification::new();
2158		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2159		/// spec.padding = Some('=');
2160		/// assert_eq!(BASE32, spec.encoding().unwrap());
2161		/// ```
2162		///
2163		/// It conforms to [RFC4648].
2164		///
2165		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-6
2166		pub const BASE32: Encoding = Encoding::internal_new(BASE32_IMPL);
2167		const BASE32_IMPL: &[u8] = &[
2168		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2169		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2170		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2171		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2172		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2173		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2174		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2175		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2176		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2177		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2178		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2179		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2180		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2181		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 130, 128, 128,
2182		128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2183		25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2184		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2185		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2186		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2187		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2188		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2189		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2190		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2191		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
2192		];
2193
2194		/// Unpadded base32 encoding
2195		///
2196		/// This encoding is a static version of:
2197		///
2198		/// ```rust
2199		/// # use data_encoding::{Specification, BASE32_NOPAD};
2200		/// let mut spec = Specification::new();
2201		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2202		/// assert_eq!(BASE32_NOPAD, spec.encoding().unwrap());
2203		/// ```
2204		pub const BASE32_NOPAD: Encoding = Encoding::internal_new(BASE32_NOPAD_IMPL);
2205		const BASE32_NOPAD_IMPL: &[u8] = &[
2206		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2207		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2208		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2209		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2210		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2211		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2212		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2213		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2214		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2215		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2216		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2217		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2218		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2219		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128,
2220		128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2221		25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2222		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2223		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2224		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2225		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2226		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2227		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2228		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2229		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2230		];
2231
2232		/// Unpadded base32 encoding with case-insensitive decoding
2233		///
2234		/// This encoding is a static version of:
2235		///
2236		/// ```rust
2237		/// # use data_encoding::{Specification, BASE32_NOPAD_NOCASE};
2238		/// let mut spec = Specification::new();
2239		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2240		/// spec.translate.from.push_str("abcdefghijklmnopqrstuvwxyz");
2241		/// spec.translate.to.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
2242		/// assert_eq!(BASE32_NOPAD_NOCASE, spec.encoding().unwrap());
2243		/// ```
2244		pub const BASE32_NOPAD_NOCASE: Encoding = Encoding::internal_new(BASE32_NOPAD_NOCASE_IMPL);
2245		const BASE32_NOPAD_NOCASE_IMPL: &[u8] = &[
2246		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2247		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2248		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2249		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2250		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2251		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2252		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2253		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2254		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2255		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2256		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2257		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2258		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2259		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128,
2260		128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
2261		25, 128, 128, 128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
2262		18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2263		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2264		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2265		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2266		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2267		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2268		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2269		128, 128, 128, 128, 128, 128, 128, 128, 29,
2270		];
2271
2272		/// Unpadded base32 encoding with visual error correction during decoding
2273		///
2274		/// This encoding is a static version of:
2275		///
2276		/// ```rust
2277		/// # use data_encoding::{Specification, BASE32_NOPAD_VISUAL};
2278		/// let mut spec = Specification::new();
2279		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2280		/// spec.translate.from.push_str("01l8");
2281		/// spec.translate.to.push_str("OIIB");
2282		/// assert_eq!(BASE32_NOPAD_VISUAL, spec.encoding().unwrap());
2283		/// ```
2284		pub const BASE32_NOPAD_VISUAL: Encoding = Encoding::internal_new(BASE32_NOPAD_VISUAL_IMPL);
2285		const BASE32_NOPAD_VISUAL_IMPL: &[u8] = &[
2286		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2287		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2288		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2289		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2290		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2291		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2292		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2293		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2294		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2295		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2296		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2297		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2298		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2299		128, 128, 128, 128, 14, 8, 26, 27, 28, 29, 30, 31, 1, 128, 128, 128, 128, 128, 128, 128, 128,
2300		0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2301		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 8, 128,
2302		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2303		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2304		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2305		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2306		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2307		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2308		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2309		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2310		];
2311
2312		/// Padded base32hex encoding
2313		///
2314		/// This encoding is a static version of:
2315		///
2316		/// ```rust
2317		/// # use data_encoding::{Specification, BASE32HEX};
2318		/// let mut spec = Specification::new();
2319		/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
2320		/// spec.padding = Some('=');
2321		/// assert_eq!(BASE32HEX, spec.encoding().unwrap());
2322		/// ```
2323		///
2324		/// It conforms to [RFC4648].
2325		///
2326		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-7
2327		pub const BASE32HEX: Encoding = Encoding::internal_new(BASE32HEX_IMPL);
2328		const BASE32HEX_IMPL: &[u8] = &[
2329		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2330		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2331		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2332		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2333		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2334		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2335		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2336		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2337		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2338		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2339		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
2340		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2341		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2342		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 130, 128, 128, 128, 10, 11,
2343		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
2344		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2345		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2346		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2347		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2348		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2349		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2350		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2351		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2352		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
2353		];
2354
2355		/// Unpadded base32hex encoding
2356		///
2357		/// This encoding is a static version of:
2358		///
2359		/// ```rust
2360		/// # use data_encoding::{Specification, BASE32HEX_NOPAD};
2361		/// let mut spec = Specification::new();
2362		/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
2363		/// assert_eq!(BASE32HEX_NOPAD, spec.encoding().unwrap());
2364		/// ```
2365		pub const BASE32HEX_NOPAD: Encoding = Encoding::internal_new(BASE32HEX_NOPAD_IMPL);
2366		const BASE32HEX_NOPAD_IMPL: &[u8] = &[
2367		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2368		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2369		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2370		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2371		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2372		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2373		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2374		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2375		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2376		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2377		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
2378		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2379		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2380		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2381		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
2382		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2383		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2384		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2385		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2386		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2387		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2388		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2389		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2390		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2391		];
2392
2393		/// DNSSEC base32 encoding
2394		///
2395		/// This encoding is a static version of:
2396		///
2397		/// ```rust
2398		/// # use data_encoding::{Specification, BASE32_DNSSEC};
2399		/// let mut spec = Specification::new();
2400		/// spec.symbols.push_str("0123456789abcdefghijklmnopqrstuv");
2401		/// spec.translate.from.push_str("ABCDEFGHIJKLMNOPQRSTUV");
2402		/// spec.translate.to.push_str("abcdefghijklmnopqrstuv");
2403		/// assert_eq!(BASE32_DNSSEC, spec.encoding().unwrap());
2404		/// ```
2405		///
2406		/// It conforms to [RFC5155]:
2407		///
2408		/// - It uses a base32 extended hex alphabet.
2409		/// - It is case-insensitive when decoding and uses lowercase when encoding.
2410		/// - It does not use padding.
2411		///
2412		/// [RFC5155]: https://tools.ietf.org/html/rfc5155
2413		pub const BASE32_DNSSEC: Encoding = Encoding::internal_new(BASE32_DNSSEC_IMPL);
2414		const BASE32_DNSSEC_IMPL: &[u8] = &[
2415		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
2416		108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
2417		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2418		116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104,
2419		105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53,
2420		54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
2421		113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101,
2422		102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49,
2423		50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
2424		110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98,
2425		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2426		118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
2427		107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 128, 128, 128, 128, 128, 128, 128,
2428		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2429		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2430		128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13,
2431		14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128,
2432		128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2433		26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2434		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2435		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2436		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2437		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2438		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2439		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2440		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2441		];
2442
2443		#[allow(clippy::doc_markdown)]
2444		/// DNSCurve base32 encoding
2445		///
2446		/// This encoding is a static version of:
2447		///
2448		/// ```rust
2449		/// # use data_encoding::{BitOrder, Specification, BASE32_DNSCURVE};
2450		/// let mut spec = Specification::new();
2451		/// spec.symbols.push_str("0123456789bcdfghjklmnpqrstuvwxyz");
2452		/// spec.bit_order = BitOrder::LeastSignificantFirst;
2453		/// spec.translate.from.push_str("BCDFGHJKLMNPQRSTUVWXYZ");
2454		/// spec.translate.to.push_str("bcdfghjklmnpqrstuvwxyz");
2455		/// assert_eq!(BASE32_DNSCURVE, spec.encoding().unwrap());
2456		/// ```
2457		///
2458		/// It conforms to [DNSCurve].
2459		///
2460		/// [DNSCurve]: https://dnscurve.org/in-implement.html
2461		pub const BASE32_DNSCURVE: Encoding = Encoding::internal_new(BASE32_DNSCURVE_IMPL);
2462		const BASE32_DNSCURVE_IMPL: &[u8] = &[
2463		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110,
2464		112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
2465		98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119,
2466		120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107,
2467		108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53,
2468		54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116,
2469		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103,
2470		104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49,
2471		50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113,
2472		114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99,
2473		100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2474		122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109,
2475		110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 128, 128, 128, 128, 128, 128, 128,
2476		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2477		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2478		128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2479		12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
2480		128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128,
2481		21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2482		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2483		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2484		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2485		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2486		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2487		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2488		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 21,
2489		];
2490
2491		/// Padded base64 encoding
2492		///
2493		/// This encoding is a static version of:
2494		///
2495		/// ```rust
2496		/// # use data_encoding::{Specification, BASE64};
2497		/// let mut spec = Specification::new();
2498		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2499		/// spec.padding = Some('=');
2500		/// assert_eq!(BASE64, spec.encoding().unwrap());
2501		/// ```
2502		///
2503		/// It conforms to [RFC4648].
2504		///
2505		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-4
2506		pub const BASE64: Encoding = Encoding::internal_new(BASE64_IMPL);
2507		const BASE64_IMPL: &[u8] = &[
2508		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2509		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2510		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2511		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2512		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2513		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2514		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2515		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2516		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2517		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2518		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2519		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2520		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2521		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2522		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2523		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2524		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2525		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2526		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2527		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2528		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2529		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2530		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2531		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2532		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
2533		];
2534
2535		/// Unpadded base64 encoding
2536		///
2537		/// This encoding is a static version of:
2538		///
2539		/// ```rust
2540		/// # use data_encoding::{Specification, BASE64_NOPAD};
2541		/// let mut spec = Specification::new();
2542		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2543		/// assert_eq!(BASE64_NOPAD, spec.encoding().unwrap());
2544		/// ```
2545		pub const BASE64_NOPAD: Encoding = Encoding::internal_new(BASE64_NOPAD_IMPL);
2546		const BASE64_NOPAD_IMPL: &[u8] = &[
2547		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2548		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2549		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2550		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2551		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2552		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2553		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2554		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2555		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2556		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2557		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2558		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2559		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2560		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2561		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
2562		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2563		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2564		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2565		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2566		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2567		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2568		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2569		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2570		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2571		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
2572		];
2573
2574		/// MIME base64 encoding
2575		///
2576		/// This encoding is a static version of:
2577		///
2578		/// ```rust
2579		/// # use data_encoding::{Specification, BASE64_MIME};
2580		/// let mut spec = Specification::new();
2581		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2582		/// spec.padding = Some('=');
2583		/// spec.wrap.width = 76;
2584		/// spec.wrap.separator.push_str("\r\n");
2585		/// assert_eq!(BASE64_MIME, spec.encoding().unwrap());
2586		/// ```
2587		///
2588		/// It does not exactly conform to [RFC2045] because it does not print the header
2589		/// and does not ignore all characters.
2590		///
2591		/// [RFC2045]: https://tools.ietf.org/html/rfc2045
2592		pub const BASE64_MIME: Encoding = Encoding::internal_new(BASE64_MIME_IMPL);
2593		const BASE64_MIME_IMPL: &[u8] = &[
2594		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2595		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2596		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2597		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2598		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2599		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2600		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2601		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2602		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2603		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2604		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2605		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2606		128, 128, 128, 128, 128, 128, 129, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2607		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2608		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2609		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2610		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2611		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2612		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2613		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2614		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2615		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2616		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2617		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2618		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30, 76, 13, 10,
2619		];
2620
2621		/// MIME base64 encoding without trailing bits check
2622		///
2623		/// This encoding is a static version of:
2624		///
2625		/// ```rust
2626		/// # use data_encoding::{Specification, BASE64_MIME_PERMISSIVE};
2627		/// let mut spec = Specification::new();
2628		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2629		/// spec.padding = Some('=');
2630		/// spec.wrap.width = 76;
2631		/// spec.wrap.separator.push_str("\r\n");
2632		/// spec.check_trailing_bits = false;
2633		/// assert_eq!(BASE64_MIME_PERMISSIVE, spec.encoding().unwrap());
2634		/// ```
2635		///
2636		/// It does not exactly conform to [RFC2045] because it does not print the header
2637		/// and does not ignore all characters.
2638		///
2639		/// [RFC2045]: https://tools.ietf.org/html/rfc2045
2640		pub const BASE64_MIME_PERMISSIVE: Encoding = Encoding::internal_new(BASE64_MIME_PERMISSIVE_IMPL);
2641		const BASE64_MIME_PERMISSIVE_IMPL: &[u8] = &[
2642		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2643		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2644		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2645		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2646		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2647		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2648		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2649		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2650		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2651		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2652		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2653		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2654		128, 128, 128, 128, 128, 128, 129, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2655		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2656		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2657		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2658		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2659		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2660		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2661		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2662		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2663		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2664		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2665		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2666		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 14, 76, 13, 10,
2667		];
2668
2669		/// Padded base64url encoding
2670		///
2671		/// This encoding is a static version of:
2672		///
2673		/// ```rust
2674		/// # use data_encoding::{Specification, BASE64URL};
2675		/// let mut spec = Specification::new();
2676		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
2677		/// spec.padding = Some('=');
2678		/// assert_eq!(BASE64URL, spec.encoding().unwrap());
2679		/// ```
2680		///
2681		/// It conforms to [RFC4648].
2682		///
2683		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-5
2684		pub const BASE64URL: Encoding = Encoding::internal_new(BASE64URL_IMPL);
2685		const BASE64URL_IMPL: &[u8] = &[
2686		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2687		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2688		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
2689		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2690		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2691		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
2692		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2693		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2694		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
2695		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2696		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2697		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
2698		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2699		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2700		128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2701		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2702		24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2703		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2704		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2705		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2706		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2707		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2708		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2709		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2710		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
2711		];
2712
2713		/// Unpadded base64url encoding
2714		///
2715		/// This encoding is a static version of:
2716		///
2717		/// ```rust
2718		/// # use data_encoding::{Specification, BASE64URL_NOPAD};
2719		/// let mut spec = Specification::new();
2720		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
2721		/// assert_eq!(BASE64URL_NOPAD, spec.encoding().unwrap());
2722		/// ```
2723		pub const BASE64URL_NOPAD: Encoding = Encoding::internal_new(BASE64URL_NOPAD_IMPL);
2724		const BASE64URL_NOPAD_IMPL: &[u8] = &[
2725		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2726		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2727		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
2728		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2729		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2730		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
2731		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2732		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2733		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
2734		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2735		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2736		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
2737		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2738		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2739		128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
2740		128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
2741		24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2742		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2743		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2744		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2745		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2746		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2747		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2748		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2749		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
2750		];

Coverage Report

Created: 2026-01-22 07:09