/rust/registry/src/index.crates.io-1949cf8c6b5b557f/data-encoding-2.9.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_auto_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		/// [`encode_mut`]: struct.Encoding.html#method.encode_mut
1260		#[must_use]
1261	0	pub fn encode_len(&self, len: usize) -> usize {
1262	0	dispatch! {
1263	0	let bit: usize = self.bit();
1264	0	let pad: Option<u8> = self.pad();
1265	0	let wrap: Option<(usize, &[u8])> = self.wrap();
1266	0	encode_wrap_len(bit, pad, wrap, len)
1267		}
1268	0	}
1269
1270		/// Encodes `input` in `output`
1271		///
1272		/// # Panics
1273		///
1274		/// Panics if the `output` length does not match the result of [`encode_len`] for the `input`
1275		/// length.
1276		///
1277		/// # Examples
1278		///
1279		/// ```rust
1280		/// use data_encoding::BASE64;
1281		/// # let mut buffer = vec![0; 100];
1282		/// let input = b"Hello world";
1283		/// let output = &mut buffer[0 .. BASE64.encode_len(input.len())];
1284		/// BASE64.encode_mut(input, output);
1285		/// assert_eq!(output, b"SGVsbG8gd29ybGQ=");
1286		/// ```
1287		///
1288		/// [`encode_len`]: struct.Encoding.html#method.encode_len
1289		#[allow(clippy::cognitive_complexity)]
1290	0	pub fn encode_mut(&self, input: &[u8], output: &mut [u8]) {
1291	0	assert_eq!(output.len(), self.encode_len(input.len()));
1292	0	dispatch! {
1293	0	let bit: usize = self.bit();
1294	0	let msb: bool = self.msb();
1295	0	let pad: Option<u8> = self.pad();
1296	0	let wrap: Option<(usize, &[u8])> = self.wrap();
1297	0	encode_wrap_mut(bit, msb, self.sym(), pad, wrap, input, output)
1298		}
1299	0	}
1300
1301		/// Encodes `input` in `output` and returns it as a `&str`
1302		///
1303		/// It is guaranteed that `output` and the return value only differ by their type. They both
1304		/// point to the same range of memory (pointer and length).
1305		///
1306		/// # Panics
1307		///
1308		/// Panics if the `output` length does not match the result of [`encode_len`] for the `input`
1309		/// length.
1310		///
1311		/// # Examples
1312		///
1313		/// ```rust
1314		/// use data_encoding::BASE64;
1315		/// # let mut buffer = vec![0; 100];
1316		/// let input = b"Hello world";
1317		/// let output = &mut buffer[0 .. BASE64.encode_len(input.len())];
1318		/// assert_eq!(BASE64.encode_mut_str(input, output), "SGVsbG8gd29ybGQ=");
1319		/// ```
1320		///
1321		/// [`encode_len`]: struct.Encoding.html#method.encode_len
1322	0	pub fn encode_mut_str<'a>(&self, input: &[u8], output: &'a mut [u8]) -> &'a str {
1323	0	self.encode_mut(input, output);
1324	0	safety_assert!(output.is_ascii());
1325		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1326	0	unsafe { core::str::from_utf8_unchecked(output) }
1327	0	}
1328
1329		/// Appends the encoding of `input` to `output`
1330		///
1331		/// # Examples
1332		///
1333		/// ```rust
1334		/// use data_encoding::BASE64;
1335		/// # let mut buffer = vec![0; 100];
1336		/// let input = b"Hello world";
1337		/// let mut output = "Result: ".to_string();
1338		/// BASE64.encode_append(input, &mut output);
1339		/// assert_eq!(output, "Result: SGVsbG8gd29ybGQ=");
1340		/// ```
1341		#[cfg(feature = "alloc")]
1342	0	pub fn encode_append(&self, input: &[u8], output: &mut String) {
1343		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted below).
1344	0	let output = unsafe { output.as_mut_vec() };
1345	0	let output_len = output.len();
1346	0	output.resize(output_len + self.encode_len(input.len()), 0u8);
1347	0	self.encode_mut(input, &mut output[output_len ..]);
1348	0	safety_assert!(output[output_len ..].is_ascii());
1349	0	}
1350
1351		/// Returns an object to encode a fragmented input and append it to `output`
1352		///
1353		/// See the documentation of [`Encoder`] for more details and examples.
1354		#[cfg(feature = "alloc")]
1355	0	pub fn new_encoder<'a>(&'a self, output: &'a mut String) -> Encoder<'a> {
1356	0	Encoder::new(self, output)
1357	0	}
1358
1359		/// Writes the encoding of `input` to `output`
1360		///
1361		/// This allocates a buffer of 1024 bytes on the stack. If you want to control the buffer size
1362		/// and location, use [`Encoding::encode_write_buffer()`] instead.
1363		///
1364		/// # Errors
1365		///
1366		/// Returns an error when writing to the output fails.
1367	0	pub fn encode_write(
1368	0	&self, input: &[u8], output: &mut impl core::fmt::Write,
1369	0	) -> core::fmt::Result {
1370	0	self.encode_write_buffer(input, output, &mut [0; 1024])
1371	0	}
1372
1373		/// Writes the encoding of `input` to `output` using a temporary `buffer`
1374		///
1375		/// # Panics
1376		///
1377		/// Panics if the buffer is shorter than 510 bytes.
1378		///
1379		/// # Errors
1380		///
1381		/// Returns an error when writing to the output fails.
1382	0	pub fn encode_write_buffer(
1383	0	&self, input: &[u8], output: &mut impl core::fmt::Write, buffer: &mut [u8],
1384	0	) -> core::fmt::Result {
1385	0	assert!(510 <= buffer.len());
1386	0	let (enc, dec) = self.block_len();
1387	0	for input in input.chunks(buffer.len() / dec * enc) {
1388	0	let buffer = &mut buffer[.. self.encode_len(input.len())];
1389	0	self.encode_mut(input, buffer);
1390	0	safety_assert!(buffer.is_ascii());
1391		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1392	0	output.write_str(unsafe { core::str::from_utf8_unchecked(buffer) })?;
1393		}
1394	0	Ok(())
1395	0	}
1396
1397		/// Returns an object to display the encoding of `input`
1398		///
1399		/// # Examples
1400		///
1401		/// ```rust
1402		/// use data_encoding::BASE64;
1403		/// assert_eq!(
1404		/// format!("Payload: {}", BASE64.encode_display(b"Hello world")),
1405		/// "Payload: SGVsbG8gd29ybGQ=",
1406		/// );
1407		/// ```
1408		#[must_use]
1409	0	pub fn encode_display<'a>(&'a self, input: &'a [u8]) -> Display<'a> {
1410	0	Display { encoding: self, input }
1411	0	}
1412
1413		/// Returns encoded `input`
1414		///
1415		/// # Examples
1416		///
1417		/// ```rust
1418		/// use data_encoding::BASE64;
1419		/// assert_eq!(BASE64.encode(b"Hello world"), "SGVsbG8gd29ybGQ=");
1420		/// ```
1421		#[cfg(feature = "alloc")]
1422		#[must_use]
1423	0	pub fn encode(&self, input: &[u8]) -> String {
1424	0	let mut output = vec![0u8; self.encode_len(input.len())];
1425	0	self.encode_mut(input, &mut output);
1426	0	safety_assert!(output.is_ascii());
1427		// SAFETY: Ensured by correctness guarantees of encode_mut (and asserted above).
1428	0	unsafe { String::from_utf8_unchecked(output) }
1429	0	}
1430
1431		/// Returns the maximum decoded length of an input of length `len`
1432		///
1433		/// See [`decode_mut`] for when to use it. In particular, the actual decoded length might be
1434		/// smaller if the actual input contains padding or ignored characters.
1435		///
1436		/// # Errors
1437		///
1438		/// Returns an error if `len` is invalid. The error kind is [`Length`] and the [position] is the
1439		/// greatest valid input length.
1440		///
1441		/// [`decode_mut`]: struct.Encoding.html#method.decode_mut
1442		/// [`Length`]: enum.DecodeKind.html#variant.Length
1443		/// [position]: struct.DecodeError.html#structfield.position
1444	0	pub fn decode_len(&self, len: usize) -> Result<usize, DecodeError> {
1445	0	let (ilen, olen) = dispatch! {
1446	0	let bit: usize = self.bit();
1447	0	let pad: bool = self.pad().is_some();
1448	0	decode_wrap_len(bit, pad, len)
1449		};
1450	0	check!(
1451	0	DecodeError { position: ilen, kind: DecodeKind::Length },
1452	0	self.has_ignore() \|\| len == ilen
1453		);
1454	0	Ok(olen)
1455	0	}
1456
1457		/// Decodes `input` in `output`
1458		///
1459		/// Returns the length of the decoded output. This length may be smaller than the output length
1460		/// if the input contained padding or ignored characters. The output bytes after the returned
1461		/// length are not initialized and should not be read.
1462		///
1463		/// # Panics
1464		///
1465		/// Panics if the `output` length does not match the result of [`decode_len`] for the `input`
1466		/// length. Also panics if `decode_len` fails for the `input` length.
1467		///
1468		/// # Errors
1469		///
1470		/// Returns an error if `input` is invalid. See [`decode`] for more details. The are two
1471		/// differences though:
1472		///
1473		/// - [`Length`] may be returned only if the encoding allows ignored characters, because
1474		/// otherwise this is already checked by [`decode_len`].
1475		/// - The [`read`] first bytes of the input have been successfully decoded to the [`written`]
1476		/// first bytes of the output.
1477		///
1478		/// # Examples
1479		///
1480		/// ```rust
1481		/// use data_encoding::BASE64;
1482		/// # let mut buffer = vec![0; 100];
1483		/// let input = b"SGVsbA==byB3b3JsZA==";
1484		/// let output = &mut buffer[0 .. BASE64.decode_len(input.len()).unwrap()];
1485		/// let len = BASE64.decode_mut(input, output).unwrap();
1486		/// assert_eq!(&output[0 .. len], b"Hello world");
1487		/// ```
1488		///
1489		/// [`decode_len`]: struct.Encoding.html#method.decode_len
1490		/// [`decode`]: struct.Encoding.html#method.decode
1491		/// [`Length`]: enum.DecodeKind.html#variant.Length
1492		/// [`read`]: struct.DecodePartial.html#structfield.read
1493		/// [`written`]: struct.DecodePartial.html#structfield.written
1494		#[allow(clippy::cognitive_complexity)]
1495	0	pub fn decode_mut(&self, input: &[u8], output: &mut [u8]) -> Result<usize, DecodePartial> {
1496	0	assert_eq!(Ok(output.len()), self.decode_len(input.len()));
1497	0	dispatch! {
1498	0	let bit: usize = self.bit();
1499	0	let msb: bool = self.msb();
1500	0	let pad: bool = self.pad().is_some();
1501	0	let has_ignore: bool = self.has_ignore();
1502	0	decode_wrap_mut(bit, msb, self.ctb(), self.val(), pad, has_ignore,
1503	0	input, output)
1504		}
1505	0	}
1506
1507		/// Returns decoded `input`
1508		///
1509		/// # Errors
1510		///
1511		/// Returns an error if `input` is invalid. The error kind can be:
1512		///
1513		/// - [`Length`] if the input length is invalid. The [position] is the greatest valid input
1514		/// length.
1515		/// - [`Symbol`] if the input contains an invalid character. The [position] is the first invalid
1516		/// character.
1517		/// - [`Trailing`] if the input has non-zero trailing bits. This is only possible if the
1518		/// encoding checks trailing bits. The [position] is the first character containing non-zero
1519		/// trailing bits.
1520		/// - [`Padding`] if the input has an invalid padding length. This is only possible if the
1521		/// encoding uses padding. The [position] is the first padding character of the first padding
1522		/// of invalid length.
1523		///
1524		/// # Examples
1525		///
1526		/// ```rust
1527		/// use data_encoding::BASE64;
1528		/// assert_eq!(BASE64.decode(b"SGVsbA==byB3b3JsZA==").unwrap(), b"Hello world");
1529		/// ```
1530		///
1531		/// [`Length`]: enum.DecodeKind.html#variant.Length
1532		/// [`Symbol`]: enum.DecodeKind.html#variant.Symbol
1533		/// [`Trailing`]: enum.DecodeKind.html#variant.Trailing
1534		/// [`Padding`]: enum.DecodeKind.html#variant.Padding
1535		/// [position]: struct.DecodeError.html#structfield.position
1536		#[cfg(feature = "alloc")]
1537	0	pub fn decode(&self, input: &[u8]) -> Result<Vec<u8>, DecodeError> {
1538	0	let mut output = vec![0u8; self.decode_len(input.len())?];
1539	0	let len = self.decode_mut(input, &mut output).map_err(\|partial\| partial.error)?;
1540	0	output.truncate(len);
1541	0	Ok(output)
1542	0	}
1543
1544		/// Returns the bit-width
1545		#[must_use]
1546	0	pub fn bit_width(&self) -> usize {
1547	0	self.bit()
1548	0	}
1549
1550		/// Returns whether the encoding is canonical
1551		///
1552		/// An encoding is not canonical if one of the following conditions holds:
1553		///
1554		/// - trailing bits are not checked
1555		/// - padding is used
1556		/// - characters are ignored
1557		/// - characters are translated
1558		#[must_use]
1559	0	pub fn is_canonical(&self) -> bool {
1560	0	if !self.ctb() {
1561	0	return false;
1562	0	}
1563	0	let bit = self.bit();
1564	0	let sym = self.sym();
1565	0	let val = self.val();
1566	0	for i in 0 .. 256 {
1567	0	if val[i] == INVALID {
1568	0	continue;
1569	0	}
1570	0	if val[i] >= 1 << bit {
1571	0	return false;
1572	0	}
1573	0	if sym[val[i] as usize] as usize != i {
1574	0	return false;
1575	0	}
1576		}
1577	0	true
1578	0	}
1579
1580		/// Returns the encoding specification
1581		#[allow(clippy::missing_panics_doc)] // no panic
1582		#[cfg(feature = "alloc")]
1583		#[must_use]
1584	0	pub fn specification(&self) -> Specification {
1585	0	let mut specification = Specification::new();
1586	0	specification
1587	0	.symbols
1588	0	.push_str(core::str::from_utf8(&self.sym()[0 .. 1 << self.bit()]).unwrap());
1589		specification.bit_order =
1590	0	if self.msb() { MostSignificantFirst } else { LeastSignificantFirst };
1591	0	specification.check_trailing_bits = self.ctb();
1592	0	if let Some(pad) = self.pad() {
1593	0	specification.padding = Some(pad as char);
1594	0	}
1595	0	for i in 0 .. 128u8 {
1596	0	if self.val()[i as usize] != IGNORE {
1597	0	continue;
1598	0	}
1599	0	specification.ignore.push(i as char);
1600		}
1601	0	if let Some((col, end)) = self.wrap() {
1602	0	specification.wrap.width = col;
1603	0	specification.wrap.separator = core::str::from_utf8(end).unwrap().to_owned();
1604	0	}
1605	0	for i in 0 .. 128u8 {
1606	0	let canonical = if self.val()[i as usize] < 1 << self.bit() {
1607	0	self.sym()[self.val()[i as usize] as usize]
1608	0	} else if self.val()[i as usize] == PADDING {
1609	0	self.pad().unwrap()
1610		} else {
1611	0	continue;
1612		};
1613	0	if i == canonical {
1614	0	continue;
1615	0	}
1616	0	specification.translate.from.push(i as char);
1617	0	specification.translate.to.push(canonical as char);
1618		}
1619	0	specification
1620	0	}
1621
1622		#[doc(hidden)]
1623		#[must_use]
1624	0	pub const fn internal_new(implementation: &'static [u8]) -> Encoding {
1625		#[cfg(feature = "alloc")]
1626	0	let encoding = Encoding(Cow::Borrowed(implementation));
1627		#[cfg(not(feature = "alloc"))]
1628		let encoding = Encoding(implementation);
1629	0	encoding
1630	0	}
1631
1632		#[doc(hidden)]
1633		#[must_use]
1634	0	pub fn internal_implementation(&self) -> &[u8] {
1635	0	&self.0
1636	0	}
1637		}
1638
1639		/// Encodes fragmented input to an output
1640		///
1641		/// It is equivalent to use an [`Encoder`] with multiple calls to [`Encoder::append()`] than to
1642		/// first concatenate all the input and then use [`Encoding::encode_append()`]. In particular, this
1643		/// function will not introduce padding or wrapping between inputs.
1644		///
1645		/// # Examples
1646		///
1647		/// ```rust
1648		/// // This is a bit inconvenient but we can't take a long-term reference to data_encoding::BASE64
1649		/// // because it's a constant. We need to use a static which has an address instead. This will be
1650		/// // fixed in version 3 of the library.
1651		/// static BASE64: data_encoding::Encoding = data_encoding::BASE64;
1652		/// let mut output = String::new();
1653		/// let mut encoder = BASE64.new_encoder(&mut output);
1654		/// encoder.append(b"hello");
1655		/// encoder.append(b"world");
1656		/// encoder.finalize();
1657		/// assert_eq!(output, BASE64.encode(b"helloworld"));
1658		/// ```
1659		#[derive(Debug)]
1660		#[cfg(feature = "alloc")]
1661		pub struct Encoder<'a> {
1662		encoding: &'a Encoding,
1663		output: &'a mut String,
1664		buffer: [u8; 255],
1665		length: u8,
1666		}
1667
1668		#[cfg(feature = "alloc")]
1669		impl Drop for Encoder<'_> {
1670	0	fn drop(&mut self) {
1671	0	self.encoding.encode_append(&self.buffer[.. self.length as usize], self.output);
1672	0	}
1673		}
1674
1675		#[cfg(feature = "alloc")]
1676		impl<'a> Encoder<'a> {
1677	0	fn new(encoding: &'a Encoding, output: &'a mut String) -> Self {
1678	0	Encoder { encoding, output, buffer: [0; 255], length: 0 }
1679	0	}
1680
1681		/// Encodes the provided input fragment and appends the result to the output
1682	0	pub fn append(&mut self, mut input: &[u8]) {
1683		#[allow(clippy::cast_possible_truncation)] // no truncation
1684	0	let max = self.encoding.block_len().0 as u8;
1685	0	if self.length != 0 {
1686	0	let len = self.length;
1687		#[allow(clippy::cast_possible_truncation)] // no truncation
1688	0	let add = core::cmp::min((max - len) as usize, input.len()) as u8;
1689	0	self.buffer[len as usize ..][.. add as usize].copy_from_slice(&input[.. add as usize]);
1690	0	self.length += add;
1691	0	input = &input[add as usize ..];
1692	0	if self.length != max {
1693	0	debug_assert!(self.length < max);
1694	0	debug_assert!(input.is_empty());
1695	0	return;
1696	0	}
1697	0	self.encoding.encode_append(&self.buffer[.. max as usize], self.output);
1698	0	self.length = 0;
1699	0	}
1700	0	let len = floor(input.len(), max as usize);
1701	0	self.encoding.encode_append(&input[.. len], self.output);
1702	0	input = &input[len ..];
1703		#[allow(clippy::cast_possible_truncation)] // no truncation
1704	0	let len = input.len() as u8;
1705	0	self.buffer[.. len as usize].copy_from_slice(input);
1706	0	self.length = len;
1707	0	}
1708
1709		/// Makes sure all inputs have been encoded and appended to the output
1710		///
1711		/// This is equivalent to dropping the encoder and required for correctness, otherwise some
1712		/// encoded data may be missing at the end.
1713	0	pub fn finalize(self) {}
1714		}
1715
1716		/// Wraps an encoding and input for display purposes.
1717		#[derive(Debug)]
1718		pub struct Display<'a> {
1719		encoding: &'a Encoding,
1720		input: &'a [u8],
1721		}
1722
1723		impl core::fmt::Display for Display<'_> {
1724	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1725	0	self.encoding.encode_write(self.input, f)
1726	0	}
1727		}
1728
1729		#[derive(Debug, Copy, Clone)]
1730		#[cfg(feature = "alloc")]
1731		enum SpecificationErrorImpl {
1732		BadSize,
1733		NotAscii,
1734		Duplicate(u8),
1735		ExtraPadding,
1736		WrapLength,
1737		WrapWidth(u8),
1738		FromTo,
1739		Undefined(u8),
1740		}
1741		#[cfg(feature = "alloc")]
1742		use crate::SpecificationErrorImpl::*;
1743
1744		/// Specification error
1745		#[derive(Debug, Copy, Clone)]
1746		#[cfg(feature = "alloc")]
1747		pub struct SpecificationError(SpecificationErrorImpl);
1748
1749		#[cfg(feature = "alloc")]
1750		impl core::fmt::Display for SpecificationError {
1751	0	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
1752	0	match self.0 {
1753	0	BadSize => write!(f, "invalid number of symbols"),
1754	0	NotAscii => write!(f, "non-ascii character"),
1755	0	Duplicate(c) => write!(f, "{:?} has conflicting definitions", c as char),
1756	0	ExtraPadding => write!(f, "unnecessary padding"),
1757	0	WrapLength => write!(f, "invalid wrap width or separator length"),
1758	0	WrapWidth(x) => write!(f, "wrap width not a multiple of {}", x),
1759	0	FromTo => write!(f, "translate from/to length mismatch"),
1760	0	Undefined(c) => write!(f, "{:?} is undefined", c as char),
1761		}
1762	0	}
1763		}
1764
1765		#[cfg(feature = "std")]
1766		impl std::error::Error for SpecificationError {
1767	0	fn description(&self) -> &str {
1768	0	match self.0 {
1769	0	BadSize => "invalid number of symbols",
1770	0	NotAscii => "non-ascii character",
1771	0	Duplicate(_) => "conflicting definitions",
1772	0	ExtraPadding => "unnecessary padding",
1773	0	WrapLength => "invalid wrap width or separator length",
1774	0	WrapWidth(_) => "wrap width not a multiple",
1775	0	FromTo => "translate from/to length mismatch",
1776	0	Undefined(_) => "undefined character",
1777		}
1778	0	}
1779		}
1780
1781		#[cfg(feature = "alloc")]
1782		impl Specification {
1783		/// Returns a default specification
1784		#[must_use]
1785	0	pub fn new() -> Specification {
1786	0	Specification {
1787	0	symbols: String::new(),
1788	0	bit_order: MostSignificantFirst,
1789	0	check_trailing_bits: true,
1790	0	padding: None,
1791	0	ignore: String::new(),
1792	0	wrap: Wrap { width: 0, separator: String::new() },
1793	0	translate: Translate { from: String::new(), to: String::new() },
1794	0	}
1795	0	}
1796
1797		/// Returns the specified encoding
1798		///
1799		/// # Errors
1800		///
1801		/// Returns an error if the specification is invalid.
1802	0	pub fn encoding(&self) -> Result<Encoding, SpecificationError> {
1803	0	let symbols = self.symbols.as_bytes();
1804	0	let bit: u8 = match symbols.len() {
1805	0	2 => 1,
1806	0	4 => 2,
1807	0	8 => 3,
1808	0	16 => 4,
1809	0	32 => 5,
1810	0	64 => 6,
1811	0	_ => return Err(SpecificationError(BadSize)),
1812		};
1813	0	let mut values = [INVALID; 128];
1814	0	let set = \|v: &mut [u8; 128], i: u8, x: u8\| {
1815	0	check!(SpecificationError(NotAscii), i < 128);
1816	0	if v[i as usize] == x {
1817	0	return Ok(());
1818	0	}
1819	0	check!(SpecificationError(Duplicate(i)), v[i as usize] == INVALID);
1820	0	v[i as usize] = x;
1821	0	Ok(())
1822	0	};
1823	0	for (v, symbols) in symbols.iter().enumerate() {
1824		#[allow(clippy::cast_possible_truncation)] // no truncation
1825	0	set(&mut values, *symbols, v as u8)?;
1826		}
1827	0	let msb = self.bit_order == MostSignificantFirst;
1828	0	let ctb = self.check_trailing_bits \|\| 8 % bit == 0;
1829	0	let pad = match self.padding {
1830	0	None => None,
1831	0	Some(pad) => {
1832	0	check!(SpecificationError(ExtraPadding), 8 % bit != 0);
1833	0	check!(SpecificationError(NotAscii), pad.len_utf8() == 1);
1834	0	set(&mut values, pad as u8, PADDING)?;
1835	0	Some(pad as u8)
1836		}
1837		};
1838	0	for i in self.ignore.bytes() {
1839	0	set(&mut values, i, IGNORE)?;
1840		}
1841	0	let wrap = if self.wrap.separator.is_empty() \|\| self.wrap.width == 0 {
1842	0	None
1843		} else {
1844	0	let col = self.wrap.width;
1845	0	let end = self.wrap.separator.as_bytes();
1846	0	check!(SpecificationError(WrapLength), col < 256 && end.len() < 256);
1847		#[allow(clippy::cast_possible_truncation)] // no truncation
1848	0	let col = col as u8;
1849		#[allow(clippy::cast_possible_truncation)] // no truncation
1850	0	let dec = dec(bit as usize) as u8;
1851	0	check!(SpecificationError(WrapWidth(dec)), col % dec == 0);
1852	0	for &i in end {
1853	0	set(&mut values, i, IGNORE)?;
1854		}
1855	0	Some((col, end))
1856		};
1857	0	let from = self.translate.from.as_bytes();
1858	0	let to = self.translate.to.as_bytes();
1859	0	check!(SpecificationError(FromTo), from.len() == to.len());
1860	0	for i in 0 .. from.len() {
1861	0	check!(SpecificationError(NotAscii), to[i] < 128);
1862	0	let v = values[to[i] as usize];
1863	0	check!(SpecificationError(Undefined(to[i])), v != INVALID);
1864	0	set(&mut values, from[i], v)?;
1865		}
1866	0	let mut encoding = Vec::new();
1867	0	for _ in 0 .. 256 / symbols.len() {
1868	0	encoding.extend_from_slice(symbols);
1869	0	}
1870	0	encoding.extend_from_slice(&values);
1871	0	encoding.extend_from_slice(&[INVALID; 128]);
1872	0	match pad {
1873	0	None => encoding.push(INVALID),
1874	0	Some(pad) => encoding.push(pad),
1875		}
1876	0	encoding.push(bit);
1877	0	if msb {
1878	0	encoding[513] \|= 0x08;
1879	0	}
1880	0	if ctb {
1881	0	encoding[513] \|= 0x10;
1882	0	}
1883	0	if let Some((col, end)) = wrap {
1884	0	encoding.push(col);
1885	0	encoding.extend_from_slice(end);
1886	0	} else if values.contains(&IGNORE) {
1887	0	encoding.push(0);
1888	0	}
1889	0	Ok(Encoding(Cow::Owned(encoding)))
1890	0	}
1891		}
1892
1893		/// Lowercase hexadecimal encoding
1894		///
1895		/// This encoding is a static version of:
1896		///
1897		/// ```rust
1898		/// # use data_encoding::{Specification, HEXLOWER};
1899		/// let mut spec = Specification::new();
1900		/// spec.symbols.push_str("0123456789abcdef");
1901		/// assert_eq!(HEXLOWER, spec.encoding().unwrap());
1902		/// ```
1903		///
1904		/// # Examples
1905		///
1906		/// ```rust
1907		/// use data_encoding::HEXLOWER;
1908		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
1909		/// assert_eq!(HEXLOWER.decode(b"deadbeef").unwrap(), deadbeef);
1910		/// assert_eq!(HEXLOWER.encode(&deadbeef), "deadbeef");
1911		/// ```
1912		pub const HEXLOWER: Encoding = Encoding::internal_new(HEXLOWER_IMPL);
1913		const HEXLOWER_IMPL: &[u8] = &[
1914		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
1915		55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1916		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1917		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1918		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1919		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1920		56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1921		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1922		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1923		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1924		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1925		56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1926		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1927		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 0, 1, 2,
1928		3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1929		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1930		128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1931		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1932		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1933		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1934		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1935		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1936		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1937		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1938		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
1939		];
1940
1941		/// Lowercase hexadecimal encoding with case-insensitive decoding
1942		///
1943		/// This encoding is a static version of:
1944		///
1945		/// ```rust
1946		/// # use data_encoding::{Specification, HEXLOWER_PERMISSIVE};
1947		/// let mut spec = Specification::new();
1948		/// spec.symbols.push_str("0123456789abcdef");
1949		/// spec.translate.from.push_str("ABCDEF");
1950		/// spec.translate.to.push_str("abcdef");
1951		/// assert_eq!(HEXLOWER_PERMISSIVE, spec.encoding().unwrap());
1952		/// ```
1953		///
1954		/// # Examples
1955		///
1956		/// ```rust
1957		/// use data_encoding::HEXLOWER_PERMISSIVE;
1958		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
1959		/// assert_eq!(HEXLOWER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
1960		/// assert_eq!(HEXLOWER_PERMISSIVE.encode(&deadbeef), "deadbeef");
1961		/// ```
1962		///
1963		/// You can also define a shorter name:
1964		///
1965		/// ```rust
1966		/// use data_encoding::{Encoding, HEXLOWER_PERMISSIVE};
1967		/// const HEX: Encoding = HEXLOWER_PERMISSIVE;
1968		/// ```
1969		pub const HEXLOWER_PERMISSIVE: Encoding = Encoding::internal_new(HEXLOWER_PERMISSIVE_IMPL);
1970		const HEXLOWER_PERMISSIVE_IMPL: &[u8] = &[
1971		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54,
1972		55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1973		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1974		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1975		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1976		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1977		56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100,
1978		101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51,
1979		52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97,
1980		98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48,
1981		49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 48, 49, 50, 51, 52, 53, 54, 55,
1982		56, 57, 97, 98, 99, 100, 101, 102, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1983		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 0, 1, 2,
1985		3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 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, 10, 11, 12, 13, 14, 15, 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, 128, 128, 128, 128, 128, 128, 128,
1992		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1993		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1994		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
1995		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 28,
1996		];
1997
1998		/// Uppercase hexadecimal encoding
1999		///
2000		/// This encoding is a static version of:
2001		///
2002		/// ```rust
2003		/// # use data_encoding::{Specification, HEXUPPER};
2004		/// let mut spec = Specification::new();
2005		/// spec.symbols.push_str("0123456789ABCDEF");
2006		/// assert_eq!(HEXUPPER, spec.encoding().unwrap());
2007		/// ```
2008		///
2009		/// It is compliant with [RFC4648] and known as "base16" or "hex".
2010		///
2011		/// # Examples
2012		///
2013		/// ```rust
2014		/// use data_encoding::HEXUPPER;
2015		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
2016		/// assert_eq!(HEXUPPER.decode(b"DEADBEEF").unwrap(), deadbeef);
2017		/// assert_eq!(HEXUPPER.encode(&deadbeef), "DEADBEEF");
2018		/// ```
2019		///
2020		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-8
2021		pub const HEXUPPER: Encoding = Encoding::internal_new(HEXUPPER_IMPL);
2022		const HEXUPPER_IMPL: &[u8] = &[
2023		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2024		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2025		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2026		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2027		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2028		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2029		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2030		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2031		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2032		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2033		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 128, 128, 128, 128, 128, 128,
2034		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2035		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2036		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2037		12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2038		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 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, 28,
2047		];
2048
2049		/// Uppercase hexadecimal encoding with case-insensitive decoding
2050		///
2051		/// This encoding is a static version of:
2052		///
2053		/// ```rust
2054		/// # use data_encoding::{Specification, HEXUPPER_PERMISSIVE};
2055		/// let mut spec = Specification::new();
2056		/// spec.symbols.push_str("0123456789ABCDEF");
2057		/// spec.translate.from.push_str("abcdef");
2058		/// spec.translate.to.push_str("ABCDEF");
2059		/// assert_eq!(HEXUPPER_PERMISSIVE, spec.encoding().unwrap());
2060		/// ```
2061		///
2062		/// # Examples
2063		///
2064		/// ```rust
2065		/// use data_encoding::HEXUPPER_PERMISSIVE;
2066		/// let deadbeef = vec![0xde, 0xad, 0xbe, 0xef];
2067		/// assert_eq!(HEXUPPER_PERMISSIVE.decode(b"DeadBeef").unwrap(), deadbeef);
2068		/// assert_eq!(HEXUPPER_PERMISSIVE.encode(&deadbeef), "DEADBEEF");
2069		/// ```
2070		pub const HEXUPPER_PERMISSIVE: Encoding = Encoding::internal_new(HEXUPPER_PERMISSIVE_IMPL);
2071		const HEXUPPER_PERMISSIVE_IMPL: &[u8] = &[
2072		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2073		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2074		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55,
2075		56, 57, 65, 66, 67, 68, 69, 70, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
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, 128, 128, 128, 128, 128, 128,
2083		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2084		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2085		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2086		12, 13, 14, 15, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2087		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2090		128, 128, 128, 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, 28,
2096		];
2097
2098		/// Padded base32 encoding
2099		///
2100		/// This encoding is a static version of:
2101		///
2102		/// ```rust
2103		/// # use data_encoding::{Specification, BASE32};
2104		/// let mut spec = Specification::new();
2105		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2106		/// spec.padding = Some('=');
2107		/// assert_eq!(BASE32, spec.encoding().unwrap());
2108		/// ```
2109		///
2110		/// It conforms to [RFC4648].
2111		///
2112		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-6
2113		pub const BASE32: Encoding = Encoding::internal_new(BASE32_IMPL);
2114		const BASE32_IMPL: &[u8] = &[
2115		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2116		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2117		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2118		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2119		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2120		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2121		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2122		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2123		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2124		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2125		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2126		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2127		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2128		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 130, 128, 128,
2129		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,
2130		25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2131		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2132		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2133		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2134		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2135		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
2139		];
2140
2141		/// Unpadded base32 encoding
2142		///
2143		/// This encoding is a static version of:
2144		///
2145		/// ```rust
2146		/// # use data_encoding::{Specification, BASE32_NOPAD};
2147		/// let mut spec = Specification::new();
2148		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2149		/// assert_eq!(BASE32_NOPAD, spec.encoding().unwrap());
2150		/// ```
2151		pub const BASE32_NOPAD: Encoding = Encoding::internal_new(BASE32_NOPAD_IMPL);
2152		const BASE32_NOPAD_IMPL: &[u8] = &[
2153		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2154		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2155		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2156		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2157		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2158		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2159		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2160		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2161		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2162		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2163		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2164		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2165		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2166		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128,
2167		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,
2168		25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2169		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2170		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2171		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2172		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2173		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2174		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2175		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2176		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2177		];
2178
2179		/// Unpadded base32 encoding with case-insensitive decoding
2180		///
2181		/// This encoding is a static version of:
2182		///
2183		/// ```rust
2184		/// # use data_encoding::{Specification, BASE32_NOPAD_NOCASE};
2185		/// let mut spec = Specification::new();
2186		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2187		/// spec.translate.from.push_str("abcdefghijklmnopqrstuvwxyz");
2188		/// spec.translate.to.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
2189		/// assert_eq!(BASE32_NOPAD_NOCASE, spec.encoding().unwrap());
2190		/// ```
2191		pub const BASE32_NOPAD_NOCASE: Encoding = Encoding::internal_new(BASE32_NOPAD_NOCASE_IMPL);
2192		const BASE32_NOPAD_NOCASE_IMPL: &[u8] = &[
2193		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2194		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2195		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2196		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2197		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2198		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2199		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2200		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2201		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2202		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2203		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2204		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2205		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2206		128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128,
2207		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,
2208		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,
2209		18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2210		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2211		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2212		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2213		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2214		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2215		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2216		128, 128, 128, 128, 128, 128, 128, 128, 29,
2217		];
2218
2219		/// Unpadded base32 encoding with visual error correction during decoding
2220		///
2221		/// This encoding is a static version of:
2222		///
2223		/// ```rust
2224		/// # use data_encoding::{Specification, BASE32_NOPAD_VISUAL};
2225		/// let mut spec = Specification::new();
2226		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567");
2227		/// spec.translate.from.push_str("01l8");
2228		/// spec.translate.to.push_str("OIIB");
2229		/// assert_eq!(BASE32_NOPAD_VISUAL, spec.encoding().unwrap());
2230		/// ```
2231		pub const BASE32_NOPAD_VISUAL: Encoding = Encoding::internal_new(BASE32_NOPAD_VISUAL_IMPL);
2232		const BASE32_NOPAD_VISUAL_IMPL: &[u8] = &[
2233		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2234		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2235		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2236		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2237		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2238		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2239		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72,
2240		73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55,
2241		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2242		89, 90, 50, 51, 52, 53, 54, 55, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
2243		81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 50, 51, 52, 53, 54, 55, 128, 128, 128, 128, 128, 128,
2244		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2245		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2246		128, 128, 128, 128, 14, 8, 26, 27, 28, 29, 30, 31, 1, 128, 128, 128, 128, 128, 128, 128, 128,
2247		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,
2248		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 8, 128,
2249		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2250		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2251		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2252		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2253		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2254		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2255		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2256		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2257		];
2258
2259		/// Padded base32hex encoding
2260		///
2261		/// This encoding is a static version of:
2262		///
2263		/// ```rust
2264		/// # use data_encoding::{Specification, BASE32HEX};
2265		/// let mut spec = Specification::new();
2266		/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
2267		/// spec.padding = Some('=');
2268		/// assert_eq!(BASE32HEX, spec.encoding().unwrap());
2269		/// ```
2270		///
2271		/// It conforms to [RFC4648].
2272		///
2273		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-7
2274		pub const BASE32HEX: Encoding = Encoding::internal_new(BASE32HEX_IMPL);
2275		const BASE32HEX_IMPL: &[u8] = &[
2276		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2277		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2278		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2279		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2280		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2281		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2282		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2283		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2284		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2285		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2286		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
2287		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2288		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2289		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 130, 128, 128, 128, 10, 11,
2290		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
2291		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2292		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2293		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2294		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2295		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2296		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 29,
2300		];
2301
2302		/// Unpadded base32hex encoding
2303		///
2304		/// This encoding is a static version of:
2305		///
2306		/// ```rust
2307		/// # use data_encoding::{Specification, BASE32HEX_NOPAD};
2308		/// let mut spec = Specification::new();
2309		/// spec.symbols.push_str("0123456789ABCDEFGHIJKLMNOPQRSTUV");
2310		/// assert_eq!(BASE32HEX_NOPAD, spec.encoding().unwrap());
2311		/// ```
2312		pub const BASE32HEX_NOPAD: Encoding = Encoding::internal_new(BASE32HEX_NOPAD_IMPL);
2313		const BASE32HEX_NOPAD_IMPL: &[u8] = &[
2314		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2315		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2316		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2317		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2318		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2319		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2320		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55,
2321		56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86,
2322		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78,
2323		79, 80, 81, 82, 83, 84, 85, 86, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
2324		71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 128, 128, 128, 128, 128, 128,
2325		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2326		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2327		128, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2328		12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128,
2329		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2330		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2331		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2332		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2333		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2334		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2335		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2336		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2337		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 29,
2338		];
2339
2340		/// DNSSEC base32 encoding
2341		///
2342		/// This encoding is a static version of:
2343		///
2344		/// ```rust
2345		/// # use data_encoding::{Specification, BASE32_DNSSEC};
2346		/// let mut spec = Specification::new();
2347		/// spec.symbols.push_str("0123456789abcdefghijklmnopqrstuv");
2348		/// spec.translate.from.push_str("ABCDEFGHIJKLMNOPQRSTUV");
2349		/// spec.translate.to.push_str("abcdefghijklmnopqrstuv");
2350		/// assert_eq!(BASE32_DNSSEC, spec.encoding().unwrap());
2351		/// ```
2352		///
2353		/// It conforms to [RFC5155]:
2354		///
2355		/// - It uses a base32 extended hex alphabet.
2356		/// - It is case-insensitive when decoding and uses lowercase when encoding.
2357		/// - It does not use padding.
2358		///
2359		/// [RFC5155]: https://tools.ietf.org/html/rfc5155
2360		pub const BASE32_DNSSEC: Encoding = Encoding::internal_new(BASE32_DNSSEC_IMPL);
2361		const BASE32_DNSSEC_IMPL: &[u8] = &[
2362		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107,
2363		108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
2364		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2365		116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104,
2366		105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53,
2367		54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112,
2368		113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101,
2369		102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49,
2370		50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
2371		110, 111, 112, 113, 114, 115, 116, 117, 118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98,
2372		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2373		118, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
2374		107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 128, 128, 128, 128, 128, 128, 128,
2375		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2376		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2377		128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 13,
2378		14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 128, 128, 128, 128,
2379		128, 128, 128, 128, 128, 128, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2380		26, 27, 28, 29, 30, 31, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2381		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 29,
2388		];
2389
2390		#[allow(clippy::doc_markdown)]
2391		/// DNSCurve base32 encoding
2392		///
2393		/// This encoding is a static version of:
2394		///
2395		/// ```rust
2396		/// # use data_encoding::{BitOrder, Specification, BASE32_DNSCURVE};
2397		/// let mut spec = Specification::new();
2398		/// spec.symbols.push_str("0123456789bcdfghjklmnpqrstuvwxyz");
2399		/// spec.bit_order = BitOrder::LeastSignificantFirst;
2400		/// spec.translate.from.push_str("BCDFGHJKLMNPQRSTUVWXYZ");
2401		/// spec.translate.to.push_str("bcdfghjklmnpqrstuvwxyz");
2402		/// assert_eq!(BASE32_DNSCURVE, spec.encoding().unwrap());
2403		/// ```
2404		///
2405		/// It conforms to [DNSCurve].
2406		///
2407		/// [DNSCurve]: https://dnscurve.org/in-implement.html
2408		pub const BASE32_DNSCURVE: Encoding = Encoding::internal_new(BASE32_DNSCURVE_IMPL);
2409		const BASE32_DNSCURVE_IMPL: &[u8] = &[
2410		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110,
2411		112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
2412		98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119,
2413		120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107,
2414		108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53,
2415		54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116,
2416		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103,
2417		104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49,
2418		50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113,
2419		114, 115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99,
2420		100, 102, 103, 104, 106, 107, 108, 109, 110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121,
2421		122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 98, 99, 100, 102, 103, 104, 106, 107, 108, 109,
2422		110, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 128, 128, 128, 128, 128, 128, 128,
2423		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2424		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2425		128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 128, 128, 128, 128, 128, 128, 128, 128, 10, 11,
2426		12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
2427		128, 128, 128, 128, 128, 128, 128, 10, 11, 12, 128, 13, 14, 15, 128, 16, 17, 18, 19, 20, 128,
2428		21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2431		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2432		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2433		128, 128, 128, 128, 128, 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, 21,
2436		];
2437
2438		/// Padded base64 encoding
2439		///
2440		/// This encoding is a static version of:
2441		///
2442		/// ```rust
2443		/// # use data_encoding::{Specification, BASE64};
2444		/// let mut spec = Specification::new();
2445		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2446		/// spec.padding = Some('=');
2447		/// assert_eq!(BASE64, spec.encoding().unwrap());
2448		/// ```
2449		///
2450		/// It conforms to [RFC4648].
2451		///
2452		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-4
2453		pub const BASE64: Encoding = Encoding::internal_new(BASE64_IMPL);
2454		const BASE64_IMPL: &[u8] = &[
2455		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2456		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2457		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2458		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2459		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2460		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2461		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2462		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2463		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2464		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2465		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2466		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2467		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2468		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2469		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2470		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,
2471		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2472		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2473		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2474		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2475		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2479		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
2480		];
2481
2482		/// Unpadded base64 encoding
2483		///
2484		/// This encoding is a static version of:
2485		///
2486		/// ```rust
2487		/// # use data_encoding::{Specification, BASE64_NOPAD};
2488		/// let mut spec = Specification::new();
2489		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2490		/// assert_eq!(BASE64_NOPAD, spec.encoding().unwrap());
2491		/// ```
2492		pub const BASE64_NOPAD: Encoding = Encoding::internal_new(BASE64_NOPAD_IMPL);
2493		const BASE64_NOPAD_IMPL: &[u8] = &[
2494		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2495		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2496		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2497		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2498		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2499		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2500		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2501		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2502		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2503		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2504		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2505		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2506		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2507		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2508		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
2509		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,
2510		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2511		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2512		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2513		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2514		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2515		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2516		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2517		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2518		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
2519		];
2520
2521		/// MIME base64 encoding
2522		///
2523		/// This encoding is a static version of:
2524		///
2525		/// ```rust
2526		/// # use data_encoding::{Specification, BASE64_MIME};
2527		/// let mut spec = Specification::new();
2528		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2529		/// spec.padding = Some('=');
2530		/// spec.wrap.width = 76;
2531		/// spec.wrap.separator.push_str("\r\n");
2532		/// assert_eq!(BASE64_MIME, spec.encoding().unwrap());
2533		/// ```
2534		///
2535		/// It does not exactly conform to [RFC2045] because it does not print the header
2536		/// and does not ignore all characters.
2537		///
2538		/// [RFC2045]: https://tools.ietf.org/html/rfc2045
2539		pub const BASE64_MIME: Encoding = Encoding::internal_new(BASE64_MIME_IMPL);
2540		const BASE64_MIME_IMPL: &[u8] = &[
2541		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2542		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2543		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2544		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2545		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2546		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2547		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2548		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2549		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2550		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2551		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2552		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2553		128, 128, 128, 128, 128, 128, 129, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2554		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2555		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2556		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,
2557		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2558		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2562		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2563		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2564		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2565		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30, 76, 13, 10,
2566		];
2567
2568		/// MIME base64 encoding without trailing bits check
2569		///
2570		/// This encoding is a static version of:
2571		///
2572		/// ```rust
2573		/// # use data_encoding::{Specification, BASE64_MIME_PERMISSIVE};
2574		/// let mut spec = Specification::new();
2575		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");
2576		/// spec.padding = Some('=');
2577		/// spec.wrap.width = 76;
2578		/// spec.wrap.separator.push_str("\r\n");
2579		/// spec.check_trailing_bits = false;
2580		/// assert_eq!(BASE64_MIME_PERMISSIVE, spec.encoding().unwrap());
2581		/// ```
2582		///
2583		/// It does not exactly conform to [RFC2045] because it does not print the header
2584		/// and does not ignore all characters.
2585		///
2586		/// [RFC2045]: https://tools.ietf.org/html/rfc2045
2587		pub const BASE64_MIME_PERMISSIVE: Encoding = Encoding::internal_new(BASE64_MIME_PERMISSIVE_IMPL);
2588		const BASE64_MIME_PERMISSIVE_IMPL: &[u8] = &[
2589		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2590		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2591		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66,
2592		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2593		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2594		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67,
2595		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2596		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2597		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 65, 66, 67, 68,
2598		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2599		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2600		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 43, 47, 128, 128, 128, 128,
2601		128, 128, 128, 128, 128, 128, 129, 128, 128, 129, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2602		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2603		128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2604		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,
2605		24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2606		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2609		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2610		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2611		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 61, 14, 76, 13, 10,
2614		];
2615
2616		/// Padded base64url encoding
2617		///
2618		/// This encoding is a static version of:
2619		///
2620		/// ```rust
2621		/// # use data_encoding::{Specification, BASE64URL};
2622		/// let mut spec = Specification::new();
2623		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
2624		/// spec.padding = Some('=');
2625		/// assert_eq!(BASE64URL, spec.encoding().unwrap());
2626		/// ```
2627		///
2628		/// It conforms to [RFC4648].
2629		///
2630		/// [RFC4648]: https://tools.ietf.org/html/rfc4648#section-5
2631		pub const BASE64URL: Encoding = Encoding::internal_new(BASE64URL_IMPL);
2632		const BASE64URL_IMPL: &[u8] = &[
2633		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2634		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2635		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
2636		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2637		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2638		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
2639		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2640		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2641		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
2642		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2643		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2644		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
2645		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2646		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2647		128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 130, 128,
2648		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,
2649		24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2650		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2651		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2652		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2653		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2654		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 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, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2657		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 61, 30,
2658		];
2659
2660		/// Unpadded base64url encoding
2661		///
2662		/// This encoding is a static version of:
2663		///
2664		/// ```rust
2665		/// # use data_encoding::{Specification, BASE64URL_NOPAD};
2666		/// let mut spec = Specification::new();
2667		/// spec.symbols.push_str("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_");
2668		/// assert_eq!(BASE64URL_NOPAD, spec.encoding().unwrap());
2669		/// ```
2670		pub const BASE64URL_NOPAD: Encoding = Encoding::internal_new(BASE64URL_NOPAD_IMPL);
2671		const BASE64URL_NOPAD_IMPL: &[u8] = &[
2672		65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
2673		89, 90, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
2674		115, 116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66,
2675		67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90,
2676		97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115,
2677		116, 117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67,
2678		68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97,
2679		98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
2680		117, 118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 65, 66, 67, 68,
2681		69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98,
2682		99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117,
2683		118, 119, 120, 121, 122, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 45, 95, 128, 128, 128, 128,
2684		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2685		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2686		128, 128, 128, 62, 128, 128, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 128, 128,
2687		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,
2688		24, 25, 128, 128, 128, 128, 63, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
2689		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2690		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2691		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2692		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2693		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2694		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2695		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
2696		128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 30,
2697		];

Coverage Report

Created: 2025-10-28 06:54