ansi.go

// Copyright 2014 Google Inc.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package ansi provides ansi escape sequence processing as defined by the
// ECMA-48 standard "Control Functions for Coded Character Sets - Fifth Edition"
//
// From the standard:
//
//   Free printed copies of this standard can be ordered from:
//   ECMA
//   114 Rue du Rhône CH-1204 Geneva Switzerland
//   Fax: +41 22 849.60.01 Email: documents@ecma.ch
//   Files of this Standard can be freely downloaded from the ECMA web site
//   (www.ecma.ch). This site gives full information on ECMA, ECMA activities,
//   ECMA Standards and Technical Reports.
//
// Portions of the standared are included in the documentation for this package.
// The standard bears no copyright.
//
// Each escape sequence is represented by a string constant and a Sequence
// structure.  For the escape sequence named SEQ, SEQ is the string constant and
// SEQ_ is the related Sequence structure.  A mapping from a sequence string to
// its Sequence structure is provided in Table.
//
// Some escape sequences may contain parameters, for example "\033[4A".  This
// sequence contains the parameter "4".  The name of the sequences is "\033[A"
// (the parameter is missing).  The sequence "\033[1;2 c" is named "\033[ c" and
// has the parameters "1", and "2".
//
// The C1 control set has both a two byte and a single byte representation.  The
// two byte representation is an Escape followed by a byte in the range of 0x40
// to 0x5f.  They may also be specified by a single byte in the range of 0x80 -
// 0x9f.  This ansi package always names the C1 control set in the two byte
// form.
package ansi

// A Sequence specifies an ANSI (ECMA-48) Escape Sequence.
// If the default value of a parameter is -1 then that parameter must
// be specified (but following parameters may be defaulted).
type Sequence struct {
	Name     string   // Short name of the sequence
	Desc     string   // Description of the sequence
	Notation string   // Notation the sequence uses
	Type     Name     // Prefix type: ESC, CSI or ""
	NParam   int      // Number of parameters (-1 implies any number)
	MinParam int      // Minium number of parameters that must be present
	Defaults []string // Default values of parameters (if any)
	Code     []byte   // Code bytes
}

// A Name is the name of ansi escape sequence.
type Name string

// S returns a reference to the Sequence for n.
func (n Name) S() *Sequence {
	return Table[n]
}

// The remainder of this file was automatically generated from the ECMA-48
// standard.

// ANSI (ECMA-48) Sequences.
// These sequences do not include parameters or string termination sequences.
const (
	NUL    = Name("\000")     // Null
	SOH    = Name("\001")     // Start of Heading
	STX    = Name("\002")     // Start of Text
	ETX    = Name("\003")     // End of Text
	EOT    = Name("\004")     // End of Transmission
	ENQ    = Name("\005")     // Enquiry
	ACK    = Name("\006")     // Acknowledge
	BEL    = Name("\007")     // Bell
	BS     = Name("\010")     // Backspace
	HT     = Name("\011")     // Character Tabulation
	LF     = Name("\012")     // Line Feed
	VT     = Name("\013")     // Line Tabulation
	FF     = Name("\014")     // Form Feed
	CR     = Name("\015")     // Carriage Return
	SO     = Name("\016")     // Shift-Out
	SI     = Name("\017")     // Shift-In
	DLE    = Name("\020")     // Data Link Escape
	DC1    = Name("\021")     // Device Control One
	DC2    = Name("\022")     // Device Control Two
	DC3    = Name("\023")     // Device Control Three
	DC4    = Name("\024")     // Device Control Four
	NAK    = Name("\025")     // Negative Acknowledge
	SYN    = Name("\026")     // Synchronous Idle
	ETB    = Name("\027")     // End of Transmission Block
	CAN    = Name("\030")     // Cancel
	EM     = Name("\031")     // End of Medium
	SUB    = Name("\032")     // Substitute
	ESC    = Name("\033")     // Escape
	IS4    = Name("\034")     // Information Separator Four (FS - File Separator)
	IS3    = Name("\035")     // Information Separator Three (GS - Group Separator)
	IS2    = Name("\036")     // Information Separator Two (RS - Record Separator)
	IS1    = Name("\037")     // Information Separator One (US - Unit Separator)
	APC    = Name("\033_")    // Application Program Command
	BPH    = Name("\033B")    // Break Permitted Here
	CBT    = Name("\033[Z")   // Cursor Backward Tabulation
	CCH    = Name("\033T")    // Cancel Character
	CHA    = Name("\033[G")   // Cursor Character Absolute
	CHT    = Name("\033[I")   // Cursor Forward Tabulation
	CMD    = Name("\033d")    // Coding Method Delimiter
	CNL    = Name("\033[E")   // Cursor Next Line
	CPL    = Name("\033[F")   // Cursor Preceding Line
	CPR    = Name("\033[R")   // Active Position Report
	CSI    = Name("\033[")    // Control Sequence Introducer
	CTC    = Name("\033[W")   // Cursor Tabulation Control
	CUB    = Name("\033[D")   // Cursor Left
	CUD    = Name("\033[B")   // Cursor Down
	CUF    = Name("\033[C")   // Cursor Right
	CUP    = Name("\033[H")   // Cursor Position
	CUU    = Name("\033[A")   // Cursor Up
	CVT    = Name("\033[Y")   // Cursor Line Tabulation
	DA     = Name("\033[c")   // Device Attributes
	DAQ    = Name("\033[o")   // Define Area Qualification
	DCH    = Name("\033[P")   // Delete Character
	DCS    = Name("\033P")    // Device Control String
	DL     = Name("\033[M")   // Delete Line
	DMI    = Name("\033`")    // Disable Manual Input
	DSR    = Name("\033[n")   // Device Status Report
	DTA    = Name("\033[ T")  // Dimension Text Area
	EA     = Name("\033[O")   // Erase in Area
	ECH    = Name("\033[X")   // Erase Character
	ED     = Name("\033[J")   // Erase in Page
	EF     = Name("\033[N")   // Erase in Field
	EL     = Name("\033[K")   // Erase in Line
	EMI    = Name("\033b")    // Enable Manual Input
	EPA    = Name("\033W")    // End of Guarded Area
	ESA    = Name("\033G")    // End of Selected Area
	FNK    = Name("\033[ W")  // Function Key
	FNT    = Name("\033[ D")  // Font Selection
	GCC    = Name("\033[ _")  // Graphic Character Combination
	GSM    = Name("\033[ B")  // Graphic Size Modification
	GSS    = Name("\033[ C")  // Graphic Size Selection
	HPA    = Name("\033[`")   // Character Position Absolute
	HPB    = Name("\033[j")   // Character Position Backward
	HPR    = Name("\033[a")   // Character Position Forward
	HTJ    = Name("\033I")    // Character Tabulation With Justification
	HTS    = Name("\033H")    // Character Tabulation Set
	HVP    = Name("\033[f")   // Character and Line Position
	ICH    = Name("\033[@")   // Insert Character
	IDCS   = Name("\033[ O")  // Identify Device Control String
	IGS    = Name("\033[ M")  // Identify Graphic Subrepertoire
	IL     = Name("\033[L")   // Insert Line
	INT    = Name("\033a")    // Interrupt
	JFY    = Name("\033[ F")  // Justify
	LS1R   = Name("\033~")    // Locking-Shift One Right
	LS2    = Name("\033n")    // Locking-Shift Two
	LS2R   = Name("\033}")    // Locking-Shift Two Right
	LS3    = Name("\033o")    // Locking-Shift Three
	LS3R   = Name("\033|")    // Locking-Shift Three Right
	MC     = Name("\033[i")   // Media Copy
	MW     = Name("\033U")    // Message Waiting
	NBH    = Name("\033C")    // No Break Here
	NEL    = Name("\033E")    // Next Line
	NP     = Name("\033[U")   // Next Page
	OSC    = Name("\033]")    // Operating System Command
	PEC    = Name("\033[ Z")  // Presentation Expand or Contract
	PFS    = Name("\033[ J")  // Page Format Selection
	PLD    = Name("\033K")    // Partial Line Forward
	PLU    = Name("\033L")    // Partial Line Backward
	PM     = Name("\033^")    // Privacy Message
	PP     = Name("\033[V")   // Preceding Page
	PPA    = Name("\033[ P")  // Page Position Absolute
	PPB    = Name("\033[ R")  // Page Position Backward
	PPR    = Name("\033[ Q")  // Page Position Forward
	PTX    = Name("\033[\\")  // Parallel Texts
	PU1    = Name("\033Q")    // Private Use One
	PU2    = Name("\033R")    // Private Use Two
	QUAD   = Name("\033[ H")  // Quad
	REP    = Name("\033[b")   // Repeat
	RI     = Name("\033M")    // Reverse Line Feed
	RIS    = Name("\033c")    // Reset to Initial State
	RM     = Name("\033[l")   // Reset Mode
	SACS   = Name("\033[ \\") // Set Additional Character Separation
	SAPV   = Name("\033[ ]")  // Select Alternative Presentation Variants
	SCI    = Name("\033Z")    // Single Character Introducer
	SCO    = Name("\033[ e")  // Select Character Orientation
	SCP    = Name("\033[ k")  // Select Character Path
	SCS    = Name("\033[ g")  // Set Character Spacing
	SD     = Name("\033[T")   // Scroll Down
	SDS    = Name("\033[]")   // Start Directed String
	SEE    = Name("\033[Q")   // Select Editing Extent
	SEF    = Name("\033[ Y")  // Sheet Eject and Feed
	SGR    = Name("\033[m")   // Select Graphic Rendition
	SHS    = Name("\033[ K")  // Select Character Spacing
	SIMD   = Name("\033[^")   // Select Implicit Movement Direction
	SL     = Name("\033[ @")  // Scroll Left
	SLH    = Name("\033[ U")  // Set Line Home
	SLL    = Name("\033[ V")  // Set Line Limit
	SLS    = Name("\033[ h")  // Set Line Spacing
	SM     = Name("\033[h")   // Set Mode
	SOS    = Name("\033X")    // Start of String
	SPA    = Name("\033V")    // Start of Guarded Area
	SPD    = Name("\033[ S")  // Select Presentation Directions
	SPH    = Name("\033[ i")  // Set Page Home
	SPI    = Name("\033[ G")  // Spacing Increment
	SPL    = Name("\033[ j")  // Set Page Limit
	SPQR   = Name("\033[ X")  // Select Print Quality and Rapidity
	SR     = Name("\033[ A")  // Scroll Right
	SRCS   = Name("\033[ f")  // Set Reduced Character Separation
	SRS    = Name("\033[[")   // Start Reversed String
	SSA    = Name("\033F")    // Start of Selected Area
	SSU    = Name("\033[ I")  // Select Size Unit
	SSW    = Name("\033[ [")  // Set Space Width
	SS2    = Name("\033N")    // Single-Shift Two
	SS3    = Name("\033O")    // Single-Shift Three
	ST     = Name("\033\\")   // String Terminator
	STAB   = Name("\033[ ^")  // Selective Tabulation
	STS    = Name("\033S")    // Set Transmit State
	SU     = Name("\033[S")   // Scroll Up
	SVS    = Name("\033[ L")  // Select Line Spacing
	TAC    = Name("\033[ b")  // Tabulation Aligned Centred
	TALE   = Name("\033[ a")  // Tabulation Aligned Leading Edge
	TATE   = Name("\033[ `")  // Tabulation Aligned Trailing Edge
	TBC    = Name("\033[g")   // Tabulation Clear
	TCC    = Name("\033[ c")  // Tabulation Centred on Character
	TSR    = Name("\033[ d")  // Tabulation Stop Remove
	TSS    = Name("\033[ E")  // Thin Space Specification
	VPA    = Name("\033[d")   // Line Position Absolute
	VPB    = Name("\033[k")   // Line Position Backward
	VPR    = Name("\033[e")   // Line Position Forward
	VTS    = Name("\033J")    // Line Tabulation Set
	C0     = Name("\033!@")   // Control Set 0 Announcer
	C1     = Name("\033&@")   // Control Set 1 Announcer
	C1ALT1 = Name("\033 F")   // Control Set 1 Announcer Alternate 1
	C1ALT2 = Name("\033\"F")  // Control Set 1 Announcer Alternate 2
)

// NUL is used for media-fill or time-fill. NUL characters may be inserted
// into, or removed from, a data stream without affecting the information
// content of that stream, but such action may affect the information layout
// and/or the control of equipment.
var NUL_ = Sequence{
	Name: "NUL",
	Desc: "Null",
	Code: []byte(NUL),
}

// SOH is used to indicate the beginning of a heading.
//
// The use of SOH is defined in ISO 1745.
var SOH_ = Sequence{
	Name: "SOH",
	Desc: "Start of Heading",
	Code: []byte(SOH),
}

// STX is used to indicate the beginning of a text and the end of a heading.
//
// The use of STX is defined in ISO 1745.
var STX_ = Sequence{
	Name: "STX",
	Desc: "Start of Text",
	Code: []byte(STX),
}

// ETX is used to indicate the end of a text.
//
// The use of ETX is defined in ISO 1745.
var ETX_ = Sequence{
	Name: "ETX",
	Desc: "End of Text",
	Code: []byte(ETX),
}

// EOT is used to indicate the conclusion of the transmission of one or more
// texts.
//
// The use of EOT is defined in ISO 1745.
var EOT_ = Sequence{
	Name: "EOT",
	Desc: "End of Transmission",
	Code: []byte(EOT),
}

// ENQ is transmitted by a sender as a request for a response from a receiver.
//
// The use of ENQ is defined in ISO 1745.
var ENQ_ = Sequence{
	Name: "ENQ",
	Desc: "Enquiry",
	Code: []byte(ENQ),
}

// ACK is transmitted by a receiver as an affirmative response to the sender.
//
// The use of ACK is defined in ISO 1745.
var ACK_ = Sequence{
	Name: "ACK",
	Desc: "Acknowledge",
	Code: []byte(ACK),
}

// BEL is used when there is a need to call for attention; it may control alarm
// or attention devices.
var BEL_ = Sequence{
	Name: "BEL",
	Desc: "Bell",
	Code: []byte(BEL),
}

// BS causes the active data position to be moved one character position in the
// data component in the direction opposite to that of the implicit movement.
//
// The direction of the implicit movement depends on the parameter value of
// SELECT IMPLICIT MOVEMENT DIRECTION (SIMD).
var BS_ = Sequence{
	Name: "BS",
	Desc: "Backspace",
	Code: []byte(BS),
}

// HT causes the active presentation position to be moved to the following
// character tabulation stop in the presentation component.
//
// In addition, if that following character tabulation stop has been set by
// TABULATION ALIGN CENTRE (TAC), TABULATION ALIGN LEADING EDGE (TALE),
// TABULATION ALIGN TRAILING EDGE (TATE) or TABULATION CENTRED ON CHARACTER
// (TCC), HT indicates the beginning of a string of text which is to be
// positioned within a line according to the properties of that tabulation
// stop. The end of the string is indicated by the next occurrence of HT or
// CARRIAGE RETURN (CR) or NEXT LINE (NEL) in the data stream.
var HT_ = Sequence{
	Name: "HT",
	Desc: "Character Tabulation",
	Code: []byte(HT),
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, LF causes
// the active presentation position to be moved to the corresponding character
// position of the following line in the presentation component.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, LF causes the
// active data position to be moved to the corresponding character position of
// the following line in the data component.
var LF_ = Sequence{
	Name: "LF",
	Desc: "Line Feed",
	Code: []byte(LF),
}

// VT causes the active presentation position to be moved in the presentation
// component to the corresponding character position on the line at which the
// following line tabulation stop is set.
var VT_ = Sequence{
	Name: "VT",
	Desc: "Line Tabulation",
	Code: []byte(VT),
}

// FF causes the active presentation position to be moved to the corresponding
// character position of the line at the page home position of the next form or
// page in the presentation component. The page home position is established by
// the parameter value of SET PAGE HOME (SPH).
var FF_ = Sequence{
	Name: "FF",
	Desc: "Form Feed",
	Code: []byte(FF),
}

// The effect of CR depends on the setting of the DEVICE COMPONENT SELECT MODE
// (DCSM) and on the parameter value of SELECT IMPLICIT MOVEMENT DIRECTION
// (SIMD).
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION and with
// the parameter value of SIMD equal to 0, CR causes the active presentation
// position to be moved to the line home position of the same line in the
// presentation component. The line home position is established by the
// parameter value of SET LINE HOME (SLH).
//
// With a parameter value of SIMD equal to 1, CR causes the active presentation
// position to be moved to the line limit position of the same line in the
// presentation component. The line limit position is established by the
// parameter value of SET LINE LIMIT (SLL).
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA and with a
// parameter value of SIMD equal to 0, CR causes the active data position to be
// moved to the line home position of the same line in the data component. The
// line home position is established by the parameter value of SET LINE HOME
// (SLH).
//
// With a parameter value of SIMD equal to 1, CR causes the active data
// position to be moved to the line limit position of the same line in the data
// component. The line limit position is established by the parameter value of
// SET LINE LIMIT (SLL).
var CR_ = Sequence{
	Name: "CR",
	Desc: "Carriage Return",
	Code: []byte(CR),
}

// SO is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of SO is defined in Standard ECMA-35.
//
// NOTE
//
// SO is used in 7-bit environments only; in 8-bit environments LOCKING-SHIFT
// ONE (LS1) is used instead.
var SO_ = Sequence{
	Name: "SO",
	Desc: "Shift-Out",
	Code: []byte(SO),
}

// SI is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of SI is defined in Standard ECMA-35.
//
// NOTE
//
// SI is used in 7-bit environments only; in 8-bit environments LOCKING-SHIFT
// ZERO (LS0) is used instead.
var SI_ = Sequence{
	Name: "SI",
	Desc: "Shift-In",
	Code: []byte(SI),
}

// DLE is used exclusively to provide supplementary transmission control
// functions.
//
// The use of DLE is defined in ISO 1745.
var DLE_ = Sequence{
	Name: "DLE",
	Desc: "Data Link Escape",
	Code: []byte(DLE),
}

// DC1 is primarily intended for turning on or starting an ancillary device. If
// it is not required for this purpose, it may be used to restore a device to
// the basic mode of operation (see also DC2 and DC3), or any other device
// control function not provided by other DCs.
//
// NOTE
//
// When used for data flow control, DC1 is sometimes called "X-ON".
var DC1_ = Sequence{
	Name: "DC1",
	Desc: "Device Control One",
	Code: []byte(DC1),
}

// DC2 is primarily intended for turning on or starting an ancillary device. If
// it is not required for this purpose, it may be used to set a device to a
// special mode of operation (in which case DC1 is used to restore the device
// to the basic mode), or for any other device control function not provided by
// other DCs.
var DC2_ = Sequence{
	Name: "DC2",
	Desc: "Device Control Two",
	Code: []byte(DC2),
}

// DC3 is primarily intended for turning off or stopping an ancillary device.
// This function may be a secondary level stop, for example wait, pause,
// stand-by or halt (in which case DC1 is used to restore normal operation). If
// it is not required for this purpose, it may be used for any other device
// control function not provided by other DCs.
//
// NOTE
//
// When used for data flow control, DC3 is sometimes called "X-OFF".
var DC3_ = Sequence{
	Name: "DC3",
	Desc: "Device Control Three",
	Code: []byte(DC3),
}

// DC4 is primarily intended for turning off, stopping or interrupting an
// ancillary device. If it is not required for this purpose, it may be used for
// any other device control function not provided by other DCs.
var DC4_ = Sequence{
	Name: "DC4",
	Desc: "Device Control Four",
	Code: []byte(DC4),
}

// NAK is transmitted by a receiver as a negative response to the sender.
//
// The use of NAK is defined in ISO 1745.
var NAK_ = Sequence{
	Name: "NAK",
	Desc: "Negative Acknowledge",
	Code: []byte(NAK),
}

// SYN is used by a synchronous transmission system in the absence of any other
// character (idle condition) to provide a signal from which synchronism may be
// achieved or retained between data terminal equipment.
//
// The use of SYN is defined in ISO 1745.
var SYN_ = Sequence{
	Name: "SYN",
	Desc: "Synchronous Idle",
	Code: []byte(SYN),
}

// ETB is used to indicate the end of a block of data where the data are
// divided into such blocks for transmission purposes.
//
// The use of ETB is defined in ISO 1745.
var ETB_ = Sequence{
	Name: "ETB",
	Desc: "End of Transmission Block",
	Code: []byte(ETB),
}

// CAN is used to indicate that the data preceding it in the data stream is in
// error. As a result, this data shall be ignored. The specific meaning of this
// control function shall be defined for each application and/or between sender
// and recipient.
var CAN_ = Sequence{
	Name: "CAN",
	Desc: "Cancel",
	Code: []byte(CAN),
}

// EM is used to identify the physical end of a medium, or the end of the used
// portion of a medium, or the end of the wanted portion of data recorded on a
// medium.
var EM_ = Sequence{
	Name: "EM",
	Desc: "End of Medium",
	Code: []byte(EM),
}

// SUB is used in the place of a character that has been found to be invalid or
// in error. SUB is intended to be introduced by automatic means.
var SUB_ = Sequence{
	Name: "SUB",
	Desc: "Substitute",
	Code: []byte(SUB),
}

// ESC is used for code extension purposes. It causes the meanings of a limited
// number of bit combinations following it in the data stream to be changed.
//
// The use of ESC is defined in Standard ECMA-35.
var ESC_ = Sequence{
	Name: "ESC",
	Desc: "Escape",
	Code: []byte(ESC),
}

// IS4 is used to separate and qualify data logically; its specific meaning has
// to be defined for each application. If this control function is used in
// hierarchical order, it may delimit a data item called a file, see 8.2.10.
var IS4_ = Sequence{
	Name: "IS4",
	Desc: "Information Separator Four (FS - File Separator)",
	Code: []byte(IS4),
}

// IS3 is used to separate and qualify data logically; its specific meaning has
// to be defined for each application. If this control function is used in
// hierarchical order, it may delimit a data item called a group, see 8.2.10.
var IS3_ = Sequence{
	Name: "IS3",
	Desc: "Information Separator Three (GS - Group Separator)",
	Code: []byte(IS3),
}

// IS2 is used to separate and qualify data logically; its specific meaning has
// to be defined for each application. If this control function is used in
// hierarchical order, it may delimit a data item called a record, see 8.2.10.
var IS2_ = Sequence{
	Name: "IS2",
	Desc: "Information Separator Two (RS - Record Separator)",
	Code: []byte(IS2),
}

// IS1 is used to separate and qualify data logically; its specific meaning has
// to be defined for each application. If this control function is used in
// hierarchical order, it may delimit a data item called a unit, see 8.2.10.
var IS1_ = Sequence{
	Name: "IS1",
	Desc: "Information Separator One (US - Unit Separator)",
	Code: []byte(IS1),
}

// APC is used as the opening delimiter of a control string for application
// program use. The command string following may consist of bit combinations in
// the range 00/08 to 00/13 and 02/00 to 07/14. The control string is closed by
// the terminating delimiter STRING TERMINATOR (ST). The interpretation of the
// command string depends on the relevant application program.
var APC_ = Sequence{
	Name: "APC",
	Desc: "Application Program Command",
	Type: ESC,
	Code: []byte{'_'},
}

// BPH is used to indicate a point where a line break may occur when text is
// formatted. BPH may occur between two graphic characters, either or both of
// which may be SPACE.
var BPH_ = Sequence{
	Name: "BPH",
	Desc: "Break Permitted Here",
	Type: ESC,
	Code: []byte{'B'},
}

// CBT causes the active presentation position to be moved to the character
// position corresponding to the n-th preceding character tabulation stop in
// the presentation component, according to the character path, where n equals
// the value of Pn.
var CBT_ = Sequence{
	Name:     "CBT",
	Desc:     "Cursor Backward Tabulation",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'Z'},
}

// CCH is used to indicate that both the preceding graphic character in the
// data stream, (represented by one or more bit combinations) including SPACE,
// and the control function CCH itself are to be ignored for further
// interpretation of the data stream.
//
// If the character preceding CCH in the data stream is a control function
// (represented by one or more bit combinations), the effect of CCH is not
// defined by this Standard.
var CCH_ = Sequence{
	Name: "CCH",
	Desc: "Cancel Character",
	Type: ESC,
	Code: []byte{'T'},
}

// CHA causes the active presentation position to be moved to character
// position n in the active line in the presentation component, where n equals
// the value of Pn.
var CHA_ = Sequence{
	Name:     "CHA",
	Desc:     "Cursor Character Absolute",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'G'},
}

// CHT causes the active presentation position to be moved to the character
// position corresponding to the n-th following character tabulation stop in
// the presentation component, according to the character path, where n equals
// the value of Pn.
var CHT_ = Sequence{
	Name:     "CHT",
	Desc:     "Cursor Forward Tabulation",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'I'},
}

// CMD is used as the delimiter of a string of data coded according to Standard
// ECMA-35 and to switch to a general level of control.
//
// The use of CMD is not mandatory if the higher level protocol defines means
// of delimiting the string, for instance, by specifying the length of the
// string.
var CMD_ = Sequence{
	Name: "CMD",
	Desc: "Coding Method Delimiter",
	Type: ESC,
	Code: []byte{'d'},
}

// CNL causes the active presentation position to be moved to the first
// character position of the n-th following line in the presentation component,
// where n equals the value of Pn.
var CNL_ = Sequence{
	Name:     "CNL",
	Desc:     "Cursor Next Line",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'E'},
}

// CPL causes the active presentation position to be moved to the first
// character position of the n-th preceding line in the presentation component,
// where n equals the value of Pn.
var CPL_ = Sequence{
	Name:     "CPL",
	Desc:     "Cursor Preceding Line",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'F'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, CPR is
// used to report the active presentation position of the sending device as
// residing in the presentation component at the n-th line position according
// to the line progression and at the m-th character position according to the
// character path, where n equals the value of Pn1 and m equals the value of
// Pn2.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, CPR is used to
// report the active data position of the sending device as residing in the
// data component at the n-th line position according to the line progression
// and at the m-th character position according to the character progression,
// where n equals the value of Pn1 and m equals the value of Pn2.
//
// CPR may be solicited by a DEVICE STATUS REPORT (DSR) or be sent unsolicited.
var CPR_ = Sequence{
	Name:     "CPR",
	Desc:     "Active Position Report",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	Defaults: []string{"1", "1"},
	Code:     []byte{'R'},
}

// CSI is used as the first character of a control sequence, see 5.4.
var CSI_ = Sequence{
	Name: "CSI",
	Desc: "Control Sequence Introducer",
	Type: ESC,
	Code: []byte{'['},
}

// CTC causes one or more tabulation stops to be set or cleared in the
// presentation component, depending on the parameter values:
//
// 0 a character tabulation stop is set at the active presentation position
//
// 1 a line tabulation stop is set at the active line (the line that contains
// the active presentation position)
//
// 2 the character tabulation stop at the active presentation position is
// cleared
//
// 3 the line tabulation stop at the active line is cleared
//
// 4 all character tabulation stops in the active line are cleared
//
// 5 all character tabulation stops are cleared
//
// 6 all line tabulation stops are cleared
//
// In the case of parameter values 0, 2 or 4 the number of lines affected
// depends on the setting of the TABULATION STOP MODE (TSM).
var CTC_ = Sequence{
	Name:     "CTC",
	Desc:     "Cursor Tabulation Control",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{'W'},
}

// CUB causes the active presentation position to be moved leftwards in the
// presentation component by n character positions if the character path is
// horizontal, or by n line positions if the character path is vertical, where
// n equals the value of Pn.
var CUB_ = Sequence{
	Name:     "CUB",
	Desc:     "Cursor Left",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'D'},
}

// CUD causes the active presentation position to be moved downwards in the
// presentation component by n line positions if the character path is
// horizontal, or by n character positions if the character path is vertical,
// where n equals the value of Pn.
var CUD_ = Sequence{
	Name:     "CUD",
	Desc:     "Cursor Down",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'B'},
}

// CUF causes the active presentation position to be moved rightwards in the
// presentation component by n character positions if the character path is
// horizontal, or by n line positions if the character path is vertical, where
// n equals the value of Pn.
var CUF_ = Sequence{
	Name:     "CUF",
	Desc:     "Cursor Right",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'C'},
}

// CUP causes the active presentation position to be moved in the presentation
// component to the n-th line position according to the line progression and to
// the m-th character position according to the character path, where n equals
// the value of Pn1 and m equals the value of Pn2.
var CUP_ = Sequence{
	Name:     "CUP",
	Desc:     "Cursor Position",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	Defaults: []string{"1", "1"},
	Code:     []byte{'H'},
}

// CUU causes the active presentation position to be moved upwards in the
// presentation component by n line positions if the character path is
// horizontal, or by n character positions if the character path is vertical,
// where n equals the value of Pn.
var CUU_ = Sequence{
	Name:     "CUU",
	Desc:     "Cursor Up",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'A'},
}

// CVT causes the active presentation position to be moved to the corresponding
// character position of the line corresponding to the n-th following line
// tabulation stop in the presentation component, where n equals the value of
// Pn.
var CVT_ = Sequence{
	Name:     "CVT",
	Desc:     "Cursor Line Tabulation",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'Y'},
}

// With a parameter value not equal to 0, DA is used to identify the device
// which sends the DA. The parameter value is a device type identification code
// according to a register which is to be established. If the parameter value
// is 0, DA is used to request an identifying DA from a device.
var DA_ = Sequence{
	Name:     "DA",
	Desc:     "Device Attributes",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'c'},
}

// DAQ is used to indicate that the active presentation position in the
// presentation component is the first character position of a qualified area.
// The last character position of the qualified area is the character position
// in the presentation component immediately preceding the first character
// position of the following qualified area.
//
// The parameter value designates the type of qualified area:
//
// 0 unprotected and unguarded
//
// 1 protected and guarded
//
// 2 graphic character input
//
// 3 numeric input
//
// 4 alphabetic input
//
// 5 input aligned on the last character position of the qualified area
//
// 6 fill with ZEROs
//
// 7 set a character tabulation stop at the active presentation position (the
// first character position of the qualified area) to indicate the beginning of
// a field
//
// 8 protected and unguarded
//
// 9 fill with SPACEs
//
// 10 input aligned on the first character position of the qualified area
//
// 11 the order of the character positions in the input field is reversed, i.e.
// the last position in each line becomes the first and vice versa; input
// begins at the new first position.
//
// This control function operates independently of the setting of the
// TABULATION STOP MODE (TSM). The character tabulation stop set by parameter
// value 7 applies to the active line only.
//
// NOTE
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string or an SDS string.
var DAQ_ = Sequence{
	Name:     "DAQ",
	Desc:     "Define Area Qualification",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{'o'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, DCH
// causes the contents of the active presentation position and, depending on
// the setting of the CHARACTER EDITING MODE (HEM), the contents of the n-1
// preceding or following character positions to be removed from the
// presentation component, where n equals the value of Pn. The resulting gap is
// closed by shifting the contents of the adjacent character positions towards
// the active presentation position. At the other end of the shifted part, n
// character positions are put into the erased state.
//
// The extent of the shifted part is established by SELECT EDITING EXTENT (SEE).
//
// The effect of DCH on the start or end of a selected area, the start or end
// of a qualified area, or a tabulation stop in the shifted part is not defined
// by this Standard.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, DCH causes the
// contents of the active data position and, depending on the setting of the
// CHARACTER EDITING MODE (HEM), the contents of the n-1 preceding or following
// character positions to be removed from the data component, where n equals
// the value of Pn. The resulting gap is closed by shifting the contents of the
// adjacent character positions towards the active data position. At the other
// end of the shifted part, n character positions are put into the erased state.
var DCH_ = Sequence{
	Name:     "DCH",
	Desc:     "Delete Character",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'P'},
}

// DCS is used as the opening delimiter of a control string for device control
// use. The command string following may consist of bit combinations in the
// range 00/08 to 00/13 and 02/00 to 07/14. The control string is closed by the
// terminating delimiter STRING TERMINATOR (ST).
//
// The command string represents either one or more commands for the receiving
// device, or one or more status reports from the sending device. The purpose
// and the format of the command string are specified by the most recent
// occurrence of IDENTIFY DEVICE CONTROL STRING (IDCS), if any, or depend on
// the sending and/or the receiving device.
var DCS_ = Sequence{
	Name: "DCS",
	Desc: "Device Control String",
	Type: ESC,
	Code: []byte{'P'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, DL causes
// the contents of the active line (the line that contains the active
// presentation position) and, depending on the setting of the LINE EDITING
// MODE (VEM), the contents of the n-1 preceding or following lines to be
// removed from the presentation component, where n equals the value of Pn. The
// resulting gap is closed by shifting the contents of a number of adjacent
// lines towards the active line. At the other end of the shifted part, n lines
// are put into the erased state.
//
// The active presentation position is moved to the line home position in the
// active line. The line home position is established by the parameter value of
// SET LINE HOME (SLH). If the TABULATION STOP MODE (TSM) is set to SINGLE,
// character tabulation stops are cleared in the lines that are put into the
// erased state.
//
// The extent of the shifted part is established by SELECT EDITING EXTENT (SEE).
//
// Any occurrences of the start or end of a selected area, the start or end of
// a qualified area, or a tabulation stop in the shifted part, are also shifted.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, DL causes the
// contents of the active line (the line that contains the active data
// position) and, depending on the setting of the LINE EDITING MODE (VEM), the
// contents of the n-1 preceding or following lines to be removed from the data
// component, where n equals the value of Pn. The resulting gap is closed by
// shifting the contents of a number of adjacent lines towards the active line.
// At the other end of the shifted part, n lines are put into the erased state.
// The active data position is moved to the line home position in the active
// line. The line home position is established by the parameter value of SET
// LINE HOME (SLH).
var DL_ = Sequence{
	Name:     "DL",
	Desc:     "Delete Line",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'M'},
}

// DMI causes the manual input facilities of a device to be disabled.
var DMI_ = Sequence{
	Name: "DMI",
	Desc: "Disable Manual Input",
	Type: ESC,
	Code: []byte{'`'},
}

// DSR is used either to report the status of the sending device or to request
// a status report from the receiving device, depending on the parameter values:
//
// 0 ready, no malfunction detected
//
// 1 busy, another DSR must be requested later
//
// 2 busy, another DSR will be sent later
//
// 3 some malfunction detected, another DSR must be requested later
//
// 4 some malfunction detected, another DSR will be sent later
//
// 5 a DSR is requested
//
// 6 a report of the active presentation position or of the active data
// position in the form of ACTIVE POSITION REPORT (CPR) is requested
//
// DSR with parameter value 0, 1, 2, 3 or 4 may be sent either unsolicited or
// as a response to a request such as a DSR with a parameter value 5 or MESSAGE
// WAITING (MW).
var DSR_ = Sequence{
	Name:     "DSR",
	Desc:     "Device Status Report",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'n'},
}

// DTA is used to establish the dimensions of the text area for subsequent
// pages.
//
// The established dimensions remain in effect until the next occurrence of DTA
// in the data stream.
//
// Pn1 specifies the dimension in the direction perpendicular to the line
// orientation
//
// Pn2 specifies the dimension in the direction parallel to the line orientation
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var DTA_ = Sequence{
	Name:     "DTA",
	Desc:     "Dimension Text Area",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	MinParam: 2,
	Code:     []byte{' ', 'T'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, EA causes
// some or all character positions in the active qualified area (the qualified
// area in the presentation component which contains the active presentation
// position) to be put into the erased state, depending on the parameter values:
//
// 0 the active presentation position and the character positions up to the end
// of the qualified area are put into the erased state
//
// 1 the character positions from the beginning of the qualified area up to and
// including the active presentation position are put into the erased state
//
// 2 all character positions of the qualified area are put into the erased state
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, EA causes some or
// all character positions in the active qualified area (the qualified area in
// the data component which contains the active data position) to be put into
// the erased state, depending on the parameter values:
//
// 0 the active data position and the character positions up to the end of the
// qualified area are put into the erased state
//
// 1 the character positions from the beginning of the qualified area up to and
// including the active data position are put into the erased state
//
// 2 all character positions of the qualified area are put into the erased state
//
// Whether the character positions of protected areas are put into the erased
// state, or the character positions of unprotected areas only, depends on the
// setting of the ERASURE MODE (ERM).
var EA_ = Sequence{
	Name:     "EA",
	Desc:     "Erase in Area",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'O'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, ECH
// causes the active presentation position and the n-1 following character
// positions in the presentation component to be put into the erased state,
// where n equals the value of Pn.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, ECH causes the
// active data position and the n-1 following character positions in the data
// component to be put into the erased state, where n equals the value of Pn.
//
// Whether the character positions of protected areas are put into the erased
// state, or the character positions of unprotected areas only, depends on the
// setting of the ERASURE MODE (ERM).
var ECH_ = Sequence{
	Name:     "ECH",
	Desc:     "Erase Character",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'X'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, ED causes
// some or all character positions of the active page (the page which contains
// the active presentation position in the presentation component) to be put
// into the erased state, depending on the parameter values:
//
// 0 the active presentation position and the character positions up to the end
// of the page are put into the erased state
//
// 1 the character positions from the beginning of the page up to and including
// the active presentation position are put into the erased state
//
// 2 all character positions of the page are put into the erased state
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, ED causes some or
// all character positions of the active page (the page which contains the
// active data position in the data component) to be put into the erased state,
// depending on the parameter values:
//
// 0 the active data position and the character positions up to the end of the
// page are put into the erased state
//
// 1 the character positions from the beginning of the page up to and including
// the active data position are put into the erased state
//
// 2 all character positions of the page are put into the erased state
//
// Whether the character positions of protected areas are put into the erased
// state, or the character positions of unprotected areas only, depends on the
// setting of the ERASURE MODE (ERM).
var ED_ = Sequence{
	Name:     "ED",
	Desc:     "Erase in Page",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'J'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, EF causes
// some or all character positions of the active field (the field which
// contains the active presentation position in the presentation component) to
// be put into the erased state, depending on the parameter values:
//
// 0 the active presentation position and the character positions up to the end
// of the field are put into the erased state
//
// 1 the character positions from the beginning of the field up to and
// including the active presentation position are put into the erased state
//
// 2 all character positions of the field are put into the erased state
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, EF causes some or
// all character positions of the active field (the field which contains the
// active data position in the data component) to be put into the erased state,
// depending on the parameter values:
//
// 0 the active data position and the character positions up to the end of the
// field are put into the erased state
//
// 1 the character positions from the beginning of the field up to and
// including the active data position are put into the erased state
//
// 2 all character positions of the field are put into the erased state
//
// Whether the character positions of protected areas are put into the erased
// state, or the character positions of unprotected areas only, depends on the
// setting of the ERASURE MODE (ERM).
var EF_ = Sequence{
	Name:     "EF",
	Desc:     "Erase in Field",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'N'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, EL causes
// some or all character positions of the active line (the line which contains
// the active presentation position in the presentation component) to be put
// into the erased state, depending on the parameter values:
//
// 0 the active presentation position and the character positions up to the end
// of the line are put into the erased state
//
// 1 the character positions from the beginning of the line up to and including
// the active presentation position are put into the erased state
//
// 2 all character positions of the line are put into the erased state
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, EL causes some or
// all character positions of the active line (the line which contains the
// active data position in the data component) to be put into the erased state,
// depending on the parameter values:
//
// 0 the active data position and the character positions up to the end of the
// line are put into the erased state
//
// 1 the character positions from the beginning of the line up to and including
// the active data position are put into the erased state
//
// 2 all character positions of the line are put into the erased state
//
// Whether the character positions of protected areas are put into the erased
// state, or the character positions of unprotected areas only, depends on the
// setting of the ERASURE MODE (ERM).
var EL_ = Sequence{
	Name:     "EL",
	Desc:     "Erase in Line",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'K'},
}

// EMI is used to enable the manual input facilities of a device.
var EMI_ = Sequence{
	Name: "EMI",
	Desc: "Enable Manual Input",
	Type: ESC,
	Code: []byte{'b'},
}

// EPA is used to indicate that the active presentation position is the last of
// a string of character positions in the presentation component, the contents
// of which are protected against manual alteration, are guarded against
// transmission or transfer, depending on the setting of the GUARDED AREA
// TRANSFER MODE (GATM), and may be protected against erasure, depending on the
// setting of the ERASURE MODE (ERM). The beginning of this string is indicated
// by START OF GUARDED AREA (SPA).
//
// NOTE
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string or an SDS string.
var EPA_ = Sequence{
	Name: "EPA",
	Desc: "End of Guarded Area",
	Type: ESC,
	Code: []byte{'W'},
}

// ESA is used to indicate that the active presentation position is the last of
// a string of character positions in the presentation component, the contents
// of which are eligible to be transmitted in the form of a data stream or
// transferred to an auxiliary input/output device. The beginning of this
// string is indicated by START OF SELECTED AREA (SSA).
//
// NOTE
//
// The control function for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string or an SDS string.
var ESA_ = Sequence{
	Name: "ESA",
	Desc: "End of Selected Area",
	Type: ESC,
	Code: []byte{'G'},
}

// FNK is a control function in which the parameter value identifies the
// function key which has been operated.
var FNK_ = Sequence{
	Name:     "FNK",
	Desc:     "Function Key",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'W'},
}

// FNT is used to identify the character font to be selected as primary or
// alternative font by subsequent occurrences of SELECT GRAPHIC RENDITION (SGR)
// in the data stream. Ps1 specifies the primary or alternative font concerned:
//
// 0 primary font
//
// 1 first alternative font
//
// 2 second alternative font
//
// 3 third alternative font
//
// 4 fourth alternative font
//
// 5 fifth alternative font
//
// 6 sixth alternative font
//
// 7 seventh alternative font
//
// 8 eighth alternative font
//
// 9 ninth alternative font
//
// Ps2 identifies the character font according to a register which is to be
// established.
var FNT_ = Sequence{
	Name:     "FNT",
	Desc:     "Font Selection",
	Type:     CSI,
	Notation: "Ps1;Ps2",
	NParam:   2,
	Defaults: []string{"0", "0"},
	Code:     []byte{' ', 'D'},
}

// GCC is used to indicate that two or more graphic characters are to be imaged
// as one single graphic symbol. GCC with a parameter value of 0 indicates that
// the following two graphic characters are to be imaged as one single graphic
// symbol; GCC with a parameter value of 1 and GCC with a parameter value of 2
// indicate respectively the beginning and the end of a string of graphic
// characters which are to be imaged as one single graphic symbol.
//
// NOTE
//
// GCC does not explicitly specify the relative sizes or placements of the
// component parts of a composite graphic symbol. In the simplest case, two
// components may be "half-width" and side-by-side. For
//
// example, in Japanese text a pair of characters may be presented
// side-by-side, and occupy the space of a normal-size Kanji character.
var GCC_ = Sequence{
	Name:     "GCC",
	Desc:     "Graphic Character Combination",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', '_'},
}

// GSM is used to modify for subsequent text the height and/or the width of all
// primary and alternative fonts identified by FONT SELECTION (FNT) and
// established by GRAPHIC SIZE SELECTION (GSS). The established values remain
// in effect until the next occurrence of GSM or GSS in the data steam.
//
// Pn1 specifies the height as a percentage of the height established by GSS
//
// Pn2 specifies the width as a percentage of the width established by GSS
var GSM_ = Sequence{
	Name:     "GSM",
	Desc:     "Graphic Size Modification",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	Defaults: []string{"100", "100"},
	Code:     []byte{' ', 'B'},
}

// GSS is used to establish for subsequent text the height and the width of all
// primary and alternative fonts identified by FONT SELECTION (FNT). The
// established values remain in effect until the next occurrence of GSS in the
// data stream.
//
// Pn specifies the height, the width is implicitly defined by the height.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var GSS_ = Sequence{
	Name:     "GSS",
	Desc:     "Graphic Size Selection",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'C'},
}

// HPA causes the active data position to be moved to character position n in
// the active line (the line in the data component that contains the active
// data position), where n equals the value of Pn.
var HPA_ = Sequence{
	Name:     "HPA",
	Desc:     "Character Position Absolute",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'`'},
}

// HPB causes the active data position to be moved by n character positions in
// the data component in the direction opposite to that of the character
// progression, where n equals the value of Pn.
var HPB_ = Sequence{
	Name:     "HPB",
	Desc:     "Character Position Backward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'j'},
}

// HPR causes the active data position to be moved by n character positions in
// the data component in the direction of the character progression, where n
// equals the value of Pn.
var HPR_ = Sequence{
	Name:     "HPR",
	Desc:     "Character Position Forward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'a'},
}

// HTJ causes the contents of the active field (the field in the presentation
// component that contains the active presentation position) to be shifted
// forward so that it ends at the character position preceding the following
// character tabulation stop. The active presentation position is moved to that
// following character tabulation stop. The character positions which precede
// the beginning of the shifted string are put into the erased state.
var HTJ_ = Sequence{
	Name: "HTJ",
	Desc: "Character Tabulation With Justification",
	Type: ESC,
	Code: []byte{'I'},
}

// HTS causes a character tabulation stop to be set at the active presentation
// position in the presentation component.
//
// The number of lines affected depends on the setting of the TABULATION STOP
// MODE (TSM).
var HTS_ = Sequence{
	Name: "HTS",
	Desc: "Character Tabulation Set",
	Type: ESC,
	Code: []byte{'H'},
}

// HVP causes the active data position to be moved in the data component to the
// n-th line position according to the line progression and to the m-th
// character position according to the character progression, where n equals
// the value of Pn1 and m equals the value of Pn2.
var HVP_ = Sequence{
	Name:     "HVP",
	Desc:     "Character and Line Position",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	Defaults: []string{"1", "1"},
	Code:     []byte{'f'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, ICH is
// used to prepare the insertion of n characters, by putting into the erased
// state the active presentation position and, depending on the setting of the
// CHARACTER EDITING MODE (HEM), the n-1 preceding or following character
// positions in the presentation component, where n equals the value of Pn. The
// previous contents of the active presentation position and an adjacent string
// of character positions are shifted away from the active presentation
// position. The contents of n character positions at the other end of the
// shifted part are removed. The active presentation position is moved to the
// line home position in the active line. The line home position is established
// by the parameter value of SET LINE HOME (SLH).
//
// The extent of the shifted part is established by SELECT EDITING EXTENT (SEE).
//
// The effect of ICH on the start or end of a selected area, the start or end
// of a qualified area, or a tabulation stop in the shifted part, is not
// defined by this Standard.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, ICH is used to
// prepare the insertion of n characters, by putting into the erased state the
// active data position and, depending on the setting of the CHARACTER EDITING
// MODE (HEM), the n-1 preceding or following character positions in the data
// component, where n equals the value of Pn. The previous contents of the
// active data position and an adjacent string of character positions are
// shifted away from the active data position. The contents of n character
// positions at the other end of the shifted part are removed. The active data
//
// position is moved to the line home position in the active line. The line
// home position is established by the parameter value of SET LINE HOME (SLH).
var ICH_ = Sequence{
	Name:     "ICH",
	Desc:     "Insert Character",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'@'},
}

// IDCS is used to specify the purpose and format of the command string of
// subsequent DEVICE CONTROL STRINGs (DCS). The specified purpose and format
// remain in effect until the next occurrence of IDCS in the data stream.
//
// The parameter values are
//
// 1 reserved for use with the DIAGNOSTIC state of the STATUS REPORT TRANSFER
// MODE (SRTM)
//
// 2 reserved for Dynamically Redefinable Character Sets (DRCS) according to
// Standard ECMA-35.
//
// The format and interpretation of the command string corresponding to these
// parameter values are to be defined in appropriate standards. If this control
// function is used to identify a private command string, a private parameter
// value shall be used.
var IDCS_ = Sequence{
	Name:     "IDCS",
	Desc:     "Identify Device Control String",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'O'},
}

// IGS is used to indicate that a repertoire of the graphic characters of
// ISO/IEC 10367 is used in the subsequent text.
//
// The parameter value of IGS identifies a graphic character repertoire
// registered in accordance with ISO/IEC 7350.
var IGS_ = Sequence{
	Name:     "IGS",
	Desc:     "Identify Graphic Subrepertoire",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'M'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, IL is
// used to prepare the insertion of n lines, by putting into the erased state
// in the presentation component the active line (the line that contains the
// active presentation position) and, depending on the setting of the LINE
// EDITING MODE (VEM), the n-1 preceding or following lines, where n equals the
// value of Pn. The previous contents of the active line and of adjacent lines
// are shifted away from the active line. The contents of n lines at the other
// end of the shifted part are removed. The active presentation position is
// moved to the line home position in the active line. The line home position
// is established by the parameter value of SET LINE HOME (SLH).
//
// The extent of the shifted part is established by SELECT EDITING EXTENT (SEE).
//
// Any occurrences of the start or end of a selected area, the start or end of
// a qualified area, or a tabulation stop in the shifted part, are also shifted.
//
// If the TABULATION STOP MODE (TSM) is set to SINGLE, character tabulation
// stops are cleared in the lines that are put into the erased state.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, IL is used to
// prepare the insertion of n lines, by putting into the erased state in the
// data component the active line (the line that contains the active data
// position) and, depending on the setting of the LINE EDITING MODE (VEM), the
// n-1 preceding or following lines, where n equals the value of Pn. The
// previous contents of the active line and of adjacent lines are shifted away
// from the active line. The contents of n lines at the other end of the
// shifted part are removed. The active data position is moved to the line home
// position in the active line. The line home position is established by the
// parameter value of SET LINE HOME (SLH).
var IL_ = Sequence{
	Name:     "IL",
	Desc:     "Insert Line",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'L'},
}

// INT is used to indicate to the receiving device that the current process is
// to be interrupted and an agreed procedure is to be initiated. This control
// function is applicable to either direction of transmission.
var INT_ = Sequence{
	Name: "INT",
	Desc: "Interrupt",
	Type: ESC,
	Code: []byte{'a'},
}

// JFY is used to indicate the beginning of a string of graphic characters in
// the presentation component that are to be justified according to the layout
// specified by the parameter values, see annex C:
//
// 0 no justification, end of justification of preceding text
//
// 1 word fill
//
// 2 word space
//
// 3 letter space
//
// 4 hyphenation
//
// 5 flush to line home position margin
//
// 6 centre between line home position and line limit position margins
//
// 7 flush to line limit position margin
//
// 8 Italian hyphenation
//
// The end of the string to be justified is indicated by the next occurrence of
// JFY in the data stream.
//
// The line home position is established by the parameter value of SET LINE
// HOME (SLH). The line limit position is established by the parameter value of
// SET LINE LIMIT (SLL).
var JFY_ = Sequence{
	Name:     "JFY",
	Desc:     "Justify",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'F'},
}

// LS1R is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of LS1R is defined in Standard ECMA-35.
var LS1R_ = Sequence{
	Name: "LS1R",
	Desc: "Locking-Shift One Right",
	Type: ESC,
	Code: []byte{'~'},
}

// LS2 is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of LS2 is defined in Standard ECMA-35.
var LS2_ = Sequence{
	Name: "LS2",
	Desc: "Locking-Shift Two",
	Type: ESC,
	Code: []byte{'n'},
}

// LS2R is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of LS2R is defined in Standard ECMA-35.
var LS2R_ = Sequence{
	Name: "LS2R",
	Desc: "Locking-Shift Two Right",
	Type: ESC,
	Code: []byte{'}'},
}

// LS3 is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of LS3 is defined in Standard ECMA-35.
var LS3_ = Sequence{
	Name: "LS3",
	Desc: "Locking-Shift Three",
	Type: ESC,
	Code: []byte{'o'},
}

// LS3R is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of LS3R is defined in Standard ECMA-35.
var LS3R_ = Sequence{
	Name: "LS3R",
	Desc: "Locking-Shift Three Right",
	Type: ESC,
	Code: []byte{'|'},
}

// MC is used either to initiate a transfer of data from or to an auxiliary
// input/output device or to enable or disable the relay of the received data
// stream to an auxiliary input/output device, depending on the parameter value:
//
// 0 initiate transfer to a primary auxiliary device
//
// 1 initiate transfer from a primary auxiliary device
//
// 2 initiate transfer to a secondary auxiliary device
//
// 3 initiate transfer from a secondary auxiliary device
//
// 4 stop relay to a primary auxiliary device
//
// 5 start relay to a primary auxiliary device
//
// 6 stop relay to a secondary auxiliary device
//
// 7 start relay to a secondary auxiliary device
//
// This control function may not be used to switch on or off an auxiliary
// device.
var MC_ = Sequence{
	Name:     "MC",
	Desc:     "Media Copy",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'i'},
}

// MW is used to set a message waiting indicator in the receiving device. An
// appropriate acknowledgement to the receipt of MW may be given by using
// DEVICE STATUS REPORT (DSR).
var MW_ = Sequence{
	Name: "MW",
	Desc: "Message Waiting",
	Type: ESC,
	Code: []byte{'U'},
}

// NBH is used to indicate a point where a line break shall not occur when text
// is formatted. NBH may occur between two graphic characters either or both of
// which may be SPACE.
var NBH_ = Sequence{
	Name: "NBH",
	Desc: "No Break Here",
	Type: ESC,
	Code: []byte{'C'},
}

// The effect of NEL depends on the setting of the DEVICE COMPONENT SELECT MODE
// (DCSM) and on the parameter value of SELECT IMPLICIT MOVEMENT DIRECTION
// (SIMD).
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION and with a
// parameter value of SIMD equal to 0, NEL causes the active presentation
// position to be moved to the line home position of the following line in the
// presentation component. The line home position is established by the
// parameter value of SET LINE HOME (SLH).
//
// With a parameter value of SIMD equal to 1, NEL causes the active
// presentation position to be moved to the line limit position of the
// following line in the presentation component. The line limit position is
// established by the parameter value of SET LINE LIMIT (SLL).
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA and with a
// parameter value of SIMD equal to 0, NEL causes the active data position to
// be moved to the line home position of the following line in the data
// component. The line home position is established by the parameter value of
// SET LINE HOME (SLH).
//
// With a parameter value of SIMD equal to 1, NEL causes the active data
// position to be moved to the line limit position of the following line in the
// data component. The line limit position is established by the parameter
// value of SET LINE LIMIT (SLL).
var NEL_ = Sequence{
	Name: "NEL",
	Desc: "Next Line",
	Type: ESC,
	Code: []byte{'E'},
}

// NP causes the n-th following page in the presentation component to be
// displayed, where n equals the value of Pn.
//
// The effect of this control function on the active presentation position is
// not defined by this Standard.
var NP_ = Sequence{
	Name:     "NP",
	Desc:     "Next Page",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'U'},
}

// OSC is used as the opening delimiter of a control string for operating
// system use. The command string following may consist of a sequence of bit
// combinations in the range 00/08 to 00/13 and 02/00 to 07/14. The control
// string is closed by the terminating delimiter STRING TERMINATOR (ST). The
// interpretation of the command string depends on the relevant operating
// system.
var OSC_ = Sequence{
	Name: "OSC",
	Desc: "Operating System Command",
	Type: ESC,
	Code: []byte{']'},
}

// PEC is used to establish the spacing and the extent of the graphic
// characters for subsequent text. The spacing is specified in the line as
// multiples of the spacing established by the most recent occurrence of SET
// CHARACTER SPACING (SCS) or of SELECT CHARACTER SPACING (SHS) or of SPACING
// INCREMENT (SPI) in the data stream. The extent of the characters is
// implicitly established by these
//
// control functions. The established spacing and the extent remain in effect
// until the next occurrence of PEC, of SCS, of SHS or of SPI in the data
// stream. The parameter values are
//
// 0 normal (as specified by SCS, SHS or SPI)
//
// 1 expanded (multiplied by a factor not greater than 2)
//
// 2 condensed (multiplied by a factor not less than 0,5)
var PEC_ = Sequence{
	Name:     "PEC",
	Desc:     "Presentation Expand or Contract",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'Z'},
}

// PFS is used to establish the available area for the imaging of pages of text
// based on paper size. The pages are introduced by the subsequent occurrence
// of FORM FEED (FF) in the data stream.
//
// The established image area remains in effect until the next occurrence of
// PFS in the data stream. The parameter values are (see also annex E):
//
// 0 tall basic text communication format
//
// 1 wide basic text communication format
//
// 2 tall basic A4 format
//
// 3 wide basic A4 format
//
// 4 tall North American letter format
//
// 5 wide North American letter format
//
// 6 tall extended A4 format
//
// 7 wide extended A4 format
//
// 8 tall North American legal format
//
// 9 wide North American legal format
//
// 10 A4 short lines format
//
// 11 A4 long lines format
//
// 12 B5 short lines format
//
// 13 B5 long lines format
//
// 14 B4 short lines format
//
// 15 B4 long lines format
//
// The page home position is established by the parameter value of SET PAGE
// HOME (SPH), the page limit position is established by the parameter value of
// SET PAGE LIMIT (SPL).
var PFS_ = Sequence{
	Name:     "PFS",
	Desc:     "Page Format Selection",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'J'},
}

// PLD causes the active presentation position to be moved in the presentation
// component to the corresponding position of an imaginary line with a partial
// offset in the direction of the line progression. This offset should be
// sufficient either to image following characters as subscripts until the
// first following occurrence of PARTIAL LINE BACKWARD (PLU) in the data
// stream, or, if preceding characters were imaged as superscripts, to restore
// imaging of following characters to the active line (the line that contains
// the active presentation position).
//
// Any interactions between PLD and format effectors other than PLU are not
// defined by this Standard.
var PLD_ = Sequence{
	Name: "PLD",
	Desc: "Partial Line Forward",
	Type: ESC,
	Code: []byte{'K'},
}

// PLU causes the active presentation position to be moved in the presentation
// component to the corresponding position of an imaginary line with a partial
// offset in the direction opposite to that of the line progression. This
// offset should be sufficient either to image following characters as
// superscripts until the first following occurrence of PARTIAL LINE FORWARD
// (PLD) in the data stream, or, if preceding characters were imaged as
// subscripts, to restore imaging of following characters to the active line
// (the line that contains the active presentation position).
//
// Any interactions between PLU and format effectors other than PLD are not
// defined by this Standard.
var PLU_ = Sequence{
	Name: "PLU",
	Desc: "Partial Line Backward",
	Type: ESC,
	Code: []byte{'L'},
}

// PM is used as the opening delimiter of a control string for privacy message
// use. The command string following may consist of a sequence of bit
// combinations in the range 00/08 to 00/13 and 02/00 to 07/14. The control
// string is closed by the terminating delimiter STRING TERMINATOR (ST). The
// interpretation of the command string depends on the relevant privacy
// discipline.
var PM_ = Sequence{
	Name: "PM",
	Desc: "Privacy Message",
	Type: ESC,
	Code: []byte{'^'},
}

// PP causes the n-th preceding page in the presentation component to be
// displayed, where n equals the value of Pn. The effect of this control
// function on the active presentation position is not defined by this Standard.
var PP_ = Sequence{
	Name:     "PP",
	Desc:     "Preceding Page",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'V'},
}

// PPA causes the active data position to be moved in the data component to the
// corresponding character position on the n-th page, where n equals the value
// of Pn.
var PPA_ = Sequence{
	Name:     "PPA",
	Desc:     "Page Position Absolute",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{' ', 'P'},
}

// PPB causes the active data position to be moved in the data component to the
// corresponding character position on the n-th preceding page, where n equals
// the value of Pn.
var PPB_ = Sequence{
	Name:     "PPB",
	Desc:     "Page Position Backward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{' ', 'R'},
}

// PPR causes the active data position to be moved in the data component to the
// corresponding character position on the n-th following page, where n equals
// the value of Pn.
var PPR_ = Sequence{
	Name:     "PPR",
	Desc:     "Page Position Forward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{' ', 'Q'},
}

// PTX is used to delimit strings of graphic characters that are communicated
// one after another in the data stream but that are intended to be presented
// in parallel with one another, usually in adjacent lines.
//
// The parameter values are
//
// 0 end of parallel texts
//
// 1 beginning of a string of principal parallel text
//
// 2 beginning of a string of supplementary parallel text
//
// 3 beginning of a string of supplementary Japanese phonetic annotation
//
// 4 beginning of a string of supplementary Chinese phonetic annotation
//
// 5 end of a string of supplementary phonetic annotations
//
// PTX with a parameter value of 1 indicates the beginning of the string of
// principal text intended to be presented in parallel with one or more strings
// of supplementary text.
//
// PTX with a parameter value of 2, 3 or 4 indicates the beginning of a string
// of supplementary text that is intended to be presented in parallel with
// either a string of principal text or the immediately preceding string of
// supplementary text, if any; at the same time it indicates the end of the
// preceding string of principal text or of the immediately preceding string of
// supplementary text, if any. The end of a string of supplementary text is
// indicated by a subsequent occurrence of PTX with a parameter value other
// than 1.
//
// PTX with a parameter value of 0 indicates the end of the strings of text
// intended to be presented in parallel with one another.
//
// NOTE
//
// PTX does not explicitly specify the relative placement of the strings of
// principal and supplementary parallel texts, or the relative sizes of graphic
// characters in the strings of parallel text. A string of supplementary text
// is normally presented in a line adjacent to the line containing the string
// of principal text, or adjacent to the line containing the immediately
// preceding string of supplementary text, if any. The first graphic character
// of the string of principal text and the first graphic character of a string
// of supplementary text are normally presented in the same position of their
// respective lines. However, a string of supplementary text longer (when
// presented) than the associated string of principal text may be centred on
// that string. In the case of long strings of text, such as paragraphs in
// different languages, the strings may be presented in successive lines in
// parallel columns, with their beginnings aligned with one another and the
// shorter of the paragraphs followed by an appropriate amount of "white space".
//
// Japanese phonetic annotation typically consists of a few half-size or
// smaller Kana characters which indicate the pronunciation or interpretation
// of one or more Kanji characters and are presented above those Kanji
// characters if the character path is horizontal, or to the right of them if
// the character path is vertical.
//
// Chinese phonetic annotation typically consists of a few Pinyin characters
// which indicate the pronunciation of one or more Hanzi characters and are
// presented above those Hanzi characters. Alternatively, the Pinyin characters
// may be presented in the same line as the Hanzi characters and following the
// respective Hanzi characters. The Pinyin characters will then be presented
// within enclosing pairs of parentheses.
var PTX_ = Sequence{
	Name:     "PTX",
	Desc:     "Parallel Texts",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'\\'},
}

// PU1 is reserved for a function without standardized meaning for private use
// as required, subject to the prior agreement between the sender and the
// recipient of the data.
var PU1_ = Sequence{
	Name: "PU1",
	Desc: "Private Use One",
	Type: ESC,
	Code: []byte{'Q'},
}

// PU2 is reserved for a function without standardized meaning for private use
// as required, subject to the prior agreement between the sender and the
// recipient of the data.
var PU2_ = Sequence{
	Name: "PU2",
	Desc: "Private Use Two",
	Type: ESC,
	Code: []byte{'R'},
}

// QUAD is used to indicate the end of a string of graphic characters that are
// to be positioned on a single line according to the layout specified by the
// parameter values, see annex C:
//
// 0 flush to line home position margin
//
// 1 flush to line home position margin and fill with leader
//
// 2 centre between line home position and line limit position margins
//
// 3 centre between line home position and line limit position margins and fill
// with leader
//
// 4 flush to line limit position margin
//
// 5 flush to line limit position margin and fill with leader
//
// 6 flush to both margins
//
// The beginning of the string to be positioned is indicated by the preceding
// occurrence in the data stream of either QUAD or one of the following
// formator functions: FORM FEED (FF), CHARACTER AND LINE POSITION (HVP), LINE
// FEED (LF), NEXT LINE (NEL), PAGE POSITION ABSOLUTE (PPA), PAGE POSITION
// BACKWARD (PPB), PAGE POSITION FORWARD (PPR), REVERSE LINE FEED (RI), LINE
// POSITION ABSOLUTE (VPA), LINE POSITION BACKWARD (VPB), LINE POSITION FORWARD
// (VPR), or LINE TABULATION (VT).
//
// The line home position is established by the parameter value of SET LINE
// HOME (SLH). The line limit position is established by the parameter value of
// SET LINE LIMIT (SLL).
var QUAD_ = Sequence{
	Name:     "QUAD",
	Desc:     "Quad",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'H'},
}

// REP is used to indicate that the preceding character in the data stream, if
// it is a graphic character (represented by one or more bit combinations)
// including SPACE, is to be repeated n times, where n equals the value of Pn.
// If the character preceding REP is a control function or part of a control
// function, the effect of REP is not defined by this Standard.
var REP_ = Sequence{
	Name:     "REP",
	Desc:     "Repeat",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'b'},
}

// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to PRESENTATION, RI causes
// the active presentation position to be moved in the presentation component
// to the corresponding character position of the preceding line.
//
// If the DEVICE COMPONENT SELECT MODE (DCSM) is set to DATA, RI causes the
// active data position to be moved in the data component to the corresponding
// character position of the preceding line.
var RI_ = Sequence{
	Name: "RI",
	Desc: "Reverse Line Feed",
	Type: ESC,
	Code: []byte{'M'},
}

// RIS causes a device to be reset to its initial state, i.e. the state it has
// after it is made operational. This may imply, if applicable: clear
// tabulation stops, remove qualified areas, reset graphic rendition, put all
// character positions into the erased state, move the active presentation
// position to the first position of the first line in the presentation
// component, move the active data position to the first character position of
// the first line in the data component, set the modes into the reset state,
// etc.
var RIS_ = Sequence{
	Name: "RIS",
	Desc: "Reset to Initial State",
	Type: ESC,
	Code: []byte{'c'},
}

// RM causes the modes of the receiving device to be reset as specified by the
// parameter values:
//
// 1 GUARDED AREA TRANSFER MODE (GATM)
//
// 2 KEYBOARD ACTION MODE (KAM)
//
// 3 CONTROL REPRESENTATION MODE (CRM)
//
// 4 INSERTION REPLACEMENT MODE (IRM)
//
// 5 STATUS REPORT TRANSFER MODE (SRTM)
//
// 6 ERASURE MODE (ERM)
//
// 7 LINE EDITING MODE (VEM)
//
// 8 BI-DIRECTIONAL SUPPORT MODE (BDSM)
//
// 9 DEVICE COMPONENT SELECT MODE (DCSM)
//
// 10 CHARACTER EDITING MODE (HEM)
//
// 11 POSITIONING UNIT MODE (PUM) (see F.4.1 in annex F)
//
// 12 SEND/RECEIVE MODE (SRM)
//
// 13 FORMAT EFFECTOR ACTION MODE (FEAM)
//
// 14 FORMAT EFFECTOR TRANSFER MODE (FETM)
//
// 15 MULTIPLE AREA TRANSFER MODE (MATM)
//
// 16 TRANSFER TERMINATION MODE (TTM)
//
// 17 SELECTED AREA TRANSFER MODE (SATM)
//
// 18 TABULATION STOP MODE (TSM)
//
// 19 (Shall not be used; see F.5.1 in annex F)
//
// 20 (Shall not be used; see F.5.2 in annex F)
//
// 21 GRAPHIC RENDITION COMBINATION MODE (GRCM)
//
// 22 ZERO DEFAULT MODE (ZDM) (see F.4.2 in annex F)
//
// NOTE
//
// Private modes may be implemented using private parameters, see 5.4.1 and 7.4.
var RM_ = Sequence{
	Name:     "RM",
	Desc:     "Reset Mode",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Code:     []byte{'l'},
}

// SACS is used to establish extra inter-character escapement for subsequent
// text. The established extra escapement remains in effect until the next
// occurrence of SACS or of SET REDUCED CHARACTER SEPARATION (SRCS) in the data
// stream or until it is reset to the default value by a subsequent occurrence
// of CARRIAGE RETURN/LINE FEED (CR LF) or of NEXT LINE (NEL) in the data
// stream, see annex C.
//
// Pn specifies the number of units by which the inter-character escapement is
// enlarged.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var SACS_ = Sequence{
	Name:     "SACS",
	Desc:     "Set Additional Character Separation",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', '\\'},
}

// SAPV is used to specify one or more variants for the presentation of
// subsequent text. The parameter values are
//
// 0 default presentation (implementation-defined); cancels the effect of any
// preceding occurrence of SAPV in the data stream
//
// 1 the decimal digits are presented by means of the graphic symbols used in
// the Latin script
//
// 2 the decimal digits are presented by means of the graphic symbols used in
// the Arabic script, i.e. the Hindi symbols
//
// 3 when the direction of the character path is right-to-left, each of the
// graphic characters in the graphic character set(s) in use which is one of a
// left/right-handed pair (parentheses, square brackets, curly brackets,
// greater-than/less-than signs, etc.) is presented as "mirrored", i.e. as the
// other member of the pair. For example, the coded graphic character given the
// name LEFT PARENTHESIS is presented as RIGHT PARENTHESIS, and vice versa
//
// 4 when the direction of the character path is right-to-left, all graphic
// characters which represent operators and delimiters in mathematical formulae
// and which are not symmetrical about a vertical axis are presented as
// mirrored about that vertical axis
//
// 5 the following graphic character is presented in its isolated form
//
// 6 the following graphic character is presented in its initial form
//
// 7 the following graphic character is presented in its medial form
//
// 8 the following graphic character is presented in its final form
//
// 9 where the bit combination 02/14 is intended to represent a decimal mark in
// a decimal number it shall be presented by means of the graphic symbol FULL
// STOP
//
// 10 where the bit combination 02/14 is intended to represent a decimal mark
// in a decimal number it shall be presented by means of the graphic symbol
// COMMA
//
// 11 vowels are presented above or below the preceding character
//
// 12 vowels are presented after the preceding character
//
// 13 contextual shape determination of Arabic scripts, including the LAM-ALEPH
// ligature but excluding all other Arabic ligatures
//
// 14 contextual shape determination of Arabic scripts, excluding all Arabic
// ligatures
//
// 15 cancels the effect of parameter values 3 and 4
//
// 16 vowels are not presented
//
// 17 when the string direction is right-to-left, the italicized characters are
// slanted to the left; when the string direction is left-to-right, the
// italicized characters are slanted to the right
//
// 18 contextual shape determination of Arabic scripts is not used, the graphic
// characters - including the digits - are presented in the form they are
// stored (Pass-through)
//
// 19 contextual shape determination of Arabic scripts is not used, the graphic
// characters- excluding the digits - are presented in the form they are stored
// (Pass-through)
//
// 20 the graphic symbols used to present the decimal digits are device
// dependent
//
// 21 establishes the effect of parameter values 5, 6, 7, and 8 for the
// following graphic characters until cancelled
//
// 22 cancels the effect of parameter value 21, i.e. re-establishes the effect
// of parameter values 5, 6, 7, and 8 for the next single graphic character
// only.
var SAPV_ = Sequence{
	Name:     "SAPV",
	Desc:     "Select Alternative Presentation Variants",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{' ', ']'},
}

// SCI and the bit combination following it are used to represent a control
// function or a graphic character. The bit combination following SCI must be
// from 00/08 to 00/13 or 02/00 to 07/14. The use of SCI is reserved for future
// standardization.
var SCI_ = Sequence{
	Name: "SCI",
	Desc: "Single Character Introducer",
	Type: ESC,
	Code: []byte{'Z'},
}

// SCO is used to establish the amount of rotation of the graphic characters
// following in the data stream. The established value remains in effect until
// the next occurrence of SCO in the data stream.
//
// The parameter values are 0 0°
//
// 1 45°
//
// 2 90°
//
// 3 135° 4 180° 5 225° 6 270° 7 315°
//
// is positive, i.e. counter-clockwise and applies to the normal presentation
// of the graphic
//
// Rotation
//
// characters along the character path. The centre of rotation of the affected
// graphic characters is not defined by this Standard.
var SCO_ = Sequence{
	Name:     "SCO",
	Desc:     "Select Character Orientation",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'e'},
}

// SCP is used to select the character path, relative to the line orientation,
// for the active line (the line that contains the active presentation
// position) and subsequent lines in the presentation component. It is also
// used to update the content of the active line in the presentation component
// and the content of the active line (the line that contains the active data
// position) in the data component. This takes effect immediately.
//
// Ps1 specifies the character path:
//
// 1 left-to-right (in the case of horizontal line orientation), or
// top-to-bottom (in the case of vertical line orientation)
//
// 2 right-to-left (in the case of horizontal line orientation), or
// bottom-to-top (in the case of vertical line orientation)
//
// Ps2 specifies the effect on the content of the presentation component and
// the content of the data component:
//
// 0 undefined (implementation-dependent)
//
// NOTE
//
// This may also permit the effect to take place after the next occurrence of
// CR, NEL or any control function which initiates an absolute movement of the
// active presentation position or the active data position.
//
// 1 the content of the active line in the presentation component (the line
// that contains the active presentation position) is updated to correspond to
// the content of the active line in the data component (the line that contains
// the active data position) according to the newly established character path
// characteristics in the presentation component; the active data position is
// moved to the first character position in the active line in the data
// component, the active presentation position in the presentation component is
// updated accordingly
//
// 2 the content of the active line in the data component (the line that
// contains the active data position) is updated to correspond to the content
// of the active line in the presentation component (the line that contains the
// active presentation position) according to the newly established character
// path characteristics of the presentation component; the active presentation
// position is moved to the first character position in the active line in the
// presentation component, the active data position in the data component is
// updated accordingly.
var SCP_ = Sequence{
	Name:     "SCP",
	Desc:     "Select Character Path",
	Type:     CSI,
	Notation: "Ps1;Ps2",
	NParam:   2,
	MinParam: 2,
	Code:     []byte{' ', 'k'},
}

// SCS is used to establish the character spacing for subsequent text. The
// established spacing remains in effect until the next occurrence of SCS, or
// of SELECT CHARACTER SPACING (SHS) or of SPACING INCREMENT (SPI) in the data
// stream, see annex C.
//
// Pn specifies the character spacing.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var SCS_ = Sequence{
	Name:     "SCS",
	Desc:     "Set Character Spacing",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'g'},
}

// SD causes the data in the presentation component to be moved by n line
// positions if the line orientation is horizontal, or by n character positions
// if the line orientation is vertical, such that the data appear to move down;
// where n equals the value of Pn.
//
// The active presentation position is not affected by this control function.
var SD_ = Sequence{
	Name:     "SD",
	Desc:     "Scroll Down",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'T'},
}

// SDS is used to establish in the data component the beginning and the end of
// a string of characters as well as the direction of the string. This
// direction may be different from that currently established. The indicated
// string follows the preceding text. The established character progression is
// not affected.
//
// The beginning of a directed string is indicated by SDS with a parameter
// value not equal to 0. A directed string may contain one or more nested
// strings. These nested strings may be directed strings the beginnings of
// which are indicated by SDS with a parameter value not equal to 0, or
// reversed strings the beginnings of which are indicated by START REVERSED
// STRING (SRS) with a parameter value of 1. Every beginning of such a string
// invokes the next deeper level of nesting.
//
// This Standard does not define the location of the active data position
// within any such nested string.
//
// The end of a directed string is indicated by SDS with a parameter value of
// 0. Every end of such a string re-establishes the next higher level of
// nesting (the one in effect prior to the string just ended). The direction is
// re-established to that in effect prior to the string just ended. The active
// data position is moved to the character position following the characters of
// the string just ended.
//
// The parameter values are:
//
// 0 end of a directed string; re-establish the previous direction
//
// 1 start of a directed string; establish the direction left-to-right
//
// 2 start of a directed string; establish the direction right-to-left
//
// NOTE 1
//
// The effect of receiving a CVT, HT, SCP, SPD or VT control function within an
// SDS string is not defined by this Standard.
//
// NOTE 2
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SDS string.
var SDS_ = Sequence{
	Name:     "SDS",
	Desc:     "Start Directed String",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{']'},
}

// SEE is used to establish the editing extent for subsequent character or line
// insertion or deletion. The established extent remains in effect until the
// next occurrence of SEE in the data stream. The editing extent depends on the
// parameter value:
//
// 0 the shifted part is limited to the active page in the presentation
// component
//
// 1 the shifted part is limited to the active line in the presentation
// component
//
// 2 the shifted part is limited to the active field in the presentation
// component
//
// 3 the shifted part is limited to the active qualified area
//
// 4 the shifted part consists of the relevant part of the entire presentation
// component.
var SEE_ = Sequence{
	Name:     "SEE",
	Desc:     "Select Editing Extent",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'Q'},
}

// SEF causes a sheet of paper to be ejected from a printing device into a
// specified output stacker and another sheet to be loaded into the printing
// device from a specified paper bin.
//
// Parameter values of Ps1 are:
//
// 0 eject sheet, no new sheet loaded
//
// 1 eject sheet and load another from bin 1
//
// 2 eject sheet and load another from bin 2
//
// . . .
//
// n eject sheet and load another from bin n Parameter values of Ps2 are:
//
// 0 eject sheet, no stacker specified
//
// 1 eject sheet into stacker 1
//
// 2 eject sheet into stacker 2
//
// . . .
//
// n eject sheet into stacker n
var SEF_ = Sequence{
	Name:     "SEF",
	Desc:     "Sheet Eject and Feed",
	Type:     CSI,
	Notation: "Ps1;Ps2",
	NParam:   2,
	Defaults: []string{"0", "0"},
	Code:     []byte{' ', 'Y'},
}

// SGR is used to establish one or more graphic rendition aspects for
// subsequent text. The established aspects remain in effect until the next
// occurrence of SGR in the data stream, depending on the setting of the
// GRAPHIC RENDITION COMBINATION MODE (GRCM). Each graphic rendition aspect is
// specified by a parameter value:
//
// 0 default rendition (implementation-defined), cancels the effect of any
// preceding occurrence of SGR in the data stream regardless of the setting of
// the GRAPHIC RENDITION COMBINATION MODE (GRCM)
//
// 1 bold or increased intensity
//
// 2 faint, decreased intensity or second colour
//
// 3 italicized
//
// 4 singly underlined
//
// 5 slowly blinking (less then 150 per minute)
//
// 6 rapidly blinking (150 per minute or more)
//
// 7 negative image
//
// 8 concealed characters
//
// 9 crossed-out (characters still legible but marked as to be deleted)
//
// 10 primary (default) font
//
// 11 first alternative font
//
// 12 second alternative font
//
// 13 third alternative font
//
// 14 fourth alternative font
//
// 15 fifth alternative font
//
// 16 sixth alternative font
//
// 17 seventh alternative font
//
// 18 eighth alternative font
//
// 19 ninth alternative font
//
// 20 Fraktur (Gothic)
//
// 21 doubly underlined
//
// 22 normal colour or normal intensity (neither bold nor faint)
//
// 23 not italicized, not fraktur
//
// 24 not underlined (neither singly nor doubly)
//
// 25 steady (not blinking)
//
// 26 (reserved for proportional spacing as specified in CCITT Recommendation
// T.61)
//
// 27 positive image
//
// 28 revealed characters
//
// 29 not crossed out 30 black display 31 red display
//
// 32 green display 33 yellow display 34 blue display
//
// 35 magenta display
//
// 36 cyan display
//
// 37 white display
//
// 38 (reserved for future standardization; intended for setting character
// foreground colour as specified in ISO 8613-6 [CCITT Recommendation T.416])
//
// 39 default display colour (implementation-defined) 40 black background
//
// 41 red background
//
// 42 green background
//
// 43 yellow background 44 blue background
//
// 45 magenta background 46 cyan background
//
// 47 white background
//
// 48 (reserved for future standardization; intended for setting character
// background colour as specified in ISO 8613-6 [CCITT Recommendation T.416])
//
// 49 default background colour (implementation-defined)
//
// 50 (reserved for cancelling the effect of the rendering aspect established
// by parameter value 26) 51 framed
//
// 52 encircled
//
// 53 overlined
//
// 54 not framed, not encircled
//
// 55 not overlined
//
// 56 (reserved for future standardization)
//
// 57 (reserved for future standardization)
//
// 58 (reserved for future standardization)
//
// 59 (reserved for future standardization)
//
// 60 ideogram underline or right side line
//
// 61 ideogram double underline or double line on the right side
//
// 62 ideogram overline or left side line
//
// 63 ideogram double overline or double line on the left side
//
// 64 ideogram stress marking
//
// 65 cancels the effect of the rendition aspects established by parameter
// values 60 to 64
//
// 0 1 2 3 4 5 6
//
// 10 characters per 25,4 mm 12 characters per 25,4 mm 15 characters per 25,4 mm
//
// 6 characters per 25,4 mm 3 characters per 25,4 mm 9 characters per 50,8 mm 4
// characters per 25,4 mm
//
// NOTE
//
// The usable combinations of parameter values are determined by the
// implementation.
var SGR_ = Sequence{
	Name:     "SGR",
	Desc:     "Select Graphic Rendition",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Defaults: []string{"0"},
	Code:     []byte{'m'},
}

// SHS is used to establish the character spacing for subsequent text. The
// established spacing remains in effect until the next occurrence of SHS or of
// SET CHARACTER SPACING (SCS) or of SPACING INCREMENT (SPI) in the data
// stream. The parameter values are
var SHS_ = Sequence{
	Name:     "SHS",
	Desc:     "Select Character Spacing",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'K'},
}

// SIMD is used to select the direction of implicit movement of the data
// position relative to the character progression. The direction selected
// remains in effect until the next occurrence of SIMD.
//
// The parameter values are:
//
// 0 the direction of implicit movement is the same as that of the character
// progression
//
// 1 the direction of implicit movement is opposite to that of the character
// progression.
var SIMD_ = Sequence{
	Name:     "SIMD",
	Desc:     "Select Implicit Movement Direction",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'^'},
}

// SL causes the data in the presentation component to be moved by n character
// positions if the line orientation is horizontal, or by n line positions if
// the line orientation is vertical, such that the data appear to move to the
// left; where n equals the value of Pn.
//
// The active presentation position is not affected by this control function.
var SL_ = Sequence{
	Name:     "SL",
	Desc:     "Scroll Left",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{' ', '@'},
}

// If the DEVICE COMPONENT SELECT MODE is set to PRESENTATION, SLH is used to
// establish at character position n in the active line (the line that contains
// the active presentation position) and lines of subsequent text in the
// presentation component the position to which the active presentation
// position will be moved by subsequent occurrences of CARRIAGE RETURN (CR),
// DELETE LINE (DL), INSERT LINE (IL) or NEXT LINE (NEL) in the data stream;
// where n equals the value of Pn. In the case of a device without data
// component, it is also the position ahead of which no implicit movement of
// the active presentation position shall occur.
//
// If the DEVICE COMPONENT SELECT MODE is set to DATA, SLH is used to establish
// at character position n in the active line (the line that contains the
// active data position) and lines of subsequent text in the data component the
// position to which the active data position will be moved by subsequent
// occurrences of CARRIAGE RETURN (CR), DELETE LINE (DL), INSERT LINE (IL) or
// NEXT LINE (NEL) in the data stream; where n equals the value of Pn. It is
// also the position ahead of which no implicit movement of the active data
// position shall occur.
//
// The established position is called the line home position and remains in
// effect until the next occurrence of SLH in the data stream.
var SLH_ = Sequence{
	Name:     "SLH",
	Desc:     "Set Line Home",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'U'},
}

// If the DEVICE COMPONENT SELECT MODE is set to PRESENTATION, SLL is used to
// establish at character position n in the active line (the line that contains
// the active presentation position) and lines of subsequent text in the
// presentation component the position to which the active presentation
// position will be moved by subsequent occurrences of CARRIAGE RETURN (CR), or
// NEXT LINE (NEL) in the data stream if the parameter value of SELECT IMPLICIT
// MOVEMENT DIRECTION (SIMD) is equal to 1; where n equals the value of Pn. In
// the case of a device without data component, it is also the position beyond
// which no implicit movement of the active presentation position shall occur.
//
// If the DEVICE COMPONENT SELECT MODE is set to DATA, SLL is used to establish
// at character position n in the active line (the line that contains the
// active data position) and lines of subsequent text in the data component the
// position beyond which no implicit movement of the active data position shall
// occur. It is also the position in the data component to which the active
// data position will be moved by subsequent occurrences of CR or NEL in the
// data stream, if the parameter value of SELECT IMPLICIT MOVEMENT DIRECTION
// (SIMD) is equal to 1.
//
// The established position is called the line limit position and remains in
// effect until the next occurrence of SLL in the data stream.
var SLL_ = Sequence{
	Name:     "SLL",
	Desc:     "Set Line Limit",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'V'},
}

// SLS is used to establish the line spacing for subsequent text. The
// established spacing remains in effect until the next occurrence of SLS or of
// SELECT LINE SPACING (SVS) or of SPACING INCREMENT (SPI) in the data stream.
//
// Pn specifies the line spacing.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var SLS_ = Sequence{
	Name:     "SLS",
	Desc:     "Set Line Spacing",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'h'},
}

// SM causes the modes of the receiving device to be set as specified by the
// parameter values:
//
// 1 GUARDED AREA TRANSFER MODE (GATM)
//
// 2 KEYBOARD ACTION MODE (KAM)
//
// 3 CONTROL REPRESENTATION MODE (CRM)
//
// 4 INSERTION REPLACEMENT MODE (IRM)
//
// 5 STATUS REPORT TRANSFER MODE (SRTM)
//
// 6 ERASURE MODE (ERM)
//
// 7 LINE EDITING MODE (VEM)
//
// 8 BI-DIRECTIONAL SUPPORT MODE (BDSM)
//
// 9 DEVICE COMPONENT SELECT MODE (DCSM)
//
// 10 CHARACTER EDITING MODE (HEM)
//
// 11 POSITIONING UNIT MODE (PUM) (see F.4.1 in annex F)
//
// 12 SEND/RECEIVE MODE (SRM)
//
// 13 FORMAT EFFECTOR ACTION MODE (FEAM)
//
// 14 FORMAT EFFECTOR TRANSFER MODE (FETM)
//
// 15 MULTIPLE AREA TRANSFER MODE (MATM)
//
// 16 TRANSFER TERMINATION MODE (TTM)
//
// 17 SELECTED AREA TRANSFER MODE (SATM)
//
// 18 TABULATION STOP MODE (TSM)
//
// 19 (Shall not be used; see F.5.1 in annex F)
//
// 20 (Shall not be used; see F.5.2 in annex F)
//
// 21 GRAPHIC RENDITION COMBINATION (GRCM)
//
// 22 ZERO DEFAULT MODE (ZDM) (see F.4.2 in annex F)
//
// NOTE
//
// Private modes may be implemented using private parameters, see 5.4.1 and 7.4.
var SM_ = Sequence{
	Name:     "SM",
	Desc:     "Set Mode",
	Type:     CSI,
	Notation: "Ps...",
	NParam:   -1,
	Code:     []byte{'h'},
}

// SOS is used as the opening delimiter of a control string. The character
// string following may consist of any bit combination, except those
// representing SOS or STRING TERMINATOR (ST). The control string is closed by
// the terminating delimiter STRING TERMINATOR (ST). The interpretation of the
// character string depends on the application.
var SOS_ = Sequence{
	Name: "SOS",
	Desc: "Start of String",
	Type: ESC,
	Code: []byte{'X'},
}

// SPA is used to indicate that the active presentation position is the first
// of a string of character positions in the presentation component, the
// contents of which are protected against manual alteration, are guarded
// against transmission or transfer, depending on the setting of the GUARDED
// AREA TRANSFER MODE (GATM) and may be protected against erasure, depending on
// the setting of the ERASURE MODE (ERM). The end of this string is indicated
// by END OF GUARDED AREA (EPA).
//
// NOTE
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string or an SDS string.
var SPA_ = Sequence{
	Name: "SPA",
	Desc: "Start of Guarded Area",
	Type: ESC,
	Code: []byte{'V'},
}

// SPD is used to select the line orientation, the line progression, and the
// character path in the presentation component. It is also used to update the
// content of the presentation component and the content of the data component.
// This takes effect immediately.
//
// Ps1 specifies the line orientation, the line progression and the character
// path:
//
// 0 line orientation: line progression: character path:
//
// 1 line orientation: line progression: character path:
//
// 2 line orientation: line progression: character path:
//
// 3 line orientation: line progression: character path:
//
// 4 line orientation: line progression: character path:
//
// 5 line orientation: line progression: character path:
//
// horizontal top-to-bottom left-to-right
//
// vertical right-to-left top-to-bottom
//
// vertical left-to-right top-to-bottom
//
// horizontal top-to-bottom right-to-left
//
// vertical left-to-right bottom-to-top
//
// horizontal bottom-to-top right-to-left
//
// 6 line orientation: line progression: character path:
//
// 7 line orientation: line progression: character path:
//
// horizontal bottom-to-top left-to-right
//
// vertical right-to-left bottom-to-top
//
// Ps2 specifies the effect on the content of the presentation component and
// the content of the data component:
//
// 0 undefined (implementation-dependent)
//
// NOTE
//
// This may also permit the effect to take place after the next occurrence of
// CR, FF or any control function which initiates an absolute movement of the
// active presentation position or the active data position.
//
// 1 the content of the presentation component is updated to correspond to the
// content of the data component according to the newly established
// characteristics of the presentation component; the active data position is
// moved to the first character position in the first line in the data
// component, the active presentation position in the presentation component is
// updated accordingly
//
// 2 the content of the data component is updated to correspond to the content
// of the presentation component according to the newly established
// characteristics of the presentation component; the active presentation
// position is moved to the first character position in the first line in the
// presentation component, the active data position in the data component is
// updated accordingly.
var SPD_ = Sequence{
	Name:     "SPD",
	Desc:     "Select Presentation Directions",
	Type:     CSI,
	Notation: "Ps1;Ps2",
	NParam:   2,
	Defaults: []string{"0", "0"},
	Code:     []byte{' ', 'S'},
}

// If the DEVICE COMPONENT SELECT MODE is set to PRESENTATION, SPH is used to
// establish at line position n in the active page (the page that contains the
// active presentation position) and subsequent pages in the presentation
// component the position to which the active presentation position will be
// moved by subsequent occurrences of FORM FEED (FF) in the data stream; where
// n equals the value of Pn. In the case of a device without data component, it
// is also the position ahead of which no implicit movement of the active
// presentation position shall occur.
//
// If the DEVICE COMPONENT SELECT MODE is set to DATA, SPH is used to establish
// at line position n in the active page (the page that contains the active
// data position) and subsequent pages in the data component the position to
// which the active data position will be moved by subsequent occurrences of
// FORM FEED (FF) in the data stream; where n equals the value of Pn. It is
// also the position ahead of which no implicit movement of the active
// presentation position shall occur.
//
// The established position is called the page home position and remains in
// effect until the next occurrence of SPH in the data stream.
var SPH_ = Sequence{
	Name:     "SPH",
	Desc:     "Set Page Home",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'i'},
}

// SPI is used to establish the line spacing and the character spacing for
// subsequent text. The established line spacing remains in effect until the
// next occurrence of SPI or of SET LINE SPACING (SLS) or of SELECT LINE
// SPACING (SVS) in the data stream. The established character spacing remains
// in effect until the next occurrence of SET CHARACTER SPACING (SCS) or of
// SELECT CHARACTER SPACING (SHS) in the data stream, see annex C.
//
// Pn1 specifies the line spacing
//
// Pn2 specifies the character spacing
//
// The unit in which the parameter values are expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var SPI_ = Sequence{
	Name:     "SPI",
	Desc:     "Spacing Increment",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	MinParam: 2,
	Code:     []byte{' ', 'G'},
}

// If the DEVICE COMPONENT SELECT MODE is set to PRESENTATION, SPL is used to
// establish at line position n in the active page (the page that contains the
// active presentation position) and pages of subsequent text in the
// presentation component the position beyond which the active presentation
// position can normally not be moved; where n equals the value of Pn. In the
// case of a device without data component, it is also the position beyond
// which no implicit movement of the active presentation position shall occur.
//
// If the DEVICE COMPONENT SELECT MODE is set to DATA, SPL is used to establish
// at line position n in the active page (the page that contains the active
// data position) and pages of subsequent text in the data component the
// position beyond which no implicit movement of the active data position shall
// occur.
//
// The established position is called the page limit position and remains in
// effect until the next occurrence of SPL in the data stream.
var SPL_ = Sequence{
	Name:     "SPL",
	Desc:     "Set Page Limit",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'j'},
}

// SPQR is used to select the relative print quality and the print speed for
// devices the output quality and speed of which are inversely related. The
// selected values remain in effect until the next occurrence of SPQR in the
// data stream. The parameter values are
//
// 0 highest available print quality, low print speed
//
// 1 medium print quality, medium print speed
//
// 2 draft print quality, highest available print speed
var SPQR_ = Sequence{
	Name:     "SPQR",
	Desc:     "Select Print Quality and Rapidity",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'X'},
}

// SR causes the data in the presentation component to be moved by n character
// positions if the line orientation is horizontal, or by n line positions if
// the line orientation is vertical, such that the data appear to move to the
// right; where n equals the value of Pn.
//
// The active presentation position is not affected by this control function.
var SR_ = Sequence{
	Name:     "SR",
	Desc:     "Scroll Right",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{' ', 'A'},
}

// SRCS is used to establish reduced inter-character escapement for subsequent
// text. The established reduced escapement remains in effect until the next
// occurrence of SRCS or of SET ADDITIONAL CHARACTER SEPARATION (SACS) in the
// data stream or until it is reset to the default value by a subsequent
// occurrence of CARRIAGE RETURN/LINE FEED (CR/LF) or of NEXT LINE (NEL) in the
// data stream, see annex C.
//
// Pn specifies the number of units by which the inter-character escapement is
// reduced.
//
// The unit in which the parameter values are expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var SRCS_ = Sequence{
	Name:     "SRCS",
	Desc:     "Set Reduced Character Separation",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'f'},
}

// SRS is used to establish in the data component the beginning and the end of
// a string of characters as well as the direction of the string. This
// direction is opposite to that currently established. The indicated string
// follows the preceding text. The established character progression is not
// affected.
//
// The beginning of a reversed string is indicated by SRS with a parameter
// value of 1. A reversed string may contain one or more nested strings. These
// nested strings may be reversed strings the beginnings of which are indicated
// by SRS with a parameter value of 1, or directed strings the beginnings of
// which are indicated by START DIRECTED STRING (SDS) with a parameter value
// not equal to 0. Every beginning of such a string invokes the next deeper
// level of nesting.
//
// This Standard does not define the location of the active data position
// within any such nested string.
//
// The end of a reversed string is indicated by SRS with a parameter value of
// 0. Every end of such a string re-establishes the next higher level of
// nesting (the one in effect prior to the string just ended). The direction is
// re-established to that in effect prior to the string just ended. The active
// data position is moved to the character position following the characters of
// the string just ended.
//
// The parameter values are:
//
// 0 end of a reversed string; re-establish the previous direction
//
// 1 beginning of a reversed string; reverse the direction.
//
// NOTE 1
//
// The effect of receiving a CVT, HT, SCP, SPD or VT control function within an
// SRS string is not defined by this Standard.
//
// NOTE 2
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string.
var SRS_ = Sequence{
	Name:     "SRS",
	Desc:     "Start Reversed String",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'['},
}

// SSA is used to indicate that the active presentation position is the first
// of a string of character positions in the presentation component, the
// contents of which are eligible to be transmitted in the form of a data
// stream or transferred to an auxiliary input/output device.
//
// The end of this string is indicated by END OF SELECTED AREA (ESA). The
// string of characters actually transmitted or transferred depends on the
// setting of the GUARDED AREA TRANSFER MODE (GATM) and on any guarded areas
// established by DEFINE AREA QUALIFICATION (DAQ), or by START OF GUARDED AREA
// (SPA) and END OF GUARDED AREA (EPA).
//
// NOTE
//
// The control functions for area definition (DAQ, EPA, ESA, SPA, SSA) should
// not be used within an SRS string or an SDS string.
var SSA_ = Sequence{
	Name: "SSA",
	Desc: "Start of Selected Area",
	Type: ESC,
	Code: []byte{'F'},
}

// SSU is used to establish the unit in which the numeric parameters of certain
// control functions are expressed. The established unit remains in effect
// until the next occurrence of SSU in the data stream.
//
// The parameter values are
//
// 0 CHARACTER - The dimensions of this unit are device-dependent
//
// 1 MILLIMETRE
//
// 2 COMPUTER DECIPOINT - 0,035 28 mm (1/720 of 25,4 mm)
//
// 3 DECIDIDOT - 0,037 59 mm (10/266 mm)
//
// 4 MIL-0,0254mm(1/1000of25,4mm)
//
// 5 BASIC MEASURING UNIT (BMU) - 0,021 17 mm (1/1 200 of 25,4 mm)
//
// 6 MICROMETRE - 0,001 mm
//
// 7 PIXEL - The smallest increment that can be specified in a device
//
// 8 DECIPOINT - 0,035 14 mm (35/996 mm)
var SSU_ = Sequence{
	Name:     "SSU",
	Desc:     "Select Size Unit",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'I'},
}

// SSW is used to establish for subsequent text the character escapement
// associated with the character SPACE. The established escapement remains in
// effect until the next occurrence of SSW in the data stream or until it is
// reset to the default value by a subsequent occurrence of CARRIAGE
// RETURN/LINE FEED (CR/LF), CARRIAGE RETURN/FORM FEED (CR/FF), or of NEXT LINE
// (NEL) in the data stream, see annex C.
//
// Pn specifies the escapement.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
//
// The default character escapement of SPACE is specified by the most recent
// occurrence of SET CHARACTER SPACING (SCS) or of SELECT CHARACTER SPACING
// (SHS) or of SELECT SPACING INCREMENT (SPI) in the data stream if the current
// font has constant spacing, or is specified by the nominal width of the
// character SPACE in the current font if that font has proportional spacing.
var SSW_ = Sequence{
	Name:     "SSW",
	Desc:     "Set Space Width",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', '['},
}

// SS2 is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of SS2 is defined in Standard ECMA-35.
var SS2_ = Sequence{
	Name: "SS2",
	Desc: "Single-Shift Two",
	Type: ESC,
	Code: []byte{'N'},
}

// SS3 is used for code extension purposes. It causes the meanings of the bit
// combinations following it in the data stream to be changed.
//
// The use of SS3 is defined in Standard ECMA-35.
var SS3_ = Sequence{
	Name: "SS3",
	Desc: "Single-Shift Three",
	Type: ESC,
	Code: []byte{'O'},
}

// ST is used as the closing delimiter of a control string opened by
// APPLICATION PROGRAM COMMAND (APC), DEVICE CONTROL STRING (DCS), OPERATING
// SYSTEM COMMAND (OSC), PRIVACY MESSAGE (PM), or START OF STRING (SOS).
var ST_ = Sequence{
	Name: "ST",
	Desc: "String Terminator",
	Type: ESC,
	Code: []byte{'\\'},
}

// STAB causes subsequent text in the presentation component to be aligned
// according to the position and the properties of a tabulation stop which is
// selected from a list according to the value of the parameter Ps.
//
// The use of this control function and means of specifying a list of
// tabulation stops to be referenced by the control function are specified in
// other standards, for example ISO 8613-6.
var STAB_ = Sequence{
	Name:     "STAB",
	Desc:     "Selective Tabulation",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', '^'},
}

// STS is used to establish the transmit state in the receiving device. In this
// state the transmission of data from the device is possible.
//
// The actual initiation of transmission of data is performed by a data
// communication or input/output interface control procedure which is outside
// the scope of this Standard.
//
// The transmit state is established either by STS appearing in the received
// data stream or by the operation of an appropriate key on a keyboard.
var STS_ = Sequence{
	Name: "STS",
	Desc: "Set Transmit State",
	Type: ESC,
	Code: []byte{'S'},
}

// SU causes the data in the presentation component to be moved by n line
// positions if the line orientation is horizontal, or by n character positions
// if the line orientation is vertical, such that the data appear to move up;
// where n equals the value of Pn.
//
// The active presentation position is not affected by this control function.
var SU_ = Sequence{
	Name:     "SU",
	Desc:     "Scroll Up",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'S'},
}

// SVS is used to establish the line spacing for subsequent text. The
// established spacing remains in effect until the next occurrence of SVS or of
// SET LINE SPACING (SLS) or of SPACING INCREMENT (SPI) in the data stream. The
// parameter values are:
//
// 0 6 lines per 25,4 mm
//
// 1 4 lines per 25,4 mm
//
// 2 3 lines per 25,4 mm
//
// 3 12 lines per 25,4 mm
//
// 4 8 lines per 25,4 mm
//
// 5 6 lines per 30,0 mm
//
// 6 4 lines per 30,0 mm
//
// 7 3 lines per 30,0 mm
//
// 8 12 lines per 30,0 mm
//
// 9 2 lines per 25,4 mm
var SVS_ = Sequence{
	Name:     "SVS",
	Desc:     "Select Line Spacing",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{' ', 'L'},
}

// TAC causes a character tabulation stop calling for centring to be set at
// character position n in the active line (the line that contains the active
// presentation position) and lines of subsequent text in the presentation
// component, where n equals the value of Pn. TAC causes the replacement of any
// tabulation stop previously set at that character position, but does not
// affect other tabulation stops.
//
// A text string centred upon a tabulation stop set by TAC will be positioned
// so that the (trailing edge of the) first graphic character and the (leading
// edge of the) last graphic character are at approximately equal distances
// from the tabulation stop.
var TAC_ = Sequence{
	Name:     "TAC",
	Desc:     "Tabulation Aligned Centred",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'b'},
}

// TALE causes a character tabulation stop calling for leading edge alignment
// to be set at character position n in the active line (the line that contains
// the active presentation position) and lines of subsequent text in the
// presentation component, where n equals the value of Pn. TALE causes the
// replacement of any tabulation stop previously set at that character
// position, but does not affect other tabulation stops.
//
// A text string aligned with a tabulation stop set by TALE will be positioned
// so that the (leading edge of the) last graphic character of the string is
// placed at the tabulation stop.
var TALE_ = Sequence{
	Name:     "TALE",
	Desc:     "Tabulation Aligned Leading Edge",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'a'},
}

// TATE causes a character tabulation stop calling for trailing edge alignment
// to be set at character position n in the active line (the line that contains
// the active presentation position) and lines of subsequent text in the
// presentation component, where n equals the value of Pn. TATE causes the
// replacement of any tabulation stop previously set at that character
// position, but does not affect other tabulation stops.
//
// A text string aligned with a tabulation stop set by TATE will be positioned
// so that the (trailing edge of the) first graphic character of the string is
// placed at the tabulation stop.
var TATE_ = Sequence{
	Name:     "TATE",
	Desc:     "Tabulation Aligned Trailing Edge",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', '`'},
}

// TBC causes one or more tabulation stops in the presentation component to be
// cleared, depending on the parameter value:
//
// 0 the character tabulation stop at the active presentation position is
// cleared
//
// 1 the line tabulation stop at the active line is cleared
//
// 2 all character tabulation stops in the active line are cleared
//
// 3 all character tabulation stops are cleared
//
// 4 all line tabulation stops are cleared
//
// 5 all tabulation stops are cleared
//
// In the case of parameter value 0 or 2 the number of lines affected depends
// on the setting of the TABULATION STOP MODE (TSM)
var TBC_ = Sequence{
	Name:     "TBC",
	Desc:     "Tabulation Clear",
	Type:     CSI,
	Notation: "Ps",
	NParam:   1,
	Defaults: []string{"0"},
	Code:     []byte{'g'},
}

// TCC causes a character tabulation stop calling for alignment of a target
// graphic character to be set at character position n in the active line (the
// line that contains the active presentation position) and lines of subsequent
// text in the presentation component, where n equals the value of Pn1, and the
// target character about which centring is to be performed is specified by
// Pn2. TCC causes the replacement of any tabulation stop previously set at
// that character position, but does not affect other tabulation stops.
//
// The positioning of a text string aligned with a tabulation stop set by TCC
// will be determined by the first occurrence in the string of the target
// graphic character; that character will be centred upon the tabulation stop.
// If the target character does not occur within the string, then the trailing
// edge of the first character of the string will be positioned at the
// tabulation stop.
//
// The value of Pn2 indicates the code table position (binary value) of the
// target character in the currently invoked code. For a 7-bit code, the
// permissible range of values is 32 to 127; for an 8-bit code, the permissible
// range of values is 32 to 127 and 160 to 255.
var TCC_ = Sequence{
	Name:     "TCC",
	Desc:     "Tabulation Centred on Character",
	Type:     CSI,
	Notation: "Pn1;Pn2",
	NParam:   2,
	MinParam: 1,
	Defaults: []string{"", "32"},
	Code:     []byte{' ', 'c'},
}

// TSR causes any character tabulation stop at character position n in the
// active line (the line that contains the active presentation position) and
// lines of subsequent text in the presentation component to be cleared, but
// does not affect other tabulation stops. n equals the value of Pn.
var TSR_ = Sequence{
	Name:     "TSR",
	Desc:     "Tabulation Stop Remove",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'd'},
}

// TSS is used to establish the width of a thin space for subsequent text. The
// established width remains in effect until the next occurrence of TSS in the
// data stream, see annex C.
//
// Pn specifies the width of the thin space.
//
// The unit in which the parameter value is expressed is that established by
// the parameter value of SELECT SIZE UNIT (SSU).
var TSS_ = Sequence{
	Name:     "TSS",
	Desc:     "Thin Space Specification",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	MinParam: 1,
	Code:     []byte{' ', 'E'},
}

// VPA causes the active data position to be moved to line position n in the
// data component in a direction parallel to the line progression, where n
// equals the value of Pn.
var VPA_ = Sequence{
	Name:     "VPA",
	Desc:     "Line Position Absolute",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'d'},
}

// VPB causes the active data position to be moved by n line positions in the
// data component in a direction opposite to that of the line progression,
// where n equals the value of Pn.
var VPB_ = Sequence{
	Name:     "VPB",
	Desc:     "Line Position Backward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'k'},
}

// VPR causes the active data position to be moved by n line positions in the
// data component in a direction parallel to the line progression, where n
// equals the value of Pn.
var VPR_ = Sequence{
	Name:     "VPR",
	Desc:     "Line Position Forward",
	Type:     CSI,
	Notation: "Pn",
	NParam:   1,
	Defaults: []string{"1"},
	Code:     []byte{'e'},
}

// VTS causes a line tabulation stop to be set at the active line (the line
// that contains the active presentation position).
var VTS_ = Sequence{
	Name: "VTS",
	Desc: "Line Tabulation Set",
	Type: ESC,
	Code: []byte{'J'},
}

// C0 is the 3-character escape sequence designating and invoking the C0 set.
//
// NOTE 1
//
// The use of this escape sequence implies that all control functions of this
// C0 set must be implemented.
//
// NOTE 2
//
// It is assumed that even with no invoked C0 set the control character ESCAPE
// is available and is represented by bit combination 01/11.
//
// This sequence is described, but not named in ECMA-48.
var C0_ = Sequence{
	Name: "C0",
	Desc: "Control Set 0 Announcer",
	Type: ESC,
	Code: []byte{'!', '@'},
}

// C1 is the 3-character escape sequence designating and invoking the C1 set.
//
// NOTE:
//
// The use of this escape sequence implies that all control characters of this
// C1 set must be implemented.
//
// This sequence is described, but not named in ECMA-48.
var C1_ = Sequence{
	Name: "C1",
	Desc: "Control Set 1 Announcer",
	Type: ESC,
	Code: []byte{'&', '@'},
}

// C1ALT1, according to Standard ECMA-35, announces the control functions of
// the C1 set are represented by ESC Fe sequences as in a 7-bit code.
//
// This sequence is described, but not named in ECMA-48.
var C1ALT1_ = Sequence{
	Name: "C1ALT1",
	Desc: "Control Set 1 Announcer Alternate 1",
	Type: ESC,
	Code: []byte{' ', 'F'},
}

// C1LAT2 is an alternate 3-character escape sequence designating and invoking
// the C1 set.
//
// NOTE:
//
// The use of this escape sequence implies that all control characters of this
// C1 set must be implemented.
//
// This sequence is described, but not named in ECMA-48.
var C1ALT2_ = Sequence{
	Name: "C1ALT2",
	Desc: "Control Set 1 Announcer Alternate 2",
	Type: ESC,
	Code: []byte{'"', 'F'},
}

// Table maps escape sequence Names to the corresponding Sequence.
// The sequence does not include parameters or string termination sequences.
var Table = map[Name]*Sequence{
	NUL:    &NUL_,
	SOH:    &SOH_,
	STX:    &STX_,
	ETX:    &ETX_,
	EOT:    &EOT_,
	ENQ:    &ENQ_,
	ACK:    &ACK_,
	BEL:    &BEL_,
	BS:     &BS_,
	HT:     &HT_,
	LF:     &LF_,
	VT:     &VT_,
	FF:     &FF_,
	CR:     &CR_,
	SO:     &SO_,
	SI:     &SI_,
	DLE:    &DLE_,
	DC1:    &DC1_,
	DC2:    &DC2_,
	DC3:    &DC3_,
	DC4:    &DC4_,
	NAK:    &NAK_,
	SYN:    &SYN_,
	ETB:    &ETB_,
	CAN:    &CAN_,
	EM:     &EM_,
	SUB:    &SUB_,
	ESC:    &ESC_,
	IS4:    &IS4_,
	IS3:    &IS3_,
	IS2:    &IS2_,
	IS1:    &IS1_,
	APC:    &APC_,
	"\237": &APC_,
	BPH:    &BPH_,
	"\202": &BPH_,
	CBT:    &CBT_,
	CCH:    &CCH_,
	"\224": &CCH_,
	CHA:    &CHA_,
	CHT:    &CHT_,
	CMD:    &CMD_,
	CNL:    &CNL_,
	CPL:    &CPL_,
	CPR:    &CPR_,
	CSI:    &CSI_,
	"\233": &CSI_,
	CTC:    &CTC_,
	CUB:    &CUB_,
	CUD:    &CUD_,
	CUF:    &CUF_,
	CUP:    &CUP_,
	CUU:    &CUU_,
	CVT:    &CVT_,
	DA:     &DA_,
	DAQ:    &DAQ_,
	DCH:    &DCH_,
	DCS:    &DCS_,
	"\220": &DCS_,
	DL:     &DL_,
	DMI:    &DMI_,
	DSR:    &DSR_,
	DTA:    &DTA_,
	EA:     &EA_,
	ECH:    &ECH_,
	ED:     &ED_,
	EF:     &EF_,
	EL:     &EL_,
	EMI:    &EMI_,
	EPA:    &EPA_,
	"\227": &EPA_,
	ESA:    &ESA_,
	"\207": &ESA_,
	FNK:    &FNK_,
	FNT:    &FNT_,
	GCC:    &GCC_,
	GSM:    &GSM_,
	GSS:    &GSS_,
	HPA:    &HPA_,
	HPB:    &HPB_,
	HPR:    &HPR_,
	HTJ:    &HTJ_,
	"\211": &HTJ_,
	HTS:    &HTS_,
	"\210": &HTS_,
	HVP:    &HVP_,
	ICH:    &ICH_,
	IDCS:   &IDCS_,
	IGS:    &IGS_,
	IL:     &IL_,
	INT:    &INT_,
	JFY:    &JFY_,
	LS1R:   &LS1R_,
	LS2:    &LS2_,
	LS2R:   &LS2R_,
	LS3:    &LS3_,
	LS3R:   &LS3R_,
	MC:     &MC_,
	MW:     &MW_,
	"\225": &MW_,
	NBH:    &NBH_,
	"\203": &NBH_,
	NEL:    &NEL_,
	"\205": &NEL_,
	NP:     &NP_,
	OSC:    &OSC_,
	"\235": &OSC_,
	PEC:    &PEC_,
	PFS:    &PFS_,
	PLD:    &PLD_,
	"\213": &PLD_,
	PLU:    &PLU_,
	"\214": &PLU_,
	PM:     &PM_,
	"\236": &PM_,
	PP:     &PP_,
	PPA:    &PPA_,
	PPB:    &PPB_,
	PPR:    &PPR_,
	PTX:    &PTX_,
	PU1:    &PU1_,
	"\221": &PU1_,
	PU2:    &PU2_,
	"\222": &PU2_,
	QUAD:   &QUAD_,
	REP:    &REP_,
	RI:     &RI_,
	"\215": &RI_,
	RIS:    &RIS_,
	RM:     &RM_,
	SACS:   &SACS_,
	SAPV:   &SAPV_,
	SCI:    &SCI_,
	"\232": &SCI_,
	SCO:    &SCO_,
	SCP:    &SCP_,
	SCS:    &SCS_,
	SD:     &SD_,
	SDS:    &SDS_,
	SEE:    &SEE_,
	SEF:    &SEF_,
	SGR:    &SGR_,
	SHS:    &SHS_,
	SIMD:   &SIMD_,
	SL:     &SL_,
	SLH:    &SLH_,
	SLL:    &SLL_,
	SLS:    &SLS_,
	SM:     &SM_,
	SOS:    &SOS_,
	"\230": &SOS_,
	SPA:    &SPA_,
	"\226": &SPA_,
	SPD:    &SPD_,
	SPH:    &SPH_,
	SPI:    &SPI_,
	SPL:    &SPL_,
	SPQR:   &SPQR_,
	SR:     &SR_,
	SRCS:   &SRCS_,
	SRS:    &SRS_,
	SSA:    &SSA_,
	"\206": &SSA_,
	SSU:    &SSU_,
	SSW:    &SSW_,
	SS2:    &SS2_,
	"\216": &SS2_,
	SS3:    &SS3_,
	"\217": &SS3_,
	ST:     &ST_,
	"\234": &ST_,
	STAB:   &STAB_,
	STS:    &STS_,
	"\223": &STS_,
	SU:     &SU_,
	SVS:    &SVS_,
	TAC:    &TAC_,
	TALE:   &TALE_,
	TATE:   &TATE_,
	TBC:    &TBC_,
	TCC:    &TCC_,
	TSR:    &TSR_,
	TSS:    &TSS_,
	VPA:    &VPA_,
	VPB:    &VPB_,
	VPR:    &VPR_,
	VTS:    &VTS_,
	"\212": &VTS_,
	C0:     &C0_,
	C1:     &C1_,
	C1ALT1: &C1ALT1_,
	C1ALT2: &C1ALT2_,
}