Enum AsciiChar 

#[repr(u8)]
pub enum AsciiChar {
    Null = 0,
    SOH = 1,
    SOX = 2,
    ETX = 3,
    EOT = 4,
    ENQ = 5,
    ACK = 6,
    Bell = 7,
    BackSpace = 8,
    Tab = 9,
    LineFeed = 10,
    VT = 11,
    FF = 12,
    CarriageReturn = 13,
    SI = 14,
    SO = 15,
    DLE = 16,
    DC1 = 17,
    DC2 = 18,
    DC3 = 19,
    DC4 = 20,
    NAK = 21,
    SYN = 22,
    ETB = 23,
    CAN = 24,
    EM = 25,
    SUB = 26,
    ESC = 27,
    FS = 28,
    GS = 29,
    RS = 30,
    US = 31,
    Space = 32,
    Exclamation = 33,
    Quotation = 34,
    Hash = 35,
    Dollar = 36,
    Percent = 37,
    Ampersand = 38,
    Apostrophe = 39,
    ParenOpen = 40,
    ParenClose = 41,
    Asterisk = 42,
    Plus = 43,
    Comma = 44,
    Minus = 45,
    Dot = 46,
    Slash = 47,
    _0 = 48,
    _1 = 49,
    _2 = 50,
    _3 = 51,
    _4 = 52,
    _5 = 53,
    _6 = 54,
    _7 = 55,
    _8 = 56,
    _9 = 57,
    Colon = 58,
    Semicolon = 59,
    LessThan = 60,
    Equal = 61,
    GreaterThan = 62,
    Question = 63,
    At = 64,
    A = 65,
    B = 66,
    C = 67,
    D = 68,
    E = 69,
    F = 70,
    G = 71,
    H = 72,
    I = 73,
    J = 74,
    K = 75,
    L = 76,
    M = 77,
    N = 78,
    O = 79,
    P = 80,
    Q = 81,
    R = 82,
    S = 83,
    T = 84,
    U = 85,
    V = 86,
    W = 87,
    X = 88,
    Y = 89,
    Z = 90,
    BracketOpen = 91,
    BackSlash = 92,
    BracketClose = 93,
    Caret = 94,
    UnderScore = 95,
    Grave = 96,
    a = 97,
    b = 98,
    c = 99,
    d = 100,
    e = 101,
    f = 102,
    g = 103,
    h = 104,
    i = 105,
    j = 106,
    k = 107,
    l = 108,
    m = 109,
    n = 110,
    o = 111,
    p = 112,
    q = 113,
    r = 114,
    s = 115,
    t = 116,
    u = 117,
    v = 118,
    w = 119,
    x = 120,
    y = 121,
    z = 122,
    CurlyBraceOpen = 123,
    VerticalBar = 124,
    CurlyBraceClose = 125,
    Tilde = 126,
    DEL = 127,
}

An ASCII character. It wraps a u8, with the highest bit always zero.

Variants

Null = 0

'\0'

SOH = 1

Start Of Heading

SOX = 2

Start Of teXt

ETX = 3

End of TeXt

EOT = 4

End Of Transmission

ENQ = 5

Enquiry

ACK = 6

Acknowledgement

Bell = 7

bell / alarm / audible

'\a' is not recognized by Rust.

BackSpace = 8

Backspace

'\b' is not recognized by Rust.

Tab = 9

'\t'

LineFeed = 10

'\n'

VT = 11

Vertical tab

'\v' is not recognized by Rust.

FF = 12

Form Feed

'\f' is not recognized by Rust.

CarriageReturn = 13

'\r'

SI = 14

Shift In

SO = 15

Shift Out

DLE = 16

Data Link Escape

DC1 = 17

Device control 1, often XON

DC2 = 18

Device control 2

DC3 = 19

Device control 3, Often XOFF

DC4 = 20

Device control 4

NAK = 21

Negative AcKnowledgement

SYN = 22

Synchronous idle

ETB = 23

End of Transmission Block

CAN = 24

Cancel

EM = 25

End of Medium

SUB = 26

Substitute

ESC = 27

Escape

'\e' is not recognized by Rust.

FS = 28

File Separator

GS = 29

Group Separator

RS = 30

Record Separator

US = 31

Unit Separator

Space = 32

' '

Exclamation = 33

'!'

Quotation = 34

'"'

Hash = 35

'#'

Dollar = 36

'$'

Percent = 37

'%'

Ampersand = 38

'&'

Apostrophe = 39

'\''

ParenOpen = 40

'('

ParenClose = 41

')'

Asterisk = 42

'*'

Plus = 43

'+'

Comma = 44

','

Minus = 45

'-'

Dot = 46

'.'

Slash = 47

'/'

_0 = 48

'0'

_1 = 49

'1'

_2 = 50

'2'

_3 = 51

'3'

_4 = 52

'4'

_5 = 53

'5'

_6 = 54

'6'

_7 = 55

'7'

_8 = 56

'8'

_9 = 57

'9'

Colon = 58

':'

Semicolon = 59

';'

LessThan = 60

'<'

Equal = 61

'='

GreaterThan = 62

'>'

Question = 63

'?'

At = 64

'@'

A = 65

'A'

B = 66

'B'

C = 67

'C'

D = 68

'D'

E = 69

'E'

F = 70

'F'

G = 71

'G'

H = 72

'H'

I = 73

'I'

J = 74

'J'

K = 75

'K'

L = 76

'L'

M = 77

'M'

N = 78

'N'

O = 79

'O'

P = 80

'P'

Q = 81

'Q'

R = 82

'R'

S = 83

'S'

T = 84

'T'

U = 85

'U'

V = 86

'V'

W = 87

'W'

X = 88

'X'

Y = 89

'Y'

Z = 90

'Z'

BracketOpen = 91

'['

BackSlash = 92

'\'

BracketClose = 93

']'

Caret = 94

'^'

UnderScore = 95

'_'

Grave = 96

'’`

a = 97

'a'

b = 98

'b'

c = 99

'c'

d = 100

'd'

e = 101

'e'

f = 102

'f'

g = 103

'g'

h = 104

'h'

i = 105

'i'

j = 106

'j'

k = 107

'k'

l = 108

'l'

m = 109

'm'

n = 110

'n'

o = 111

'o'

p = 112

'p'

q = 113

'q'

r = 114

'r'

s = 115

's'

t = 116

't'

u = 117

'u'

v = 118

'v'

w = 119

'w'

x = 120

'x'

y = 121

'y'

z = 122

'z'

CurlyBraceOpen = 123

'{'

VerticalBar = 124

'|'

CurlyBraceClose = 125

'}'

Tilde = 126

'~'

DEL = 127

Delete

Implementations

impl AsciiChar

pub fn from_ascii<C: ToAsciiChar>(ch: C) -> Result<Self, ToAsciiCharError>

Constructs an ASCII character from a u8, char or other character type.

Errors

Returns Err(()) if the character can’t be ASCII encoded.

Example

let a = AsciiChar::from_ascii('g').unwrap();
assert_eq!(a.as_char(), 'g');

pub const fn new(ch: char) -> AsciiChar

Create an AsciiChar from a char, panicking if it’s not ASCII.

This function is intended for creating AsciiChar values from hardcoded known-good character literals such as 'K', '-' or '\0', and for use in const contexts. Use from_ascii() instead when you’re not certain the character is ASCII.

Examples

assert_eq!(AsciiChar::new('@'), AsciiChar::At);
assert_eq!(AsciiChar::new('C').as_char(), 'C');

In a constant:

const SPLIT_ON: AsciiChar = AsciiChar::new(',');

This will not compile:

const BAD: AsciiChar = AsciiChar::new('Ø');

Panics

This function will panic if passed a non-ASCII character.

The panic message might not be the most descriptive due to the current limitations of const fn.

pub unsafe fn from_ascii_unchecked(ch: u8) -> Self

Constructs an ASCII character from a u8, char or other character type without any checks.

Safety

This function is very unsafe as it can create invalid enum discriminants, which instantly creates undefined behavior. (let _ = AsciiChar::from_ascii_unchecked(200); alone is UB).

The undefined behavior is not just theoretical either: For example, [0; 128][AsciiChar::from_ascii_unchecked(255) as u8 as usize] = 0 might not panic, creating a buffer overflow, and Some(AsciiChar::from_ascii_unchecked(128)) might be None.

pub const fn as_byte(self) -> u8

Converts an ASCII character into a u8.

pub const fn as_char(self) -> char

Converts an ASCII character into a char.

pub const fn is_alphabetic(self) -> bool

Check if the character is a letter (a-z, A-Z)

pub const fn is_ascii_alphabetic(&self) -> bool

Check if the character is a letter (a-z, A-Z).

This method is identical to is_alphabetic()

pub fn is_digit(self, radix: u32) -> bool

Check if the character is a digit in the given radix.

If the radix is always 10 or 16, is_ascii_digit() and is_ascii_hexdigit() will be faster.

Panics

Radixes greater than 36 are not supported and will result in a panic.

pub const fn is_ascii_digit(&self) -> bool

Check if the character is a number (0-9)

Examples

assert_eq!(AsciiChar::new('0').is_ascii_digit(), true);
assert_eq!(AsciiChar::new('9').is_ascii_digit(), true);
assert_eq!(AsciiChar::new('a').is_ascii_digit(), false);
assert_eq!(AsciiChar::new('A').is_ascii_digit(), false);
assert_eq!(AsciiChar::new('/').is_ascii_digit(), false);

pub const fn is_alphanumeric(self) -> bool

Check if the character is a letter or number

pub const fn is_ascii_alphanumeric(&self) -> bool

Check if the character is a letter or number

This method is identical to is_alphanumeric()

pub const fn is_ascii_blank(&self) -> bool

Check if the character is a space or horizontal tab

Examples

assert!(AsciiChar::Space.is_ascii_blank());
assert!(AsciiChar::Tab.is_ascii_blank());
assert!(!AsciiChar::VT.is_ascii_blank());
assert!(!AsciiChar::LineFeed.is_ascii_blank());
assert!(!AsciiChar::CarriageReturn.is_ascii_blank());
assert!(!AsciiChar::FF.is_ascii_blank());

pub const fn is_whitespace(self) -> bool

Check if the character one of ’ ’, ‘\t’, ‘\n’, ‘\r’, ‘\0xb’ (vertical tab) or ‘\0xc’ (form feed).

pub const fn is_ascii_whitespace(&self) -> bool

Check if the character is a ’ ’, ‘\t’, ‘\n’, ‘\r’ or ‘\0xc’ (form feed).

This method is NOT identical to is_whitespace().

pub const fn is_ascii_control(&self) -> bool

Check if the character is a control character

Examples

assert_eq!(AsciiChar::new('\0').is_ascii_control(), true);
assert_eq!(AsciiChar::new('n').is_ascii_control(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_control(), false);
assert_eq!(AsciiChar::new('\n').is_ascii_control(), true);
assert_eq!(AsciiChar::new('\t').is_ascii_control(), true);
assert_eq!(AsciiChar::EOT.is_ascii_control(), true);

pub const fn is_ascii_graphic(&self) -> bool

Checks if the character is printable (except space)

Examples

assert_eq!(AsciiChar::new('n').is_ascii_graphic(), true);
assert_eq!(AsciiChar::new(' ').is_ascii_graphic(), false);
assert_eq!(AsciiChar::new('\n').is_ascii_graphic(), false);

pub const fn is_ascii_printable(&self) -> bool

Checks if the character is printable (including space)

Examples

assert_eq!(AsciiChar::new('n').is_ascii_printable(), true);
assert_eq!(AsciiChar::new(' ').is_ascii_printable(), true);
assert_eq!(AsciiChar::new('\n').is_ascii_printable(), false);

pub const fn is_lowercase(self) -> bool

Checks if the character is alphabetic and lowercase (a-z).

Examples

use ascii::AsciiChar;
assert_eq!(AsciiChar::new('a').is_lowercase(), true);
assert_eq!(AsciiChar::new('A').is_lowercase(), false);
assert_eq!(AsciiChar::new('@').is_lowercase(), false);

pub const fn is_ascii_lowercase(&self) -> bool

Checks if the character is alphabetic and lowercase (a-z).

This method is identical to is_lowercase()

pub const fn is_uppercase(self) -> bool

Checks if the character is alphabetic and uppercase (A-Z).

Examples

assert_eq!(AsciiChar::new('A').is_uppercase(), true);
assert_eq!(AsciiChar::new('a').is_uppercase(), false);
assert_eq!(AsciiChar::new('@').is_uppercase(), false);

pub const fn is_ascii_uppercase(&self) -> bool

Checks if the character is alphabetic and uppercase (A-Z).

This method is identical to is_uppercase()

pub const fn is_ascii_punctuation(&self) -> bool

Checks if the character is punctuation

Examples

assert_eq!(AsciiChar::new('n').is_ascii_punctuation(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_punctuation(), false);
assert_eq!(AsciiChar::new('_').is_ascii_punctuation(), true);
assert_eq!(AsciiChar::new('~').is_ascii_punctuation(), true);

pub const fn is_ascii_hexdigit(&self) -> bool

Checks if the character is a valid hex digit

Examples

assert_eq!(AsciiChar::new('5').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('a').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('F').is_ascii_hexdigit(), true);
assert_eq!(AsciiChar::new('G').is_ascii_hexdigit(), false);
assert_eq!(AsciiChar::new(' ').is_ascii_hexdigit(), false);

pub fn as_printable_char(self) -> char

Unicode has printable versions of the ASCII control codes, like ‘␛’.

This function is identical with .as_char() for all values .is_printable() returns true for, but replaces the control codes with those unicodes printable versions.

Examples

assert_eq!(AsciiChar::new('\0').as_printable_char(), '␀');
assert_eq!(AsciiChar::new('\n').as_printable_char(), '␊');
assert_eq!(AsciiChar::new(' ').as_printable_char(), ' ');
assert_eq!(AsciiChar::new('p').as_printable_char(), 'p');

pub fn make_ascii_uppercase(&mut self)

Replaces letters a to z with A to Z

pub fn make_ascii_lowercase(&mut self)

Replaces letters A to Z with a to z

pub const fn to_ascii_uppercase(&self) -> Self

Maps letters a-z to A-Z and returns any other character unchanged.

Examples

assert_eq!(AsciiChar::new('u').to_ascii_uppercase().as_char(), 'U');
assert_eq!(AsciiChar::new('U').to_ascii_uppercase().as_char(), 'U');
assert_eq!(AsciiChar::new('2').to_ascii_uppercase().as_char(), '2');
assert_eq!(AsciiChar::new('=').to_ascii_uppercase().as_char(), '=');
assert_eq!(AsciiChar::new('[').to_ascii_uppercase().as_char(), '[');

pub const fn to_ascii_lowercase(&self) -> Self

Maps letters A-Z to a-z and returns any other character unchanged.

Examples

assert_eq!(AsciiChar::new('U').to_ascii_lowercase().as_char(), 'u');
assert_eq!(AsciiChar::new('u').to_ascii_lowercase().as_char(), 'u');
assert_eq!(AsciiChar::new('2').to_ascii_lowercase().as_char(), '2');
assert_eq!(AsciiChar::new('^').to_ascii_lowercase().as_char(), '^');
assert_eq!(AsciiChar::new('\x7f').to_ascii_lowercase().as_char(), '\x7f');

pub const fn eq_ignore_ascii_case(&self, other: &Self) -> bool

Compares two characters case-insensitively.

Trait Implementations

impl AsRef<AsciiStr> for AsciiChar

fn as_ref(&self) -> &AsciiStr

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for AsciiChar

fn clone(&self) -> AsciiChar

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AsciiChar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AsciiChar

fn default() -> AsciiChar

Returns the “default value” for a type.

impl Display for AsciiChar

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<AsciiChar> for AsciiString

fn from(ch: AsciiChar) -> Self

Converts to this type from the input type.

impl From<AsciiChar> for char

fn from(a: AsciiChar) -> char

Converts to this type from the input type.

impl From<AsciiChar> for u8

fn from(a: AsciiChar) -> u8

Converts to this type from the input type.

impl Hash for AsciiChar

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for AsciiChar

fn cmp(&self, other: &AsciiChar) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<AsciiChar> for char

fn eq(&self, rhs: &AsciiChar) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<AsciiChar> for u8

fn eq(&self, rhs: &AsciiChar) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<char> for AsciiChar

fn eq(&self, rhs: &char) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for AsciiChar

fn eq(&self, rhs: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for AsciiChar

fn eq(&self, other: &AsciiChar) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<AsciiChar> for char

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<AsciiChar> for u8

fn partial_cmp(&self, rhs: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<char> for AsciiChar

fn partial_cmp(&self, rhs: &char) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for AsciiChar

fn partial_cmp(&self, rhs: &u8) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd for AsciiChar

fn partial_cmp(&self, other: &AsciiChar) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl ToAsciiChar for AsciiChar

fn to_ascii_char(self) -> Result<AsciiChar, ToAsciiCharError>

Convert to AsciiChar.

unsafe fn to_ascii_char_unchecked(self) -> AsciiChar

Convert to AsciiChar without checking that it is an ASCII character.

impl Copy for AsciiChar

impl Eq for AsciiChar

impl StructuralPartialEq for AsciiChar

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• Null: 0 bytes
• SOH: 0 bytes
• SOX: 0 bytes
• ETX: 0 bytes
• EOT: 0 bytes
• ENQ: 0 bytes
• ACK: 0 bytes
• Bell: 0 bytes
• BackSpace: 0 bytes
• Tab: 0 bytes
• LineFeed: 0 bytes
• VT: 0 bytes
• FF: 0 bytes
• CarriageReturn: 0 bytes
• SI: 0 bytes
• SO: 0 bytes
• DLE: 0 bytes
• DC1: 0 bytes
• DC2: 0 bytes
• DC3: 0 bytes
• DC4: 0 bytes
• NAK: 0 bytes
• SYN: 0 bytes
• ETB: 0 bytes
• CAN: 0 bytes
• EM: 0 bytes
• SUB: 0 bytes
• ESC: 0 bytes
• FS: 0 bytes
• GS: 0 bytes
• RS: 0 bytes
• US: 0 bytes
• Space: 0 bytes
• Exclamation: 0 bytes
• Quotation: 0 bytes
• Hash: 0 bytes
• Dollar: 0 bytes
• Percent: 0 bytes
• Ampersand: 0 bytes
• Apostrophe: 0 bytes
• ParenOpen: 0 bytes
• ParenClose: 0 bytes
• Asterisk: 0 bytes
• Plus: 0 bytes
• Comma: 0 bytes
• Minus: 0 bytes
• Dot: 0 bytes
• Slash: 0 bytes
• _0: 0 bytes
• _1: 0 bytes
• _2: 0 bytes
• _3: 0 bytes
• _4: 0 bytes
• _5: 0 bytes
• _6: 0 bytes
• _7: 0 bytes
• _8: 0 bytes
• _9: 0 bytes
• Colon: 0 bytes
• Semicolon: 0 bytes
• LessThan: 0 bytes
• Equal: 0 bytes
• GreaterThan: 0 bytes
• Question: 0 bytes
• At: 0 bytes
• A: 0 bytes
• B: 0 bytes
• C: 0 bytes
• D: 0 bytes
• E: 0 bytes
• F: 0 bytes
• G: 0 bytes
• H: 0 bytes
• I: 0 bytes
• J: 0 bytes
• K: 0 bytes
• L: 0 bytes
• M: 0 bytes
• N: 0 bytes
• O: 0 bytes
• P: 0 bytes
• Q: 0 bytes
• R: 0 bytes
• S: 0 bytes
• T: 0 bytes
• U: 0 bytes
• V: 0 bytes
• W: 0 bytes
• X: 0 bytes
• Y: 0 bytes
• Z: 0 bytes
• BracketOpen: 0 bytes
• BackSlash: 0 bytes
• BracketClose: 0 bytes
• Caret: 0 bytes
• UnderScore: 0 bytes
• Grave: 0 bytes
• a: 0 bytes
• b: 0 bytes
• c: 0 bytes
• d: 0 bytes
• e: 0 bytes
• f: 0 bytes
• g: 0 bytes
• h: 0 bytes
• i: 0 bytes
• j: 0 bytes
• k: 0 bytes
• l: 0 bytes
• m: 0 bytes
• n: 0 bytes
• o: 0 bytes
• p: 0 bytes
• q: 0 bytes
• r: 0 bytes
• s: 0 bytes
• t: 0 bytes
• u: 0 bytes
• v: 0 bytes
• w: 0 bytes
• x: 0 bytes
• y: 0 bytes
• z: 0 bytes
• CurlyBraceOpen: 0 bytes
• VerticalBar: 0 bytes
• CurlyBraceClose: 0 bytes
• Tilde: 0 bytes
• DEL: 0 bytes