/*
The MIT License (MIT)

Copyright © 2024 pacman64

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the “Software”), to deal
in the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

/*
Single-file source-code for j0: this version has no http(s) support. Even
the unit-tests from the original j0 are omitted.

To compile a smaller-sized command-line app, you can use the `go` command as
follows:

go build -ldflags "-s -w" -trimpath j0.go
*/

package main

import (
	"bufio"
	"bytes"
	"errors"
	"io"
	"os"
	"strconv"
)

const info = `
j0 [options...] [file...]


Json-0 converts/fixes JSON/pseudo-JSON input into minimal JSON output.
Its output is always a single line, which ends with a line-feed.

Besides minimizing bytes, this tool also adapts almost-JSON input into
valid JSON, since it

    - ignores both rest-of-line and multi-line comments
    - ignores extra/trailing commas in arrays and objects
    - turns single-quoted strings/keys into double-quoted strings
    - double-quotes unquoted object keys
    - changes \x 2-hex-digit into \u 4-hex-digit string-escapes

The only option available can either start with a single or a double-dash

    -h   -help       show this help message
`

const (
	bufSize    = 32 * 1024
	errorStyle = "\x1b[31m"
)

func main() {
	if len(os.Args) > 1 {
		switch os.Args[1] {
		case `-h`, `--h`, `-help`, `--help`:
			os.Stderr.WriteString(info[1:])
			return
		}
	}

	if len(os.Args) > 2 {
		const msg = `only 1 (optional) named input is supported`
		os.Stderr.WriteString(errorStyle + msg + "\x1b[0m\n")
		os.Exit(1)
	}

	name := `-`
	if len(os.Args) > 1 {
		name = os.Args[1]
	}

	if err := run(os.Stdout, name); isActualError(err) {
		os.Stderr.WriteString(errorStyle)
		os.Stderr.WriteString(err.Error())
		os.Stderr.WriteString("\x1b[0m\n")
		os.Exit(1)
	}
}

func run(w io.Writer, name string) error {
	if name == `` || name == `-` {
		return convertPseudoJSON(w, os.Stdin)
	}

	f, err := os.Open(name)
	if err != nil {
		return errors.New(`can't read from file named "` + name + `"`)
	}
	defer f.Close()

	return convertPseudoJSON(w, f)
}

var (
	errCommentEarlyEnd = errors.New(`unexpected early-end of comment`)
	errInputEarlyEnd   = errors.New(`expected end of input data`)
	errInvalidComment  = errors.New(`expected / or *`)
	errInvalidHex      = errors.New(`expected a base-16 digit`)
	errInvalidToken    = errors.New(`invalid JSON token`)
	errNoDigits        = errors.New(`expected numeric digits`)
	errNoStringQuote   = errors.New(`expected " or '`)
	errNoArrayComma    = errors.New(`missing comma between array values`)
	errNoObjectComma   = errors.New(`missing comma between key-value pairs`)
	errStringEarlyEnd  = errors.New(`unexpected early-end of string`)
	errExtraBytes      = errors.New(`unexpected extra input bytes`)

	// errNoMoreOutput is a generic dummy output-error, which is meant to be
	// ultimately ignored, being just an excuse to quit the app immediately
	// and successfully
	errNoMoreOutput = errors.New(`no more output`)
)

// isActualError is to figure out whether not to ignore an error, and thus
// show it as an error message
func isActualError(err error) bool {
	return err != nil && err != io.EOF && err != errNoMoreOutput
}

// linePosError is a more descriptive kind of error, showing the source of
// the input-related problem, as 1-based a line/pos number pair in front
// of the error message
type linePosError struct {
	// line is the 1-based line count from the input
	line int

	// pos is the 1-based `horizontal` position in its line
	pos int

	// err is the error message to `decorate` with the position info
	err error
}

// Error satisfies the error interface
func (lpe linePosError) Error() string {
	where := strconv.Itoa(lpe.line) + `:` + strconv.Itoa(lpe.pos)
	return where + `: ` + lpe.err.Error()
}

// convertPseudoJSON handles regular JSON and pseudo-JSON input
func convertPseudoJSON(w io.Writer, r io.Reader) error {
	bw := bufio.NewWriterSize(w, bufSize)
	br := bufio.NewReaderSize(r, bufSize)
	defer bw.Flush()

	if err := json0(bw, br); err != nil {
		return err
	}
	// end the only output-line with a line-feed; this also avoids showing
	// error messages on the same line as the main output, since JSON-0
	// output has no line-feeds before its last byte
	return outputByte(bw, '\n')
}

// isIdentifier improves control-flow of func handleKey, when it handles
// unquoted object keys
var isIdentifier = [256]bool{
	'_': true,

	'0': true, '1': true, '2': true, '3': true, '4': true,
	'5': true, '6': true, '7': true, '8': true, '9': true,

	'A': true, 'B': true, 'C': true, 'D': true, 'E': true, 'F': true,
	'G': true, 'H': true, 'I': true, 'J': true, 'K': true, 'L': true,
	'M': true, 'N': true, 'O': true, 'P': true, 'Q': true, 'R': true,
	'S': true, 'T': true, 'U': true, 'V': true, 'W': true, 'X': true,
	'Y': true, 'Z': true,

	'a': true, 'b': true, 'c': true, 'd': true, 'e': true, 'f': true,
	'g': true, 'h': true, 'i': true, 'j': true, 'k': true, 'l': true,
	'm': true, 'n': true, 'o': true, 'p': true, 'q': true, 'r': true,
	's': true, 't': true, 'u': true, 'v': true, 'w': true, 'x': true,
	'y': true, 'z': true,
}

// matchHex both figures out if a byte is a valid ASCII hex-digit, by not
// being 0, and normalizes letter-case for the hex letters
var matchHex = [256]byte{
	'0': '0', '1': '1', '2': '2', '3': '3', '4': '4',
	'5': '5', '6': '6', '7': '7', '8': '8', '9': '9',
	'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D', 'E': 'E', 'F': 'F',
	'a': 'A', 'b': 'B', 'c': 'C', 'd': 'D', 'e': 'E', 'f': 'F',
}

// json0 converts JSON/pseudo-JSON into (valid) minimal JSON; this func
// avoids writing a trailing line-feed, leaving that up to its caller
func json0(w *bufio.Writer, r *bufio.Reader) error {
	jr := jsonReader{r, 1, 1}

	// input is already assumed to be UTF-8: a leading UTF-8 BOM (byte-order
	// mark) gives no useful info if present, as UTF-8 leaves no ambiguity
	// about byte-order by design
	jr.skipUTF8BOM()

	// ignore leading whitespace and/or comments
	if err := jr.seekNext(); err != nil {
		return err
	}

	// handle a single top-level JSON value
	if err := handleValue(w, &jr); err != nil {
		return err
	}

	// ignore trailing whitespace and/or comments
	if err := jr.seekNext(); err != nil {
		return err
	}

	// beyond trailing whitespace and/or comments, any more bytes
	// make the whole input data invalid JSON
	if _, ok := jr.peekByte(); ok {
		return jr.improveError(errExtraBytes)
	}
	return nil
}

// jsonReader reads data via a buffer, keeping track of the input position:
// this in turn allows showing much more useful errors, when these happen
type jsonReader struct {
	// r is the actual reader
	r *bufio.Reader

	// line is the 1-based line-counter for input bytes, and gives errors
	// useful position info
	line int

	// pos is the 1-based `horizontal` position in its line, and gives
	// errors useful position info
	pos int
}

// improveError makes any error more useful, by giving it info about the
// current input-position, as a 1-based line/within-line-position pair
func (jr jsonReader) improveError(err error) error {
	if _, ok := err.(linePosError); ok {
		return err
	}

	if err == io.EOF {
		return linePosError{jr.line, jr.pos, errInputEarlyEnd}
	}
	if err != nil {
		return linePosError{jr.line, jr.pos, err}
	}
	return nil
}

// demandSyntax fails with an error when the next byte isn't the one given;
// when it is, the byte is then read/skipped, and a nil error is returned
func (jr *jsonReader) demandSyntax(syntax byte) error {
	chunk, err := jr.r.Peek(1)
	if err == io.EOF {
		return jr.improveError(errInputEarlyEnd)
	}
	if err != nil {
		return jr.improveError(err)
	}

	if len(chunk) < 1 || chunk[0] != syntax {
		msg := `expected ` + string(rune(syntax))
		return jr.improveError(errors.New(msg))
	}

	jr.readByte()
	return nil
}

// updatePosInfo does what it says, given the byte just read separately
func (jr *jsonReader) updatePosInfo(b byte) {
	if b == '\n' {
		jr.line += 1
		jr.pos = 1
	} else {
		jr.pos++
	}
}

// peekByte simplifies control-flow for various other funcs
func (jr jsonReader) peekByte() (b byte, ok bool) {
	chunk, err := jr.r.Peek(1)
	if err == nil && len(chunk) >= 1 {
		return chunk[0], true
	}
	return 0, false
}

// readByte does what it says, updating the reader's position info
func (jr *jsonReader) readByte() (b byte, err error) {
	b, err = jr.r.ReadByte()
	if err == nil {
		jr.updatePosInfo(b)
		return b, nil
	}
	return b, jr.improveError(err)
}

// seekNext skips/seeks the next token, ignoring runs of whitespace symbols
// and comments, either single-line (starting with //) or general (starting
// with /* and ending with */)
func (jr *jsonReader) seekNext() error {
	for {
		b, ok := jr.peekByte()
		if !ok {
			return nil
		}

		// case ' ', '\t', '\f', '\v', '\r', '\n':
		if b <= 32 {
			// keep skipping whitespace bytes
			b, _ := jr.readByte()
			jr.updatePosInfo(b)
			continue
		}

		if b != '/' {
			// reached the next token
			return nil
		}

		if err := jr.skipComment(); err != nil {
			return err
		}

		// after comments, keep looking for more whitespace and/or comments
	}
}

// skipComment helps func seekNext skip over comments, simplifying the latter
// func's control-flow
func (jr *jsonReader) skipComment() error {
	err := jr.demandSyntax('/')
	if err != nil {
		return err
	}

	b, ok := jr.peekByte()
	if !ok {
		return jr.improveError(errInputEarlyEnd)
	}

	switch b {
	case '/':
		// handle single-line comments
		return jr.skipLine()

	case '*':
		// handle (potentially) multi-line comments
		return jr.skipGeneralComment()

	default:
		return jr.improveError(errInvalidComment)
	}
}

// skipLine handles single-line comments for func skipComment
func (jr *jsonReader) skipLine() error {
	for {
		b, err := jr.r.ReadByte()
		if err == io.EOF {
			// end of input is fine in this case
			return nil
		}
		if err != nil {
			return err
		}

		jr.updatePosInfo(b)
		if b == '\n' {
			jr.line++
			return nil
		}
	}
}

// skipGeneralComment handles (potentially) multi-line comments for func
// skipComment
func (jr *jsonReader) skipGeneralComment() error {
	var prev byte
	for {
		b, err := jr.readByte()
		if err != nil {
			return jr.improveError(errCommentEarlyEnd)
		}

		if prev == '*' && b == '/' {
			return nil
		}
		if b == '\n' {
			jr.line++
		}
		prev = b
	}
}

// skipUTF8BOM does what it says, if a UTF-8 BOM is present
func (jr *jsonReader) skipUTF8BOM() {
	lead, err := jr.r.Peek(3)
	if err == nil && bytes.HasPrefix(lead, []byte{0xef, 0xbb, 0xbf}) {
		jr.readByte()
		jr.readByte()
		jr.readByte()
		jr.pos += 3
	}
}

// outputByte is a small wrapper on func WriteByte, which adapts any error
// into a custom dummy output-error, which is in turn meant to be ignored,
// being just an excuse to quit the app immediately and successfully
func outputByte(w *bufio.Writer, b byte) error {
	err := w.WriteByte(b)
	if err == nil {
		return nil
	}
	return errNoMoreOutput
}

// handleArray handles arrays for func handleValue
func handleArray(w *bufio.Writer, jr *jsonReader) error {
	if err := jr.demandSyntax('['); err != nil {
		return err
	}
	w.WriteByte('[')

	for n := 0; true; n++ {
		// there may be whitespace/comments before the next comma
		if err := jr.seekNext(); err != nil {
			return err
		}

		// handle commas between values, as well as trailing ones
		comma := false
		b, _ := jr.peekByte()
		if b == ',' {
			jr.readByte()
			comma = true

			// there may be whitespace/comments before an ending ']'
			if err := jr.seekNext(); err != nil {
				return err
			}
			b, _ = jr.peekByte()
		}

		// handle end of array
		if b == ']' {
			jr.readByte()
			w.WriteByte(']')
			return nil
		}

		// don't forget commas between adjacent values
		if n > 0 {
			if !comma {
				return errNoArrayComma
			}
			if err := outputByte(w, ','); err != nil {
				return err
			}
		}

		// handle the next value
		if err := jr.seekNext(); err != nil {
			return err
		}
		if err := handleValue(w, jr); err != nil {
			return err
		}
	}

	// make the compiler happy
	return nil
}

// handleDigits helps various number-handling funcs do their job
func handleDigits(w *bufio.Writer, jr *jsonReader) error {
	for n := 0; true; n++ {
		b, _ := jr.peekByte()

		// support `nice` long numbers by ignoring their underscores
		if b == '_' {
			jr.readByte()
			continue
		}

		if '0' <= b && b <= '9' {
			jr.readByte()
			w.WriteByte(b)
			continue
		}

		if n == 0 {
			return errNoDigits
		}
		return nil
	}

	// make the compiler happy
	return nil
}

// handleDot handles pseudo-JSON numbers which start with a decimal dot
func handleDot(w *bufio.Writer, jr *jsonReader) error {
	if err := jr.demandSyntax('.'); err != nil {
		return err
	}
	w.Write([]byte{'0', '.'})
	return handleDigits(w, jr)
}

// handleKey is used by func handleObjects and generalizes func handleString,
// by allowing unquoted object keys; it's not used anywhere else, as allowing
// unquoted string values is ambiguous with actual JSON-keyword values null,
// false, and true.
func handleKey(w *bufio.Writer, jr *jsonReader) error {
	quote, ok := jr.peekByte()
	if quote == '"' || quote == '\'' {
		return handleString(w, jr)
	}
	if !ok {
		return jr.improveError(errStringEarlyEnd)
	}

	w.WriteByte('"')
	for {
		if b, _ := jr.peekByte(); isIdentifier[b] {
			jr.readByte()
			w.WriteByte(b)
			continue
		}

		w.WriteByte('"')
		return nil
	}
}

// trySimpleInner tries to handle (more quickly) inner-strings where all bytes
// are unescaped ASCII symbols: this is a very common case for strings, and is
// almost always the case for object keys; returns whether it succeeded, so
// this func's caller knows knows if it needs to do anything, the slower way
func trySimpleInner(w *bufio.Writer, jr *jsonReader, quote byte) (gotIt bool) {
	chunk, _ := jr.r.Peek(64)

	for i, b := range chunk {
		if b < 32 || b > 127 || b == '\\' {
			return false
		}
		if b != quote {
			continue
		}

		// bulk-writing the chunk is this func's whole point
		w.WriteByte('"')
		w.Write(chunk[:i])
		w.WriteByte('"')

		jr.r.Discard(i + 1)
		return true
	}

	// maybe the inner-string is ok, but it's just longer than the chunk
	return false
}

// handleKeyword is used by funcs handleFalse, handleNull, and handleTrue
func handleKeyword(w *bufio.Writer, jr *jsonReader, kw []byte) error {
	for rest := kw; len(rest) > 0; rest = rest[1:] {
		b, err := jr.readByte()
		if err == nil && b == rest[0] {
			// keywords given to this func have no line-feeds
			jr.pos++
			continue
		}

		msg := `expected JSON value ` + string(kw)
		return jr.improveError(errors.New(msg))
	}

	w.Write(kw)
	return nil
}

// handleNegative handles numbers starting with a negative sign for func
// handleValue
func handleNegative(w *bufio.Writer, jr *jsonReader) error {
	if err := jr.demandSyntax('-'); err != nil {
		return err
	}

	w.WriteByte('-')
	if b, _ := jr.peekByte(); b == '.' {
		jr.readByte()
		w.Write([]byte{'0', '.'})
		return handleDigits(w, jr)
	}
	return handleNumber(w, jr)
}

// handleNumber handles numeric values/tokens, including invalid-JSON cases,
// such as values starting with a decimal dot
func handleNumber(w *bufio.Writer, jr *jsonReader) error {
	// handle integer digits
	if err := handleDigits(w, jr); err != nil {
		return err
	}

	// handle optional decimal digits, starting with a leading dot
	if b, _ := jr.peekByte(); b == '.' {
		jr.readByte()
		w.WriteByte('.')
		return handleDigits(w, jr)
	}

	// handle optional exponent digits
	if b, _ := jr.peekByte(); b == 'e' || b == 'E' {
		jr.readByte()
		w.WriteByte(b)
		b, _ = jr.peekByte()
		if b == '+' {
			jr.readByte()
		} else if b == '-' {
			w.WriteByte('-')
			jr.readByte()
		}
		return handleDigits(w, jr)
	}

	return nil
}

// handleObject handles objects for func handleValue
func handleObject(w *bufio.Writer, jr *jsonReader) error {
	if err := jr.demandSyntax('{'); err != nil {
		return err
	}
	w.WriteByte('{')

	for npairs := 0; true; npairs++ {
		// there may be whitespace/comments before the next comma
		if err := jr.seekNext(); err != nil {
			return err
		}

		// handle commas between key-value pairs, as well as trailing ones
		comma := false
		b, _ := jr.peekByte()
		if b == ',' {
			jr.readByte()
			comma = true

			// there may be whitespace/comments before an ending '}'
			if err := jr.seekNext(); err != nil {
				return err
			}
			b, _ = jr.peekByte()
		}

		// handle end of object
		if b == '}' {
			jr.readByte()
			w.WriteByte('}')
			return nil
		}

		// don't forget commas between adjacent key-value pairs
		if npairs > 0 {
			if !comma {
				return errNoObjectComma
			}
			if err := outputByte(w, ','); err != nil {
				return err
			}
		}

		// handle the next pair's key
		if err := jr.seekNext(); err != nil {
			return err
		}
		if err := handleKey(w, jr); err != nil {
			return err
		}

		// demand a colon right after the key
		if err := jr.seekNext(); err != nil {
			return err
		}
		if err := jr.demandSyntax(':'); err != nil {
			return err
		}
		w.WriteByte(':')

		// handle the next pair's value
		if err := jr.seekNext(); err != nil {
			return err
		}
		if err := handleValue(w, jr); err != nil {
			return err
		}
	}

	// make the compiler happy
	return nil
}

// handlePositive handles numbers starting with a positive sign for func
// handleValue
func handlePositive(w *bufio.Writer, jr *jsonReader) error {
	if err := jr.demandSyntax('+'); err != nil {
		return err
	}

	// valid JSON isn't supposed to have leading pluses on numbers, so
	// emit nothing for it, unlike for negative numbers

	if b, _ := jr.peekByte(); b == '.' {
		jr.readByte()
		w.Write([]byte{'0', '.'})
		return handleDigits(w, jr)
	}
	return handleNumber(w, jr)
}

// handleString handles strings for funcs handleValue and handleObject, and
// supports both single-quotes and double-quotes, always emitting the latter
// in the output, of course
func handleString(w *bufio.Writer, jr *jsonReader) error {
	quote, ok := jr.peekByte()
	if !ok || (quote != '"' && quote != '\'') {
		return errNoStringQuote
	}

	jr.readByte()
	// try the quicker all-unescaped-ASCII handler
	if trySimpleInner(w, jr, quote) {
		return nil
	}

	// it's a non-trivial inner-string, so handle it byte-by-byte
	w.WriteByte('"')
	escaped := false

	for {
		b, err := jr.r.ReadByte()
		if err != nil {
			if err == io.EOF {
				return jr.improveError(errStringEarlyEnd)
			}
			return jr.improveError(err)
		}

		if !escaped {
			if b == '\\' {
				escaped = true
				continue
			}

			// handle end of string
			if b == quote {
				return outputByte(w, '"')
			}

			w.Write(escapedStringBytes[b])
			jr.updatePosInfo(b)
			continue
		}

		// handle escaped items
		escaped = false

		switch b {
		case 'u':
			// \u needs exactly 4 hex-digits to follow it
			w.Write([]byte{'\\', 'u'})
			if err := copyHex(w, 4, jr); err != nil {
				return jr.improveError(err)
			}

		case 'x':
			// JSON only supports 4 escaped hex-digits, so pad the 2
			// expected hex-digits with 2 zeros
			w.Write([]byte{'\\', 'u', '0', '0'})
			if err := copyHex(w, 2, jr); err != nil {
				return jr.improveError(err)
			}

		case 't', 'f', 'r', 'n', 'b', '\\', '"':
			// handle valid-JSON escaped string sequences
			w.WriteByte('\\')
			w.WriteByte(b)

		// case '\'':
		// 	// escaped single-quotes aren't standard JSON, but they can
		// 	// be handy when the input uses non-standard single-quoted
		// 	// strings
		// 	w.WriteByte('\'')

		default:
			// return jr.decorateError(unexpectedByte{b})
			w.Write(escapedStringBytes[b])
		}
	}
}

// copyHex handles a run of hex-digits for func handleString, starting right
// after the leading `\u` (or `\x`) part; this func doesn't `improve` its
// errors with position info: that's up to the caller
func copyHex(w *bufio.Writer, n int, jr *jsonReader) error {
	for i := 0; i < n; i++ {
		b, err := jr.r.ReadByte()
		if err == io.EOF {
			return errStringEarlyEnd
		}
		if err != nil {
			return err
		}

		jr.updatePosInfo(b)

		if b := matchHex[b]; b != 0 {
			w.WriteByte(b)
			continue
		}

		return errInvalidHex
	}

	return nil
}

// handleValue is a generic JSON-token handler, which allows the recursive
// behavior to handle any kind of JSON/pseudo-JSON input
func handleValue(w *bufio.Writer, jr *jsonReader) error {
	chunk, err := jr.r.Peek(1)
	if err == nil && len(chunk) >= 1 {
		return handleValueDispatch(w, jr, chunk[0])
	}

	if err == io.EOF {
		return jr.improveError(errInputEarlyEnd)
	}
	return jr.improveError(errInputEarlyEnd)
}

// handleValueDispatch simplifies control-flow for func handleValue
func handleValueDispatch(w *bufio.Writer, jr *jsonReader, b byte) error {
	switch b {
	case 'f':
		return handleKeyword(w, jr, []byte{'f', 'a', 'l', 's', 'e'})
	case 'n':
		return handleKeyword(w, jr, []byte{'n', 'u', 'l', 'l'})
	case 't':
		return handleKeyword(w, jr, []byte{'t', 'r', 'u', 'e'})
	case '.':
		return handleDot(w, jr)
	case '+':
		return handlePositive(w, jr)
	case '-':
		return handleNegative(w, jr)
	case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
		return handleNumber(w, jr)
	case '\'', '"':
		return handleString(w, jr)
	case '[':
		return handleArray(w, jr)
	case '{':
		return handleObject(w, jr)
	default:
		return jr.improveError(errInvalidToken)
	}
}

// escapedStringBytes helps func handleString treat all string bytes quickly
// and correctly, using their officially-supported JSON escape sequences
//
// https://www.rfc-editor.org/rfc/rfc8259#section-7
var escapedStringBytes = [256][]byte{
	{'\\', 'u', '0', '0', '0', '0'}, {'\\', 'u', '0', '0', '0', '1'},
	{'\\', 'u', '0', '0', '0', '2'}, {'\\', 'u', '0', '0', '0', '3'},
	{'\\', 'u', '0', '0', '0', '4'}, {'\\', 'u', '0', '0', '0', '5'},
	{'\\', 'u', '0', '0', '0', '6'}, {'\\', 'u', '0', '0', '0', '7'},
	{'\\', 'b'}, {'\\', 't'},
	{'\\', 'n'}, {'\\', 'u', '0', '0', '0', 'b'},
	{'\\', 'f'}, {'\\', 'r'},
	{'\\', 'u', '0', '0', '0', 'e'}, {'\\', 'u', '0', '0', '0', 'f'},
	{'\\', 'u', '0', '0', '1', '0'}, {'\\', 'u', '0', '0', '1', '1'},
	{'\\', 'u', '0', '0', '1', '2'}, {'\\', 'u', '0', '0', '1', '3'},
	{'\\', 'u', '0', '0', '1', '4'}, {'\\', 'u', '0', '0', '1', '5'},
	{'\\', 'u', '0', '0', '1', '6'}, {'\\', 'u', '0', '0', '1', '7'},
	{'\\', 'u', '0', '0', '1', '8'}, {'\\', 'u', '0', '0', '1', '9'},
	{'\\', 'u', '0', '0', '1', 'a'}, {'\\', 'u', '0', '0', '1', 'b'},
	{'\\', 'u', '0', '0', '1', 'c'}, {'\\', 'u', '0', '0', '1', 'd'},
	{'\\', 'u', '0', '0', '1', 'e'}, {'\\', 'u', '0', '0', '1', 'f'},
	{32}, {33}, {'\\', '"'}, {35}, {36}, {37}, {38}, {39},
	{40}, {41}, {42}, {43}, {44}, {45}, {46}, {47},
	{48}, {49}, {50}, {51}, {52}, {53}, {54}, {55},
	{56}, {57}, {58}, {59}, {60}, {61}, {62}, {63},
	{64}, {65}, {66}, {67}, {68}, {69}, {70}, {71},
	{72}, {73}, {74}, {75}, {76}, {77}, {78}, {79},
	{80}, {81}, {82}, {83}, {84}, {85}, {86}, {87},
	{88}, {89}, {90}, {91}, {'\\', '\\'}, {93}, {94}, {95},
	{96}, {97}, {98}, {99}, {100}, {101}, {102}, {103},
	{104}, {105}, {106}, {107}, {108}, {109}, {110}, {111},
	{112}, {113}, {114}, {115}, {116}, {117}, {118}, {119},
	{120}, {121}, {122}, {123}, {124}, {125}, {126}, {127},
	{128}, {129}, {130}, {131}, {132}, {133}, {134}, {135},
	{136}, {137}, {138}, {139}, {140}, {141}, {142}, {143},
	{144}, {145}, {146}, {147}, {148}, {149}, {150}, {151},
	{152}, {153}, {154}, {155}, {156}, {157}, {158}, {159},
	{160}, {161}, {162}, {163}, {164}, {165}, {166}, {167},
	{168}, {169}, {170}, {171}, {172}, {173}, {174}, {175},
	{176}, {177}, {178}, {179}, {180}, {181}, {182}, {183},
	{184}, {185}, {186}, {187}, {188}, {189}, {190}, {191},
	{192}, {193}, {194}, {195}, {196}, {197}, {198}, {199},
	{200}, {201}, {202}, {203}, {204}, {205}, {206}, {207},
	{208}, {209}, {210}, {211}, {212}, {213}, {214}, {215},
	{216}, {217}, {218}, {219}, {220}, {221}, {222}, {223},
	{224}, {225}, {226}, {227}, {228}, {229}, {230}, {231},
	{232}, {233}, {234}, {235}, {236}, {237}, {238}, {239},
	{240}, {241}, {242}, {243}, {244}, {245}, {246}, {247},
	{248}, {249}, {250}, {251}, {252}, {253}, {254}, {255},
}