enable ya make for go projects

14 files changed, 6818 insertions, 0 deletions

diff --git a/vendor/golang.org/x/text/cases/cases.go b/vendor/golang.org/x/text/cases/cases.go
new file mode 100644
index 0000000000..752cdf0316
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/cases.go
@@ -0,0 +1,162 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run gen.go gen_trieval.go
+
+// Package cases provides general and language-specific case mappers.
+package cases // import "golang.org/x/text/cases"
+
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+)
+
+// References:
+// - Unicode Reference Manual Chapter 3.13, 4.2, and 5.18.
+// - https://www.unicode.org/reports/tr29/
+// - https://www.unicode.org/Public/6.3.0/ucd/CaseFolding.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/SpecialCasing.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/DerivedCoreProperties.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/auxiliary/WordBreakProperty.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/auxiliary/WordBreakTest.txt
+// - http://userguide.icu-project.org/transforms/casemappings
+
+// TODO:
+// - Case folding
+// - Wide and Narrow?
+// - Segmenter option for title casing.
+// - ASCII fast paths
+// - Encode Soft-Dotted property within trie somehow.
+
+// A Caser transforms given input to a certain case. It implements
+// transform.Transformer.
+//
+// A Caser may be stateful and should therefore not be shared between
+// goroutines.
+type Caser struct {
+	t transform.SpanningTransformer
+}
+
+// Bytes returns a new byte slice with the result of converting b to the case
+// form implemented by c.
+func (c Caser) Bytes(b []byte) []byte {
+	b, _, _ = transform.Bytes(c.t, b)
+	return b
+}
+
+// String returns a string with the result of transforming s to the case form
+// implemented by c.
+func (c Caser) String(s string) string {
+	s, _, _ = transform.String(c.t, s)
+	return s
+}
+
+// Reset resets the Caser to be reused for new input after a previous call to
+// Transform.
+func (c Caser) Reset() { c.t.Reset() }
+
+// Transform implements the transform.Transformer interface and transforms the
+// given input to the case form implemented by c.
+func (c Caser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	return c.t.Transform(dst, src, atEOF)
+}
+
+// Span implements the transform.SpanningTransformer interface.
+func (c Caser) Span(src []byte, atEOF bool) (n int, err error) {
+	return c.t.Span(src, atEOF)
+}
+
+// Upper returns a Caser for language-specific uppercasing.
+func Upper(t language.Tag, opts ...Option) Caser {
+	return Caser{makeUpper(t, getOpts(opts...))}
+}
+
+// Lower returns a Caser for language-specific lowercasing.
+func Lower(t language.Tag, opts ...Option) Caser {
+	return Caser{makeLower(t, getOpts(opts...))}
+}
+
+// Title returns a Caser for language-specific title casing. It uses an
+// approximation of the default Unicode Word Break algorithm.
+func Title(t language.Tag, opts ...Option) Caser {
+	return Caser{makeTitle(t, getOpts(opts...))}
+}
+
+// Fold returns a Caser that implements Unicode case folding. The returned Caser
+// is stateless and safe to use concurrently by multiple goroutines.
+//
+// Case folding does not normalize the input and may not preserve a normal form.
+// Use the collate or search package for more convenient and linguistically
+// sound comparisons. Use golang.org/x/text/secure/precis for string comparisons
+// where security aspects are a concern.
+func Fold(opts ...Option) Caser {
+	return Caser{makeFold(getOpts(opts...))}
+}
+
+// An Option is used to modify the behavior of a Caser.
+type Option func(o options) options
+
+// TODO: consider these options to take a boolean as well, like FinalSigma.
+// The advantage of using this approach is that other providers of a lower-case
+// algorithm could set different defaults by prefixing a user-provided slice
+// of options with their own. This is handy, for instance, for the precis
+// package which would override the default to not handle the Greek final sigma.
+
+var (
+	// NoLower disables the lowercasing of non-leading letters for a title
+	// caser.
+	NoLower Option = noLower
+
+	// Compact omits mappings in case folding for characters that would grow the
+	// input. (Unimplemented.)
+	Compact Option = compact
+)
+
+// TODO: option to preserve a normal form, if applicable?
+
+type options struct {
+	noLower bool
+	simple  bool
+
+	// TODO: segmenter, max ignorable, alternative versions, etc.
+
+	ignoreFinalSigma bool
+}
+
+func getOpts(o ...Option) (res options) {
+	for _, f := range o {
+		res = f(res)
+	}
+	return
+}
+
+func noLower(o options) options {
+	o.noLower = true
+	return o
+}
+
+func compact(o options) options {
+	o.simple = true
+	return o
+}
+
+// HandleFinalSigma specifies whether the special handling of Greek final sigma
+// should be enabled. Unicode prescribes handling the Greek final sigma for all
+// locales, but standards like IDNA and PRECIS override this default.
+func HandleFinalSigma(enable bool) Option {
+	if enable {
+		return handleFinalSigma
+	}
+	return ignoreFinalSigma
+}
+
+func ignoreFinalSigma(o options) options {
+	o.ignoreFinalSigma = true
+	return o
+}
+
+func handleFinalSigma(o options) options {
+	o.ignoreFinalSigma = false
+	return o
+}
diff --git a/vendor/golang.org/x/text/cases/context.go b/vendor/golang.org/x/text/cases/context.go
new file mode 100644
index 0000000000..e9aa9e1936
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/context.go
@@ -0,0 +1,376 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import "golang.org/x/text/transform"
+
+// A context is used for iterating over source bytes, fetching case info and
+// writing to a destination buffer.
+//
+// Casing operations may need more than one rune of context to decide how a rune
+// should be cased. Casing implementations should call checkpoint on context
+// whenever it is known to be safe to return the runes processed so far.
+//
+// It is recommended for implementations to not allow for more than 30 case
+// ignorables as lookahead (analogous to the limit in norm) and to use state if
+// unbounded lookahead is needed for cased runes.
+type context struct {
+	dst, src []byte
+	atEOF    bool
+
+	pDst int // pDst points past the last written rune in dst.
+	pSrc int // pSrc points to the start of the currently scanned rune.
+
+	// checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
+	nDst, nSrc int
+	err        error
+
+	sz   int  // size of current rune
+	info info // case information of currently scanned rune
+
+	// State preserved across calls to Transform.
+	isMidWord bool // false if next cased letter needs to be title-cased.
+}
+
+func (c *context) Reset() {
+	c.isMidWord = false
+}
+
+// ret returns the return values for the Transform method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) ret() (nDst, nSrc int, err error) {
+	if c.err != nil || c.nSrc == len(c.src) {
+		return c.nDst, c.nSrc, c.err
+	}
+	// This point is only reached by mappers if there was no short destination
+	// buffer. This means that the source buffer was exhausted and that c.sz was
+	// set to 0 by next.
+	if c.atEOF && c.pSrc == len(c.src) {
+		return c.pDst, c.pSrc, nil
+	}
+	return c.nDst, c.nSrc, transform.ErrShortSrc
+}
+
+// retSpan returns the return values for the Span method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) retSpan() (n int, err error) {
+	_, nSrc, err := c.ret()
+	return nSrc, err
+}
+
+// checkpoint sets the return value buffer points for Transform to the current
+// positions.
+func (c *context) checkpoint() {
+	if c.err == nil {
+		c.nDst, c.nSrc = c.pDst, c.pSrc+c.sz
+	}
+}
+
+// unreadRune causes the last rune read by next to be reread on the next
+// invocation of next. Only one unreadRune may be called after a call to next.
+func (c *context) unreadRune() {
+	c.sz = 0
+}
+
+func (c *context) next() bool {
+	c.pSrc += c.sz
+	if c.pSrc == len(c.src) || c.err != nil {
+		c.info, c.sz = 0, 0
+		return false
+	}
+	v, sz := trie.lookup(c.src[c.pSrc:])
+	c.info, c.sz = info(v), sz
+	if c.sz == 0 {
+		if c.atEOF {
+			// A zero size means we have an incomplete rune. If we are atEOF,
+			// this means it is an illegal rune, which we will consume one
+			// byte at a time.
+			c.sz = 1
+		} else {
+			c.err = transform.ErrShortSrc
+			return false
+		}
+	}
+	return true
+}
+
+// writeBytes adds bytes to dst.
+func (c *context) writeBytes(b []byte) bool {
+	if len(c.dst)-c.pDst < len(b) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for _, ch := range b {
+		c.dst[c.pDst] = ch
+		c.pDst++
+	}
+	return true
+}
+
+// writeString writes the given string to dst.
+func (c *context) writeString(s string) bool {
+	if len(c.dst)-c.pDst < len(s) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for i := 0; i < len(s); i++ {
+		c.dst[c.pDst] = s[i]
+		c.pDst++
+	}
+	return true
+}
+
+// copy writes the current rune to dst.
+func (c *context) copy() bool {
+	return c.writeBytes(c.src[c.pSrc : c.pSrc+c.sz])
+}
+
+// copyXOR copies the current rune to dst and modifies it by applying the XOR
+// pattern of the case info. It is the responsibility of the caller to ensure
+// that this is a rune with a XOR pattern defined.
+func (c *context) copyXOR() bool {
+	if !c.copy() {
+		return false
+	}
+	if c.info&xorIndexBit == 0 {
+		// Fast path for 6-bit XOR pattern, which covers most cases.
+		c.dst[c.pDst-1] ^= byte(c.info >> xorShift)
+	} else {
+		// Interpret XOR bits as an index.
+		// TODO: test performance for unrolling this loop. Verify that we have
+		// at least two bytes and at most three.
+		idx := c.info >> xorShift
+		for p := c.pDst - 1; ; p-- {
+			c.dst[p] ^= xorData[idx]
+			idx--
+			if xorData[idx] == 0 {
+				break
+			}
+		}
+	}
+	return true
+}
+
+// hasPrefix returns true if src[pSrc:] starts with the given string.
+func (c *context) hasPrefix(s string) bool {
+	b := c.src[c.pSrc:]
+	if len(b) < len(s) {
+		return false
+	}
+	for i, c := range b[:len(s)] {
+		if c != s[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// caseType returns an info with only the case bits, normalized to either
+// cLower, cUpper, cTitle or cUncased.
+func (c *context) caseType() info {
+	cm := c.info & 0x7
+	if cm < 4 {
+		return cm
+	}
+	if cm >= cXORCase {
+		// xor the last bit of the rune with the case type bits.
+		b := c.src[c.pSrc+c.sz-1]
+		return info(b&1) ^ cm&0x3
+	}
+	if cm == cIgnorableCased {
+		return cLower
+	}
+	return cUncased
+}
+
+// lower writes the lowercase version of the current rune to dst.
+func lower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		return c.writeString(e[offset : offset+nLower])
+	}
+	return c.copy()
+}
+
+func isLower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// upper writes the uppercase version of the current rune to dst.
+func upper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		// The first special case mapping is for lower. Set n to the second.
+		if n == noChange {
+			n = 0
+		}
+		n, e = e[1]&lengthMask, e[n:]
+	}
+	if n != noChange {
+		return c.writeString(e[offset : offset+n])
+	}
+	return c.copy()
+}
+
+// isUpper writes the isUppercase version of the current rune to dst.
+func isUpper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		n = e[1] & lengthMask
+	}
+	if n != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// title writes the title case version of the current rune to dst.
+func title(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		if nFirst != noChange {
+			e = e[nFirst:]
+		}
+		return c.writeString(e[offset : offset+nTitle])
+	}
+	if ct == cLower && nFirst != noChange {
+		// Use the uppercase version instead.
+		return c.writeString(e[offset : offset+nFirst])
+	}
+	// Already in correct case.
+	return c.copy()
+}
+
+// isTitle reports whether the current rune is in title case.
+func isTitle(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if ct == cLower && nFirst != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// foldFull writes the foldFull version of the current rune to dst.
+func foldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return c.copy()
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 {
+		if ct == cLower {
+			return c.copy()
+		}
+		n = (e[1] >> lengthBits) & lengthMask
+	}
+	return c.writeString(e[2 : 2+n])
+}
+
+// isFoldFull reports whether the current run is mapped to foldFull
+func isFoldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return true
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 && ct == cLower {
+		return true
+	}
+	c.err = transform.ErrEndOfSpan
+	return false
+}
diff --git a/vendor/golang.org/x/text/cases/context_test.go b/vendor/golang.org/x/text/cases/context_test.go
new file mode 100644
index 0000000000..de6ba3f8cf
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/context_test.go
@@ -0,0 +1,438 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import (
+	"strings"
+	"testing"
+	"unicode"
+
+	"golang.org/x/text/internal/testtext"
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+	"golang.org/x/text/unicode/rangetable"
+)
+
+// The following definitions are taken directly from Chapter 3 of The Unicode
+// Standard.
+
+func propCased(r rune) bool {
+	return propLower(r) || propUpper(r) || unicode.IsTitle(r)
+}
+
+func propLower(r rune) bool {
+	return unicode.IsLower(r) || unicode.Is(unicode.Other_Lowercase, r)
+}
+
+func propUpper(r rune) bool {
+	return unicode.IsUpper(r) || unicode.Is(unicode.Other_Uppercase, r)
+}
+
+func propIgnore(r rune) bool {
+	if unicode.In(r, unicode.Mn, unicode.Me, unicode.Cf, unicode.Lm, unicode.Sk) {
+		return true
+	}
+	return caseIgnorable[r]
+}
+
+func hasBreakProp(r rune) bool {
+	// binary search over ranges
+	lo := 0
+	hi := len(breakProp)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		bp := &breakProp[m]
+		if bp.lo <= r && r <= bp.hi {
+			return true
+		}
+		if r < bp.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return false
+}
+
+func contextFromRune(r rune) *context {
+	c := context{dst: make([]byte, 128), src: []byte(string(r)), atEOF: true}
+	c.next()
+	return &c
+}
+
+func TestCaseProperties(t *testing.T) {
+	if unicode.Version != UnicodeVersion {
+		// Properties of existing code points may change by Unicode version, so
+		// we need to skip.
+		t.Skipf("Skipping as core Unicode version %s different than %s", unicode.Version, UnicodeVersion)
+	}
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		c := contextFromRune(r)
+		if got, want := c.info.isCaseIgnorable(), propIgnore(r); got != want {
+			t.Errorf("caseIgnorable(%U): got %v; want %v (%x)", r, got, want, c.info)
+		}
+		// New letters may change case types, but existing case pairings should
+		// not change. See Case Pair Stability in
+		// https://unicode.org/policies/stability_policy.html.
+		if rf := unicode.SimpleFold(r); rf != r && unicode.In(rf, assigned) {
+			if got, want := c.info.isCased(), propCased(r); got != want {
+				t.Errorf("cased(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+			if got, want := c.caseType() == cUpper, propUpper(r); got != want {
+				t.Errorf("upper(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+			if got, want := c.caseType() == cLower, propLower(r); got != want {
+				t.Errorf("lower(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+		}
+		if got, want := c.info.isBreak(), hasBreakProp(r); got != want {
+			t.Errorf("isBreak(%U): got %v; want %v (%x)", r, got, want, c.info)
+		}
+	}
+	// TODO: get title case from unicode file.
+}
+
+func TestMapping(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	if coreVersion == nil {
+		coreVersion = assigned
+	}
+	apply := func(r rune, f func(c *context) bool) string {
+		c := contextFromRune(r)
+		f(c)
+		return string(c.dst[:c.pDst])
+	}
+
+	for r, tt := range special {
+		if got, want := apply(r, lower), tt.toLower; got != want {
+			t.Errorf("lowerSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+		if got, want := apply(r, title), tt.toTitle; got != want {
+			t.Errorf("titleSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+		if got, want := apply(r, upper), tt.toUpper; got != want {
+			t.Errorf("upperSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+	}
+
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		if rf := unicode.SimpleFold(r); rf == r || !unicode.In(rf, assigned) {
+			continue
+		}
+		if _, ok := special[r]; ok {
+			continue
+		}
+		want := string(unicode.ToLower(r))
+		if got := apply(r, lower); got != want {
+			t.Errorf("lower:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+
+		want = string(unicode.ToUpper(r))
+		if got := apply(r, upper); got != want {
+			t.Errorf("upper:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+
+		want = string(unicode.ToTitle(r))
+		if got := apply(r, title); got != want {
+			t.Errorf("title:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+	}
+}
+
+func runeFoldData(r rune) (x struct{ simple, full, special string }) {
+	x = foldMap[r]
+	if x.simple == "" {
+		x.simple = string(unicode.ToLower(r))
+	}
+	if x.full == "" {
+		x.full = string(unicode.ToLower(r))
+	}
+	if x.special == "" {
+		x.special = x.full
+	}
+	return
+}
+
+func TestFoldData(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	if coreVersion == nil {
+		coreVersion = assigned
+	}
+	apply := func(r rune, f func(c *context) bool) (string, info) {
+		c := contextFromRune(r)
+		f(c)
+		return string(c.dst[:c.pDst]), c.info.cccType()
+	}
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		x := runeFoldData(r)
+		if got, info := apply(r, foldFull); got != x.full {
+			t.Errorf("full:%q (%U): got %q %U; want %q %U (ccc=%x)", r, r, got, []rune(got), x.full, []rune(x.full), info)
+		}
+		// TODO: special and simple.
+	}
+}
+
+func TestCCC(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	normVersion := rangetable.Assigned(norm.Version)
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, normVersion) {
+			continue
+		}
+		c := contextFromRune(r)
+
+		p := norm.NFC.PropertiesString(string(r))
+		want := cccOther
+		switch p.CCC() {
+		case 0:
+			want = cccZero
+		case above:
+			want = cccAbove
+		}
+		if got := c.info.cccType(); got != want {
+			t.Errorf("%U: got %x; want %x", r, got, want)
+		}
+	}
+}
+
+func TestWordBreaks(t *testing.T) {
+	for _, tt := range breakTest {
+		testtext.Run(t, tt, func(t *testing.T) {
+			parts := strings.Split(tt, "|")
+			want := ""
+			for _, s := range parts {
+				found := false
+				// This algorithm implements title casing given word breaks
+				// as defined in the Unicode standard 3.13 R3.
+				for _, r := range s {
+					title := unicode.ToTitle(r)
+					lower := unicode.ToLower(r)
+					if !found && title != lower {
+						found = true
+						want += string(title)
+					} else {
+						want += string(lower)
+					}
+				}
+			}
+			src := strings.Join(parts, "")
+			got := Title(language.Und).String(src)
+			if got != want {
+				t.Errorf("got %q; want %q", got, want)
+			}
+		})
+	}
+}
+
+func TestContext(t *testing.T) {
+	tests := []struct {
+		desc       string
+		dstSize    int
+		atEOF      bool
+		src        string
+		out        string
+		nSrc       int
+		err        error
+		ops        string
+		prefixArg  string
+		prefixWant bool
+	}{{
+		desc:    "next: past end, atEOF, no checkpoint",
+		dstSize: 10,
+		atEOF:   true,
+		src:     "12",
+		out:     "",
+		nSrc:    2,
+		ops:     "next;next;next",
+		// Test that calling prefix with a non-empty argument when the buffer
+		// is depleted returns false.
+		prefixArg:  "x",
+		prefixWant: false,
+	}, {
+		desc:       "next: not at end, atEOF, no checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "next: past end, !atEOF, no checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;next;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "next: past end, !atEOF, checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       2,
+		ops:        "next;next;checkpoint;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: exact count, atEOF, no checkpoint",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "12",
+		nSrc:       2,
+		ops:        "next;copy;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: past end, !atEOF, no checkpoint",
+		dstSize:    2,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;copy;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: past end, !atEOF, checkpoint",
+		dstSize:    2,
+		atEOF:      false,
+		src:        "12",
+		out:        "12",
+		nSrc:       2,
+		ops:        "next;copy;next;copy;checkpoint;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: short dst",
+		dstSize:    1,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;next;copy;checkpoint;next",
+		prefixArg:  "12",
+		prefixWant: false,
+	}, {
+		desc:       "copy: short dst, checkpointed",
+		dstSize:    1,
+		atEOF:      false,
+		src:        "12",
+		out:        "1",
+		nSrc:       1,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;checkpoint;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: simple",
+		dstSize:    3,
+		atEOF:      true,
+		src:        "1",
+		out:        "1ab",
+		nSrc:       1,
+		ops:        "next;copy;writeab;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: short dst",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;writeab;next",
+		prefixArg:  "2",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: simple",
+		dstSize:    3,
+		atEOF:      true,
+		src:        "12",
+		out:        "1ab",
+		nSrc:       2,
+		ops:        "next;copy;next;writeab;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: short dst",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;next;writeab;next",
+		prefixArg:  "1",
+		prefixWant: false,
+	}, {
+		desc:    "prefix",
+		dstSize: 2,
+		atEOF:   true,
+		src:     "12",
+		out:     "",
+		nSrc:    0,
+		// Context will assign an ErrShortSrc if the input wasn't exhausted.
+		err:        transform.ErrShortSrc,
+		prefixArg:  "12",
+		prefixWant: true,
+	}}
+	for _, tt := range tests {
+		c := context{dst: make([]byte, tt.dstSize), src: []byte(tt.src), atEOF: tt.atEOF}
+
+		for _, op := range strings.Split(tt.ops, ";") {
+			switch op {
+			case "next":
+				c.next()
+			case "checkpoint":
+				c.checkpoint()
+			case "writeab":
+				c.writeString("ab")
+			case "copy":
+				c.copy()
+			case "":
+			default:
+				t.Fatalf("unknown op %q", op)
+			}
+		}
+		if got := c.hasPrefix(tt.prefixArg); got != tt.prefixWant {
+			t.Errorf("%s:\nprefix was %v; want %v", tt.desc, got, tt.prefixWant)
+		}
+		nDst, nSrc, err := c.ret()
+		if err != tt.err {
+			t.Errorf("%s:\nerror was %v; want %v", tt.desc, err, tt.err)
+		}
+		if out := string(c.dst[:nDst]); out != tt.out {
+			t.Errorf("%s:\nout was %q; want %q", tt.desc, out, tt.out)
+		}
+		if nSrc != tt.nSrc {
+			t.Errorf("%s:\nnSrc was %d; want %d", tt.desc, nSrc, tt.nSrc)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/cases/example_test.go b/vendor/golang.org/x/text/cases/example_test.go
new file mode 100644
index 0000000000..56e6e33eed
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/example_test.go
@@ -0,0 +1,53 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases_test
+
+import (
+	"fmt"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+)
+
+func Example() {
+	src := []string{
+		"hello world!",
+		"i with dot",
+		"'n ijsberg",
+		"here comes O'Brian",
+	}
+	for _, c := range []cases.Caser{
+		cases.Lower(language.Und),
+		cases.Upper(language.Turkish),
+		cases.Title(language.Dutch),
+		cases.Title(language.Und, cases.NoLower),
+	} {
+		fmt.Println()
+		for _, s := range src {
+			fmt.Println(c.String(s))
+		}
+	}
+
+	// Output:
+	// hello world!
+	// i with dot
+	// 'n ijsberg
+	// here comes o'brian
+	//
+	// HELLO WORLD!
+	// İ WİTH DOT
+	// 'N İJSBERG
+	// HERE COMES O'BRİAN
+	//
+	// Hello World!
+	// I With Dot
+	// 'n IJsberg
+	// Here Comes O'brian
+	//
+	// Hello World!
+	// I With Dot
+	// 'N Ijsberg
+	// Here Comes O'Brian
+}
diff --git a/vendor/golang.org/x/text/cases/fold.go b/vendor/golang.org/x/text/cases/fold.go
new file mode 100644
index 0000000000..85cc434fac
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/fold.go
@@ -0,0 +1,34 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import "golang.org/x/text/transform"
+
+type caseFolder struct{ transform.NopResetter }
+
+// caseFolder implements the Transformer interface for doing case folding.
+func (t *caseFolder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() {
+		foldFull(&c)
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t *caseFolder) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isFoldFull(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+func makeFold(o options) transform.SpanningTransformer {
+	// TODO: Special case folding, through option Language, Special/Turkic, or
+	// both.
+	// TODO: Implement Compact options.
+	return &caseFolder{}
+}
diff --git a/vendor/golang.org/x/text/cases/fold_test.go b/vendor/golang.org/x/text/cases/fold_test.go
new file mode 100644
index 0000000000..ca939c7c16
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/fold_test.go
@@ -0,0 +1,51 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import (
+	"testing"
+
+	"golang.org/x/text/internal/testtext"
+)
+
+var foldTestCases = []string{
+	"βß\u13f8",        // "βssᏰ"
+	"ab\u13fc\uab7aꭰ", // abᏴᎪᎠ
+	"affifflast",           // affifflast
+	"Iİiı\u0345",      // ii̇iıι
+	"µµΜΜςσΣΣ",        // μμμμσσσσ
+}
+
+func TestFold(t *testing.T) {
+	for _, tc := range foldTestCases {
+		testEntry := func(name string, c Caser, m func(r rune) string) {
+			want := ""
+			for _, r := range tc {
+				want += m(r)
+			}
+			if got := c.String(tc); got != want {
+				t.Errorf("%s(%s) = %+q; want %+q", name, tc, got, want)
+			}
+			dst := make([]byte, 256) // big enough to hold any result
+			src := []byte(tc)
+			v := testtext.AllocsPerRun(20, func() {
+				c.Transform(dst, src, true)
+			})
+			if v > 0 {
+				t.Errorf("%s(%s): number of allocs was %f; want 0", name, tc, v)
+			}
+		}
+		testEntry("FullFold", Fold(), func(r rune) string {
+			return runeFoldData(r).full
+		})
+		// TODO:
+		// testEntry("SimpleFold", Fold(Compact), func(r rune) string {
+		// 	return runeFoldData(r).simple
+		// })
+		// testEntry("SpecialFold", Fold(Turkic), func(r rune) string {
+		// 	return runeFoldData(r).special
+		// })
+	}
+}
diff --git a/vendor/golang.org/x/text/cases/gotest/ya.make b/vendor/golang.org/x/text/cases/gotest/ya.make
new file mode 100644
index 0000000000..d83403a1a2
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/gotest/ya.make
@@ -0,0 +1,5 @@
+GO_TEST_FOR(vendor/golang.org/x/text/cases)
+
+LICENSE(BSD-3-Clause)
+
+END()
diff --git a/vendor/golang.org/x/text/cases/info.go b/vendor/golang.org/x/text/cases/info.go
new file mode 100644
index 0000000000..87a7c3e955
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/info.go
@@ -0,0 +1,82 @@
+// Copyright 2015 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+func (c info) cccVal() info {
+	if c&exceptionBit != 0 {
+		return info(exceptions[c>>exceptionShift]) & cccMask
+	}
+	return c & cccMask
+}
+
+func (c info) cccType() info {
+	ccc := c.cccVal()
+	if ccc <= cccZero {
+		return cccZero
+	}
+	return ccc
+}
+
+// TODO: Implement full Unicode breaking algorithm:
+// 1) Implement breaking in separate package.
+// 2) Use the breaker here.
+// 3) Compare table size and performance of using the more generic breaker.
+//
+// Note that we can extend the current algorithm to be much more accurate. This
+// only makes sense, though, if the performance and/or space penalty of using
+// the generic breaker is big. Extra data will only be needed for non-cased
+// runes, which means there are sufficient bits left in the caseType.
+// ICU prohibits breaking in such cases as well.
+
+// For the purpose of title casing we use an approximation of the Unicode Word
+// Breaking algorithm defined in Annex #29:
+// https://www.unicode.org/reports/tr29/#Default_Grapheme_Cluster_Table.
+//
+// For our approximation, we group the Word Break types into the following
+// categories, with associated rules:
+//
+// 1) Letter:
+//    ALetter, Hebrew_Letter, Numeric, ExtendNumLet, Extend, Format_FE, ZWJ.
+//    Rule: Never break between consecutive runes of this category.
+//
+// 2) Mid:
+//    MidLetter, MidNumLet, Single_Quote.
+//    (Cf. case-ignorable: MidLetter, MidNumLet, Single_Quote or cat is Mn,
+//    Me, Cf, Lm or Sk).
+//    Rule: Don't break between Letter and Mid, but break between two Mids.
+//
+// 3) Break:
+//    Any other category: NewLine, MidNum, CR, LF, Double_Quote, Katakana, and
+//    Other.
+//    These categories should always result in a break between two cased letters.
+//    Rule: Always break.
+//
+// Note 1: the Katakana and MidNum categories can, in esoteric cases, result in
+// preventing a break between two cased letters. For now we will ignore this
+// (e.g. [ALetter] [ExtendNumLet] [Katakana] [ExtendNumLet] [ALetter] and
+// [ALetter] [Numeric] [MidNum] [Numeric] [ALetter].)
+//
+// Note 2: the rule for Mid is very approximate, but works in most cases. To
+// improve, we could store the categories in the trie value and use a FA to
+// manage breaks. See TODO comment above.
+//
+// Note 3: according to the spec, it is possible for the Extend category to
+// introduce breaks between other categories grouped in Letter. However, this
+// is undesirable for our purposes. ICU prevents breaks in such cases as well.
+
+// isBreak returns whether this rune should introduce a break.
+func (c info) isBreak() bool {
+	return c.cccVal() == cccBreak
+}
+
+// isLetter returns whether the rune is of break type ALetter, Hebrew_Letter,
+// Numeric, ExtendNumLet, or Extend.
+func (c info) isLetter() bool {
+	ccc := c.cccVal()
+	if ccc == cccZero {
+		return !c.isCaseIgnorable()
+	}
+	return ccc != cccBreak
+}
diff --git a/vendor/golang.org/x/text/cases/map.go b/vendor/golang.org/x/text/cases/map.go
new file mode 100644
index 0000000000..0f7c6a14bb
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/map.go
@@ -0,0 +1,816 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+// This file contains the definitions of case mappings for all supported
+// languages. The rules for the language-specific tailorings were taken and
+// modified from the CLDR transform definitions in common/transforms.
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/internal"
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+// A mapFunc takes a context set to the current rune and writes the mapped
+// version to the same context. It may advance the context to the next rune. It
+// returns whether a checkpoint is possible: whether the pDst bytes written to
+// dst so far won't need changing as we see more source bytes.
+type mapFunc func(*context) bool
+
+// A spanFunc takes a context set to the current rune and returns whether this
+// rune would be altered when written to the output. It may advance the context
+// to the next rune. It returns whether a checkpoint is possible.
+type spanFunc func(*context) bool
+
+// maxIgnorable defines the maximum number of ignorables to consider for
+// lookahead operations.
+const maxIgnorable = 30
+
+// supported lists the language tags for which we have tailorings.
+const supported = "und af az el lt nl tr"
+
+func init() {
+	tags := []language.Tag{}
+	for _, s := range strings.Split(supported, " ") {
+		tags = append(tags, language.MustParse(s))
+	}
+	matcher = internal.NewInheritanceMatcher(tags)
+	Supported = language.NewCoverage(tags)
+}
+
+var (
+	matcher *internal.InheritanceMatcher
+
+	Supported language.Coverage
+
+	// We keep the following lists separate, instead of having a single per-
+	// language struct, to give the compiler a chance to remove unused code.
+
+	// Some uppercase mappers are stateless, so we can precompute the
+	// Transformers and save a bit on runtime allocations.
+	upperFunc = []struct {
+		upper mapFunc
+		span  spanFunc
+	}{
+		{nil, nil},                  // und
+		{nil, nil},                  // af
+		{aztrUpper(upper), isUpper}, // az
+		{elUpper, noSpan},           // el
+		{ltUpper(upper), noSpan},    // lt
+		{nil, nil},                  // nl
+		{aztrUpper(upper), isUpper}, // tr
+	}
+
+	undUpper            transform.SpanningTransformer = &undUpperCaser{}
+	undLower            transform.SpanningTransformer = &undLowerCaser{}
+	undLowerIgnoreSigma transform.SpanningTransformer = &undLowerIgnoreSigmaCaser{}
+
+	lowerFunc = []mapFunc{
+		nil,       // und
+		nil,       // af
+		aztrLower, // az
+		nil,       // el
+		ltLower,   // lt
+		nil,       // nl
+		aztrLower, // tr
+	}
+
+	titleInfos = []struct {
+		title     mapFunc
+		lower     mapFunc
+		titleSpan spanFunc
+		rewrite   func(*context)
+	}{
+		{title, lower, isTitle, nil},                // und
+		{title, lower, isTitle, afnlRewrite},        // af
+		{aztrUpper(title), aztrLower, isTitle, nil}, // az
+		{title, lower, isTitle, nil},                // el
+		{ltUpper(title), ltLower, noSpan, nil},      // lt
+		{nlTitle, lower, nlTitleSpan, afnlRewrite},  // nl
+		{aztrUpper(title), aztrLower, isTitle, nil}, // tr
+	}
+)
+
+func makeUpper(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	f := upperFunc[i].upper
+	if f == nil {
+		return undUpper
+	}
+	return &simpleCaser{f: f, span: upperFunc[i].span}
+}
+
+func makeLower(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	f := lowerFunc[i]
+	if f == nil {
+		if o.ignoreFinalSigma {
+			return undLowerIgnoreSigma
+		}
+		return undLower
+	}
+	if o.ignoreFinalSigma {
+		return &simpleCaser{f: f, span: isLower}
+	}
+	return &lowerCaser{
+		first:   f,
+		midWord: finalSigma(f),
+	}
+}
+
+func makeTitle(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	x := &titleInfos[i]
+	lower := x.lower
+	if o.noLower {
+		lower = (*context).copy
+	} else if !o.ignoreFinalSigma {
+		lower = finalSigma(lower)
+	}
+	return &titleCaser{
+		title:     x.title,
+		lower:     lower,
+		titleSpan: x.titleSpan,
+		rewrite:   x.rewrite,
+	}
+}
+
+func noSpan(c *context) bool {
+	c.err = transform.ErrEndOfSpan
+	return false
+}
+
+// TODO: consider a similar special case for the fast majority lower case. This
+// is a bit more involved so will require some more precise benchmarking to
+// justify it.
+
+type undUpperCaser struct{ transform.NopResetter }
+
+// undUpperCaser implements the Transformer interface for doing an upper case
+// mapping for the root locale (und). It eliminates the need for an allocation
+// as it prevents escaping by not using function pointers.
+func (t undUpperCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() {
+		upper(&c)
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t undUpperCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isUpper(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// undLowerIgnoreSigmaCaser implements the Transformer interface for doing
+// a lower case mapping for the root locale (und) ignoring final sigma
+// handling. This casing algorithm is used in some performance-critical packages
+// like secure/precis and x/net/http/idna, which warrants its special-casing.
+type undLowerIgnoreSigmaCaser struct{ transform.NopResetter }
+
+func (t undLowerIgnoreSigmaCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() && lower(&c) {
+		c.checkpoint()
+	}
+	return c.ret()
+
+}
+
+// Span implements a generic lower-casing. This is possible as isLower works
+// for all lowercasing variants. All lowercase variants only vary in how they
+// transform a non-lowercase letter. They will never change an already lowercase
+// letter. In addition, there is no state.
+func (t undLowerIgnoreSigmaCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isLower(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+type simpleCaser struct {
+	context
+	f    mapFunc
+	span spanFunc
+}
+
+// simpleCaser implements the Transformer interface for doing a case operation
+// on a rune-by-rune basis.
+func (t *simpleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() && t.f(&c) {
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t *simpleCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && t.span(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// undLowerCaser implements the Transformer interface for doing a lower case
+// mapping for the root locale (und) ignoring final sigma handling. This casing
+// algorithm is used in some performance-critical packages like secure/precis
+// and x/net/http/idna, which warrants its special-casing.
+type undLowerCaser struct{ transform.NopResetter }
+
+func (t undLowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+
+	for isInterWord := true; c.next(); {
+		if isInterWord {
+			if c.info.isCased() {
+				if !lower(&c) {
+					break
+				}
+				isInterWord = false
+			} else if !c.copy() {
+				break
+			}
+		} else {
+			if c.info.isNotCasedAndNotCaseIgnorable() {
+				if !c.copy() {
+					break
+				}
+				isInterWord = true
+			} else if !c.hasPrefix("Σ") {
+				if !lower(&c) {
+					break
+				}
+			} else if !finalSigmaBody(&c) {
+				break
+			}
+		}
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t undLowerCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isLower(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// lowerCaser implements the Transformer interface. The default Unicode lower
+// casing requires different treatment for the first and subsequent characters
+// of a word, most notably to handle the Greek final Sigma.
+type lowerCaser struct {
+	undLowerIgnoreSigmaCaser
+
+	context
+
+	first, midWord mapFunc
+}
+
+func (t *lowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	t.context = context{dst: dst, src: src, atEOF: atEOF}
+	c := &t.context
+
+	for isInterWord := true; c.next(); {
+		if isInterWord {
+			if c.info.isCased() {
+				if !t.first(c) {
+					break
+				}
+				isInterWord = false
+			} else if !c.copy() {
+				break
+			}
+		} else {
+			if c.info.isNotCasedAndNotCaseIgnorable() {
+				if !c.copy() {
+					break
+				}
+				isInterWord = true
+			} else if !t.midWord(c) {
+				break
+			}
+		}
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+// titleCaser implements the Transformer interface. Title casing algorithms
+// distinguish between the first letter of a word and subsequent letters of the
+// same word. It uses state to avoid requiring a potentially infinite lookahead.
+type titleCaser struct {
+	context
+
+	// rune mappings used by the actual casing algorithms.
+	title     mapFunc
+	lower     mapFunc
+	titleSpan spanFunc
+
+	rewrite func(*context)
+}
+
+// Transform implements the standard Unicode title case algorithm as defined in
+// Chapter 3 of The Unicode Standard:
+// toTitlecase(X): Find the word boundaries in X according to Unicode Standard
+// Annex #29, "Unicode Text Segmentation." For each word boundary, find the
+// first cased character F following the word boundary. If F exists, map F to
+// Titlecase_Mapping(F); then map all characters C between F and the following
+// word boundary to Lowercase_Mapping(C).
+func (t *titleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	t.context = context{dst: dst, src: src, atEOF: atEOF, isMidWord: t.isMidWord}
+	c := &t.context
+
+	if !c.next() {
+		return c.ret()
+	}
+
+	for {
+		p := c.info
+		if t.rewrite != nil {
+			t.rewrite(c)
+		}
+
+		wasMid := p.isMid()
+		// Break out of this loop on failure to ensure we do not modify the
+		// state incorrectly.
+		if p.isCased() {
+			if !c.isMidWord {
+				if !t.title(c) {
+					break
+				}
+				c.isMidWord = true
+			} else if !t.lower(c) {
+				break
+			}
+		} else if !c.copy() {
+			break
+		} else if p.isBreak() {
+			c.isMidWord = false
+		}
+
+		// As we save the state of the transformer, it is safe to call
+		// checkpoint after any successful write.
+		if !(c.isMidWord && wasMid) {
+			c.checkpoint()
+		}
+
+		if !c.next() {
+			break
+		}
+		if wasMid && c.info.isMid() {
+			c.isMidWord = false
+		}
+	}
+	return c.ret()
+}
+
+func (t *titleCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	t.context = context{src: src, atEOF: atEOF, isMidWord: t.isMidWord}
+	c := &t.context
+
+	if !c.next() {
+		return c.retSpan()
+	}
+
+	for {
+		p := c.info
+		if t.rewrite != nil {
+			t.rewrite(c)
+		}
+
+		wasMid := p.isMid()
+		// Break out of this loop on failure to ensure we do not modify the
+		// state incorrectly.
+		if p.isCased() {
+			if !c.isMidWord {
+				if !t.titleSpan(c) {
+					break
+				}
+				c.isMidWord = true
+			} else if !isLower(c) {
+				break
+			}
+		} else if p.isBreak() {
+			c.isMidWord = false
+		}
+		// As we save the state of the transformer, it is safe to call
+		// checkpoint after any successful write.
+		if !(c.isMidWord && wasMid) {
+			c.checkpoint()
+		}
+
+		if !c.next() {
+			break
+		}
+		if wasMid && c.info.isMid() {
+			c.isMidWord = false
+		}
+	}
+	return c.retSpan()
+}
+
+// finalSigma adds Greek final Sigma handing to another casing function. It
+// determines whether a lowercased sigma should be σ or ς, by looking ahead for
+// case-ignorables and a cased letters.
+func finalSigma(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		if !c.hasPrefix("Σ") {
+			return f(c)
+		}
+		return finalSigmaBody(c)
+	}
+}
+
+func finalSigmaBody(c *context) bool {
+	// Current rune must be ∑.
+
+	// ::NFD();
+	// # 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
+	// Σ } [:case-ignorable:]* [:cased:] → σ;
+	// [:cased:] [:case-ignorable:]* { Σ → ς;
+	// ::Any-Lower;
+	// ::NFC();
+
+	p := c.pDst
+	c.writeString("ς")
+
+	// TODO: we should do this here, but right now this will never have an
+	// effect as this is called when the prefix is Sigma, whereas Dutch and
+	// Afrikaans only test for an apostrophe.
+	//
+	// if t.rewrite != nil {
+	// 	t.rewrite(c)
+	// }
+
+	// We need to do one more iteration after maxIgnorable, as a cased
+	// letter is not an ignorable and may modify the result.
+	wasMid := false
+	for i := 0; i < maxIgnorable+1; i++ {
+		if !c.next() {
+			return false
+		}
+		if !c.info.isCaseIgnorable() {
+			// All Midword runes are also case ignorable, so we are
+			// guaranteed to have a letter or word break here. As we are
+			// unreading the run, there is no need to unset c.isMidWord;
+			// the title caser will handle this.
+			if c.info.isCased() {
+				// p+1 is guaranteed to be in bounds: if writing ς was
+				// successful, p+1 will contain the second byte of ς. If not,
+				// this function will have returned after c.next returned false.
+				c.dst[p+1]++ // ς → σ
+			}
+			c.unreadRune()
+			return true
+		}
+		// A case ignorable may also introduce a word break, so we may need
+		// to continue searching even after detecting a break.
+		isMid := c.info.isMid()
+		if (wasMid && isMid) || c.info.isBreak() {
+			c.isMidWord = false
+		}
+		wasMid = isMid
+		c.copy()
+	}
+	return true
+}
+
+// finalSigmaSpan would be the same as isLower.
+
+// elUpper implements Greek upper casing, which entails removing a predefined
+// set of non-blocked modifiers. Note that these accents should not be removed
+// for title casing!
+// Example: "Οδός" -> "ΟΔΟΣ".
+func elUpper(c *context) bool {
+	// From CLDR:
+	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Above:]]*? { [\u0313\u0314\u0301\u0300\u0306\u0342\u0308\u0304] → ;
+	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Iota_Subscript:]]*? { \u0345 → ;
+
+	r, _ := utf8.DecodeRune(c.src[c.pSrc:])
+	oldPDst := c.pDst
+	if !upper(c) {
+		return false
+	}
+	if !unicode.Is(unicode.Greek, r) {
+		return true
+	}
+	i := 0
+	// Take the properties of the uppercased rune that is already written to the
+	// destination. This saves us the trouble of having to uppercase the
+	// decomposed rune again.
+	if b := norm.NFD.Properties(c.dst[oldPDst:]).Decomposition(); b != nil {
+		// Restore the destination position and process the decomposed rune.
+		r, sz := utf8.DecodeRune(b)
+		if r <= 0xFF { // See A.6.1
+			return true
+		}
+		c.pDst = oldPDst
+		// Insert the first rune and ignore the modifiers. See A.6.2.
+		c.writeBytes(b[:sz])
+		i = len(b[sz:]) / 2 // Greek modifiers are always of length 2.
+	}
+
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch r, _ := utf8.DecodeRune(c.src[c.pSrc:]); r {
+		// Above and Iota Subscript
+		case 0x0300, // U+0300 COMBINING GRAVE ACCENT
+			0x0301, // U+0301 COMBINING ACUTE ACCENT
+			0x0304, // U+0304 COMBINING MACRON
+			0x0306, // U+0306 COMBINING BREVE
+			0x0308, // U+0308 COMBINING DIAERESIS
+			0x0313, // U+0313 COMBINING COMMA ABOVE
+			0x0314, // U+0314 COMBINING REVERSED COMMA ABOVE
+			0x0342, // U+0342 COMBINING GREEK PERISPOMENI
+			0x0345: // U+0345 COMBINING GREEK YPOGEGRAMMENI
+			// No-op. Gobble the modifier.
+
+		default:
+			switch v, _ := trie.lookup(c.src[c.pSrc:]); info(v).cccType() {
+			case cccZero:
+				c.unreadRune()
+				return true
+
+			// We don't need to test for IotaSubscript as the only rune that
+			// qualifies (U+0345) was already excluded in the switch statement
+			// above. See A.4.
+
+			case cccAbove:
+				return c.copy()
+			default:
+				// Some other modifier. We're still allowed to gobble Greek
+				// modifiers after this.
+				c.copy()
+			}
+		}
+	}
+	return i == maxIgnorable
+}
+
+// TODO: implement elUpperSpan (low-priority: complex and infrequent).
+
+func ltLower(c *context) bool {
+	// From CLDR:
+	// # Introduce an explicit dot above when lowercasing capital I's and J's
+	// # whenever there are more accents above.
+	// # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
+	// # 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
+	// # 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
+	// # 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
+	// # 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
+	// # 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
+	// # 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
+	// ::NFD();
+	// I } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0307;
+	// J } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → j \u0307;
+	// I \u0328 (Į) } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0328 \u0307;
+	// I \u0300 (Ì) → i \u0307 \u0300;
+	// I \u0301 (Í) → i \u0307 \u0301;
+	// I \u0303 (Ĩ) → i \u0307 \u0303;
+	// ::Any-Lower();
+	// ::NFC();
+
+	i := 0
+	if r := c.src[c.pSrc]; r < utf8.RuneSelf {
+		lower(c)
+		if r != 'I' && r != 'J' {
+			return true
+		}
+	} else {
+		p := norm.NFD.Properties(c.src[c.pSrc:])
+		if d := p.Decomposition(); len(d) >= 3 && (d[0] == 'I' || d[0] == 'J') {
+			// UTF-8 optimization: the decomposition will only have an above
+			// modifier if the last rune of the decomposition is in [U+300-U+311].
+			// In all other cases, a decomposition starting with I is always
+			// an I followed by modifiers that are not cased themselves. See A.2.
+			if d[1] == 0xCC && d[2] <= 0x91 { // A.2.4.
+				if !c.writeBytes(d[:1]) {
+					return false
+				}
+				c.dst[c.pDst-1] += 'a' - 'A' // lower
+
+				// Assumption: modifier never changes on lowercase. See A.1.
+				// Assumption: all modifiers added have CCC = Above. See A.2.3.
+				return c.writeString("\u0307") && c.writeBytes(d[1:])
+			}
+			// In all other cases the additional modifiers will have a CCC
+			// that is less than 230 (Above). We will insert the U+0307, if
+			// needed, after these modifiers so that a string in FCD form
+			// will remain so. See A.2.2.
+			lower(c)
+			i = 1
+		} else {
+			return lower(c)
+		}
+	}
+
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch c.info.cccType() {
+		case cccZero:
+			c.unreadRune()
+			return true
+		case cccAbove:
+			return c.writeString("\u0307") && c.copy() // See A.1.
+		default:
+			c.copy() // See A.1.
+		}
+	}
+	return i == maxIgnorable
+}
+
+// ltLowerSpan would be the same as isLower.
+
+func ltUpper(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		// Unicode:
+		// 0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
+		//
+		// From CLDR:
+		// # Remove \u0307 following soft-dotteds (i, j, and the like), with possible
+		// # intervening non-230 marks.
+		// ::NFD();
+		// [:Soft_Dotted:] [^[:ccc=Not_Reordered:][:ccc=Above:]]* { \u0307 → ;
+		// ::Any-Upper();
+		// ::NFC();
+
+		// TODO: See A.5. A soft-dotted rune never has an exception. This would
+		// allow us to overload the exception bit and encode this property in
+		// info. Need to measure performance impact of this.
+		r, _ := utf8.DecodeRune(c.src[c.pSrc:])
+		oldPDst := c.pDst
+		if !f(c) {
+			return false
+		}
+		if !unicode.Is(unicode.Soft_Dotted, r) {
+			return true
+		}
+
+		// We don't need to do an NFD normalization, as a soft-dotted rune never
+		// contains U+0307. See A.3.
+
+		i := 0
+		for ; i < maxIgnorable && c.next(); i++ {
+			switch c.info.cccType() {
+			case cccZero:
+				c.unreadRune()
+				return true
+			case cccAbove:
+				if c.hasPrefix("\u0307") {
+					// We don't do a full NFC, but rather combine runes for
+					// some of the common cases. (Returning NFC or
+					// preserving normal form is neither a requirement nor
+					// a possibility anyway).
+					if !c.next() {
+						return false
+					}
+					if c.dst[oldPDst] == 'I' && c.pDst == oldPDst+1 && c.src[c.pSrc] == 0xcc {
+						s := ""
+						switch c.src[c.pSrc+1] {
+						case 0x80: // U+0300 COMBINING GRAVE ACCENT
+							s = "\u00cc" // U+00CC LATIN CAPITAL LETTER I WITH GRAVE
+						case 0x81: // U+0301 COMBINING ACUTE ACCENT
+							s = "\u00cd" // U+00CD LATIN CAPITAL LETTER I WITH ACUTE
+						case 0x83: // U+0303 COMBINING TILDE
+							s = "\u0128" // U+0128 LATIN CAPITAL LETTER I WITH TILDE
+						case 0x88: // U+0308 COMBINING DIAERESIS
+							s = "\u00cf" // U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS
+						default:
+						}
+						if s != "" {
+							c.pDst = oldPDst
+							return c.writeString(s)
+						}
+					}
+				}
+				return c.copy()
+			default:
+				c.copy()
+			}
+		}
+		return i == maxIgnorable
+	}
+}
+
+// TODO: implement ltUpperSpan (low priority: complex and infrequent).
+
+func aztrUpper(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		// i→İ;
+		if c.src[c.pSrc] == 'i' {
+			return c.writeString("İ")
+		}
+		return f(c)
+	}
+}
+
+func aztrLower(c *context) (done bool) {
+	// From CLDR:
+	// # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
+	// # 0130; 0069; 0130; 0130; tr; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+	// İ→i;
+	// # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
+	// # This matches the behavior of the canonically equivalent I-dot_above
+	// # 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
+	// # When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
+	// # 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
+	// I([^[:ccc=Not_Reordered:][:ccc=Above:]]*)\u0307 → i$1 ;
+	// I→ı ;
+	// ::Any-Lower();
+	if c.hasPrefix("\u0130") { // İ
+		return c.writeString("i")
+	}
+	if c.src[c.pSrc] != 'I' {
+		return lower(c)
+	}
+
+	// We ignore the lower-case I for now, but insert it later when we know
+	// which form we need.
+	start := c.pSrc + c.sz
+
+	i := 0
+Loop:
+	// We check for up to n ignorables before \u0307. As \u0307 is an
+	// ignorable as well, n is maxIgnorable-1.
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch c.info.cccType() {
+		case cccAbove:
+			if c.hasPrefix("\u0307") {
+				return c.writeString("i") && c.writeBytes(c.src[start:c.pSrc]) // ignore U+0307
+			}
+			done = true
+			break Loop
+		case cccZero:
+			c.unreadRune()
+			done = true
+			break Loop
+		default:
+			// We'll write this rune after we know which starter to use.
+		}
+	}
+	if i == maxIgnorable {
+		done = true
+	}
+	return c.writeString("ı") && c.writeBytes(c.src[start:c.pSrc+c.sz]) && done
+}
+
+// aztrLowerSpan would be the same as isLower.
+
+func nlTitle(c *context) bool {
+	// From CLDR:
+	// # Special titlecasing for Dutch initial "ij".
+	// ::Any-Title();
+	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
+	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
+	if c.src[c.pSrc] != 'I' && c.src[c.pSrc] != 'i' {
+		return title(c)
+	}
+
+	if !c.writeString("I") || !c.next() {
+		return false
+	}
+	if c.src[c.pSrc] == 'j' || c.src[c.pSrc] == 'J' {
+		return c.writeString("J")
+	}
+	c.unreadRune()
+	return true
+}
+
+func nlTitleSpan(c *context) bool {
+	// From CLDR:
+	// # Special titlecasing for Dutch initial "ij".
+	// ::Any-Title();
+	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
+	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
+	if c.src[c.pSrc] != 'I' {
+		return isTitle(c)
+	}
+	if !c.next() || c.src[c.pSrc] == 'j' {
+		return false
+	}
+	if c.src[c.pSrc] != 'J' {
+		c.unreadRune()
+	}
+	return true
+}
+
+// Not part of CLDR, but see https://unicode.org/cldr/trac/ticket/7078.
+func afnlRewrite(c *context) {
+	if c.hasPrefix("'") || c.hasPrefix("’") {
+		c.isMidWord = true
+	}
+}
diff --git a/vendor/golang.org/x/text/cases/map_test.go b/vendor/golang.org/x/text/cases/map_test.go
new file mode 100644
index 0000000000..8cfb89e599
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/map_test.go
@@ -0,0 +1,950 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import (
+	"bytes"
+	"fmt"
+	"path"
+	"strings"
+	"testing"
+	"unicode/utf8"
+
+	"golang.org/x/text/internal/testtext"
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+type testCase struct {
+	lang  string
+	src   interface{} // string, []string, or nil to skip test
+	title interface{} // string, []string, or nil to skip test
+	lower interface{} // string, []string, or nil to skip test
+	upper interface{} // string, []string, or nil to skip test
+	opts  options
+}
+
+var testCases = []testCase{
+	0: {
+		lang:  "und",
+		src:   "abc aBc ABC abC İsıI ΕΣΆΣ",
+		title: "Abc Abc Abc Abc İsıi Εσάσ",
+		lower: "abc abc abc abc i\u0307sıi εσάσ",
+		upper: "ABC ABC ABC ABC İSII ΕΣΆΣ",
+		opts:  getOpts(HandleFinalSigma(false)),
+	},
+
+	1: {
+		lang:  "und",
+		src:   "abc aBc ABC abC İsıI ΕΣΆΣ Σ _Σ -Σ",
+		title: "Abc Abc Abc Abc İsıi Εσάς Σ _Σ -Σ",
+		lower: "abc abc abc abc i\u0307sıi εσάς σ _σ -σ",
+		upper: "ABC ABC ABC ABC İSII ΕΣΆΣ Σ _Σ -Σ",
+		opts:  getOpts(HandleFinalSigma(true)),
+	},
+
+	2: { // Title cased runes.
+		lang:  supported,
+		src:   "DžA",
+		title: "Dža",
+		lower: "dža",
+		upper: "DŽA",
+	},
+
+	3: {
+		// Title breaking.
+		lang: supported,
+		src: []string{
+			"FOO CASE TEST",
+			"DON'T DO THiS",
+			"χωΡΊΣ χωΡΊΣ^a χωΡΊΣ:a χωΡΊΣ:^a χωΡΊΣ^ όμΩΣ Σ",
+			"with-hyphens",
+			"49ers 49ers",
+			`"capitalize a^a -hyphen 0X _u a_u:a`,
+			"MidNumLet a.b\u2018c\u2019d\u2024e\ufe52f\uff07f\uff0eg",
+			"MidNum a,b;c\u037ed\u0589e\u060cf\u2044g\ufe50h",
+			"\u0345 x\u3031x x\u05d0x \u05d0x a'.a a.a a4,a",
+		},
+		title: []string{
+			"Foo Case Test",
+			"Don't Do This",
+			"Χωρίς Χωρίσ^A Χωρίσ:a Χωρίσ:^A Χωρίς^ Όμως Σ",
+			"With-Hyphens",
+			// Note that 49Ers is correct according to the spec.
+			// TODO: provide some option to the user to treat different
+			// characters as cased.
+			"49Ers 49Ers",
+			`"Capitalize A^A -Hyphen 0X _U A_u:a`,
+			"Midnumlet A.b\u2018c\u2019d\u2024e\ufe52f\uff07f\uff0eg",
+			"Midnum A,B;C\u037eD\u0589E\u060cF\u2044G\ufe50H",
+			"\u0399 X\u3031X X\u05d0x \u05d0X A'.A A.a A4,A",
+		},
+	},
+
+	// TODO: These are known deviations from the options{} Unicode Word Breaking
+	// Algorithm.
+	// {
+	// 	"und",
+	// 	"x_\u3031_x a4,4a",
+	// 	"X_\u3031_x A4,4a", // Currently is "X_\U3031_X A4,4A".
+	// 	"x_\u3031_x a4,4a",
+	// 	"X_\u3031_X A4,4A",
+	// 	options{},
+	// },
+
+	4: {
+		// Tests title options
+		lang:  "und",
+		src:   "abc aBc ABC abC İsıI o'Brien",
+		title: "Abc ABc ABC AbC İsıI O'Brien",
+		opts:  getOpts(NoLower),
+	},
+
+	5: {
+		lang:  "el",
+		src:   "aBc ΟΔΌΣ Οδός Σο ΣΟ Σ oΣ ΟΣ σ ἕξ \u03ac",
+		title: "Abc Οδός Οδός Σο Σο Σ Oς Ος Σ Ἕξ \u0386",
+		lower: "abc οδός οδός σο σο σ oς ος σ ἕξ \u03ac",
+		upper: "ABC ΟΔΟΣ ΟΔΟΣ ΣΟ ΣΟ Σ OΣ ΟΣ Σ ΕΞ \u0391", // Uppercase removes accents
+	},
+
+	6: {
+		lang:  "tr az",
+		src:   "Isiİ İsıI I\u0307sIiİ İsıI\u0307 I\u0300\u0307",
+		title: "Isii İsıı I\u0307sıii İsıi I\u0300\u0307",
+		lower: "ısii isıı isıii isıi \u0131\u0300\u0307",
+		upper: "ISİİ İSII I\u0307SIİİ İSII\u0307 I\u0300\u0307",
+	},
+
+	7: {
+		lang:  "lt",
+		src:   "I Ï J J̈ Į Į̈ Ì Í Ĩ xi̇̈ xj̇̈ xį̇̈ xi̇̀ xi̇́ xi̇̃ XI XÏ XJ XJ̈ XĮ XĮ̈ XI̟̤",
+		title: "I Ï J J̈ Į Į̈ Ì Í Ĩ Xi̇̈ Xj̇̈ Xį̇̈ Xi̇̀ Xi̇́ Xi̇̃ Xi Xi̇̈ Xj Xj̇̈ Xį Xį̇̈ Xi̟̤",
+		lower: "i i̇̈ j j̇̈ į į̇̈ i̇̀ i̇́ i̇̃ xi̇̈ xj̇̈ xį̇̈ xi̇̀ xi̇́ xi̇̃ xi xi̇̈ xj xj̇̈ xį xį̇̈ xi̟̤",
+		upper: "I Ï J J̈ Į Į̈ Ì Í Ĩ XÏ XJ̈ XĮ̈ XÌ XÍ XĨ XI XÏ XJ XJ̈ XĮ XĮ̈ XI̟̤",
+	},
+
+	8: {
+		lang:  "lt",
+		src:   "\u012e\u0300 \u00cc i\u0307\u0300 i\u0307\u0301 i\u0307\u0303 i\u0307\u0308 i\u0300\u0307",
+		title: "\u012e\u0300 \u00cc \u00cc \u00cd \u0128 \u00cf I\u0300\u0307",
+		lower: "\u012f\u0307\u0300 i\u0307\u0300 i\u0307\u0300 i\u0307\u0301 i\u0307\u0303 i\u0307\u0308 i\u0300\u0307",
+		upper: "\u012e\u0300 \u00cc \u00cc \u00cd \u0128 \u00cf I\u0300\u0307",
+	},
+
+	9: {
+		lang:  "nl",
+		src:   "ijs IJs Ij Ijs İJ İJs aa aA 'ns 'S",
+		title: "IJs IJs IJ IJs İj İjs Aa Aa 'ns 's",
+	},
+
+	// Note: this specification is not currently part of CLDR. The same holds
+	// for the leading apostrophe handling for Dutch.
+	// See https://unicode.org/cldr/trac/ticket/7078.
+	10: {
+		lang:  "af",
+		src:   "wag 'n bietjie",
+		title: "Wag 'n Bietjie",
+		lower: "wag 'n bietjie",
+		upper: "WAG 'N BIETJIE",
+	},
+}
+
+func TestCaseMappings(t *testing.T) {
+	for i, tt := range testCases {
+		src, ok := tt.src.([]string)
+		if !ok {
+			src = strings.Split(tt.src.(string), " ")
+		}
+
+		for _, lang := range strings.Split(tt.lang, " ") {
+			tag := language.MustParse(lang)
+			testEntry := func(name string, mk func(language.Tag, options) transform.SpanningTransformer, gold interface{}) {
+				c := Caser{mk(tag, tt.opts)}
+				if gold != nil {
+					wants, ok := gold.([]string)
+					if !ok {
+						wants = strings.Split(gold.(string), " ")
+					}
+					for j, want := range wants {
+						if got := c.String(src[j]); got != want {
+							t.Errorf("%d:%s:\n%s.String(%+q):\ngot  %+q;\nwant %+q", i, lang, name, src[j], got, want)
+						}
+					}
+				}
+				dst := make([]byte, 256) // big enough to hold any result
+				src := []byte(strings.Join(src, " "))
+				v := testtext.AllocsPerRun(20, func() {
+					c.Transform(dst, src, true)
+				})
+				if v > 1.1 {
+					t.Errorf("%d:%s:\n%s: number of allocs was %f; want 0", i, lang, name, v)
+				}
+			}
+			testEntry("Upper", makeUpper, tt.upper)
+			testEntry("Lower", makeLower, tt.lower)
+			testEntry("Title", makeTitle, tt.title)
+		}
+	}
+}
+
+// TestAlloc tests that some mapping methods should not cause any allocation.
+func TestAlloc(t *testing.T) {
+	dst := make([]byte, 256) // big enough to hold any result
+	src := []byte(txtNonASCII)
+
+	for i, f := range []func() Caser{
+		func() Caser { return Upper(language.Und) },
+		func() Caser { return Lower(language.Und) },
+		func() Caser { return Lower(language.Und, HandleFinalSigma(false)) },
+		// TODO: use a shared copy for these casers as well, in order of
+		// importance, starting with the most important:
+		// func() Caser { return Title(language.Und) },
+		// func() Caser { return Title(language.Und, HandleFinalSigma(false)) },
+	} {
+		testtext.Run(t, "", func(t *testing.T) {
+			var c Caser
+			v := testtext.AllocsPerRun(10, func() {
+				c = f()
+			})
+			if v > 0 {
+				// TODO: Right now only Upper has 1 allocation. Special-case Lower
+				// and Title as well to have less allocations for the root locale.
+				t.Errorf("%d:init: number of allocs was %f; want 0", i, v)
+			}
+			v = testtext.AllocsPerRun(2, func() {
+				c.Transform(dst, src, true)
+			})
+			if v > 0 {
+				t.Errorf("%d:transform: number of allocs was %f; want 0", i, v)
+			}
+		})
+	}
+}
+
+func testHandover(t *testing.T, c Caser, src string) {
+	want := c.String(src)
+	// Find the common prefix.
+	pSrc := 0
+	for ; pSrc < len(src) && pSrc < len(want) && want[pSrc] == src[pSrc]; pSrc++ {
+	}
+
+	// Test handover for each substring of the prefix.
+	for i := 0; i < pSrc; i++ {
+		testtext.Run(t, fmt.Sprint("interleave/", i), func(t *testing.T) {
+			dst := make([]byte, 4*len(src))
+			c.Reset()
+			nSpan, _ := c.Span([]byte(src[:i]), false)
+			copy(dst, src[:nSpan])
+			nTransform, _, _ := c.Transform(dst[nSpan:], []byte(src[nSpan:]), true)
+			got := string(dst[:nSpan+nTransform])
+			if got != want {
+				t.Errorf("full string: got %q; want %q", got, want)
+			}
+		})
+	}
+}
+
+func TestHandover(t *testing.T) {
+	testCases := []struct {
+		desc          string
+		t             Caser
+		first, second string
+	}{{
+		"title/nosigma/single midword",
+		Title(language.Und, HandleFinalSigma(false)),
+		"A.", "a",
+	}, {
+		"title/nosigma/single midword",
+		Title(language.Und, HandleFinalSigma(false)),
+		"A", ".a",
+	}, {
+		"title/nosigma/double midword",
+		Title(language.Und, HandleFinalSigma(false)),
+		"A..", "a",
+	}, {
+		"title/nosigma/double midword",
+		Title(language.Und, HandleFinalSigma(false)),
+		"A.", ".a",
+	}, {
+		"title/nosigma/double midword",
+		Title(language.Und, HandleFinalSigma(false)),
+		"A", "..a",
+	}, {
+		"title/sigma/single midword",
+		Title(language.Und),
+		"ΟΣ.", "a",
+	}, {
+		"title/sigma/single midword",
+		Title(language.Und),
+		"ΟΣ", ".a",
+	}, {
+		"title/sigma/double midword",
+		Title(language.Und),
+		"ΟΣ..", "a",
+	}, {
+		"title/sigma/double midword",
+		Title(language.Und),
+		"ΟΣ.", ".a",
+	}, {
+		"title/sigma/double midword",
+		Title(language.Und),
+		"ΟΣ", "..a",
+	}, {
+		"title/af/leading apostrophe",
+		Title(language.Afrikaans),
+		"'", "n bietje",
+	}}
+	for _, tc := range testCases {
+		testtext.Run(t, tc.desc, func(t *testing.T) {
+			src := tc.first + tc.second
+			want := tc.t.String(src)
+			tc.t.Reset()
+			n, _ := tc.t.Span([]byte(tc.first), false)
+
+			dst := make([]byte, len(want))
+			copy(dst, tc.first[:n])
+
+			nDst, _, _ := tc.t.Transform(dst[n:], []byte(src[n:]), true)
+			got := string(dst[:n+nDst])
+			if got != want {
+				t.Errorf("got %q; want %q", got, want)
+			}
+		})
+	}
+}
+
+// minBufSize is the size of the buffer by which the casing operation in
+// this package are guaranteed to make progress.
+const minBufSize = norm.MaxSegmentSize
+
+type bufferTest struct {
+	desc, src, want  string
+	firstErr         error
+	dstSize, srcSize int
+	t                transform.SpanningTransformer
+}
+
+var bufferTests []bufferTest
+
+func init() {
+	bufferTests = []bufferTest{{
+		desc:     "und/upper/short dst",
+		src:      "abcdefg",
+		want:     "ABCDEFG",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Upper(language.Und),
+	}, {
+		desc:     "und/upper/short src",
+		src:      "123é56",
+		want:     "123É56",
+		firstErr: transform.ErrShortSrc,
+		dstSize:  4,
+		srcSize:  4,
+		t:        Upper(language.Und),
+	}, {
+		desc:     "und/upper/no error on short",
+		src:      "12",
+		want:     "12",
+		firstErr: nil,
+		dstSize:  1,
+		srcSize:  1,
+		t:        Upper(language.Und),
+	}, {
+		desc:     "und/lower/short dst",
+		src:      "ABCDEFG",
+		want:     "abcdefg",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Lower(language.Und),
+	}, {
+		desc:     "und/lower/short src",
+		src:      "123É56",
+		want:     "123é56",
+		firstErr: transform.ErrShortSrc,
+		dstSize:  4,
+		srcSize:  4,
+		t:        Lower(language.Und),
+	}, {
+		desc:     "und/lower/no error on short",
+		src:      "12",
+		want:     "12",
+		firstErr: nil,
+		dstSize:  1,
+		srcSize:  1,
+		t:        Lower(language.Und),
+	}, {
+		desc:    "und/lower/simple (no final sigma)",
+		src:     "ΟΣ ΟΣΣ",
+		want:    "οσ οσσ",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Lower(language.Und, HandleFinalSigma(false)),
+	}, {
+		desc:    "und/title/simple (no final sigma)",
+		src:     "ΟΣ ΟΣΣ",
+		want:    "Οσ Οσσ",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Title(language.Und, HandleFinalSigma(false)),
+	}, {
+		desc:    "und/title/final sigma: no error",
+		src:     "ΟΣ",
+		want:    "Ος",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Title(language.Und),
+	}, {
+		desc:     "und/title/final sigma: short source",
+		src:      "ΟΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣ",
+		want:     "Οσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσς",
+		firstErr: transform.ErrShortSrc,
+		dstSize:  minBufSize,
+		srcSize:  10,
+		t:        Title(language.Und),
+	}, {
+		desc:     "und/title/final sigma: short destination 1",
+		src:      "ΟΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣ",
+		want:     "Οσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσς",
+		firstErr: transform.ErrShortDst,
+		dstSize:  10,
+		srcSize:  minBufSize,
+		t:        Title(language.Und),
+	}, {
+		desc:     "und/title/final sigma: short destination 2",
+		src:      "ΟΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣ",
+		want:     "Οσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσς",
+		firstErr: transform.ErrShortDst,
+		dstSize:  9,
+		srcSize:  minBufSize,
+		t:        Title(language.Und),
+	}, {
+		desc:     "und/title/final sigma: short destination 3",
+		src:      "ΟΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣΣ",
+		want:     "Οσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσς",
+		firstErr: transform.ErrShortDst,
+		dstSize:  8,
+		srcSize:  minBufSize,
+		t:        Title(language.Und),
+	}, {
+		desc:     "und/title/clipped UTF-8 rune",
+		src:      "σσσσσσσσσσσ",
+		want:     "Σσσσσσσσσσσ",
+		firstErr: transform.ErrShortSrc,
+		dstSize:  minBufSize,
+		srcSize:  5,
+		t:        Title(language.Und),
+	}, {
+		desc:    "und/title/clipped UTF-8 rune atEOF",
+		src:     "σσσ" + string([]byte{0xCF}),
+		want:    "Σσσ" + string([]byte{0xCF}),
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Title(language.Und),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc:    "und/title/final sigma: max ignorables",
+		src:     "ΟΣ" + strings.Repeat(".", maxIgnorable) + "a",
+		want:    "Οσ" + strings.Repeat(".", maxIgnorable) + "A",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Title(language.Und),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc:    "und/title/long string",
+		src:     "AA" + strings.Repeat(".", maxIgnorable+1) + "a",
+		want:    "Aa" + strings.Repeat(".", maxIgnorable+1) + "A",
+		dstSize: minBufSize,
+		srcSize: len("AA" + strings.Repeat(".", maxIgnorable+1)),
+		t:       Title(language.Und),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc:    "und/title/final sigma: too many ignorables",
+		src:     "ΟΣ" + strings.Repeat(".", maxIgnorable+1) + "a",
+		want:    "Ος" + strings.Repeat(".", maxIgnorable+1) + "A",
+		dstSize: minBufSize,
+		srcSize: len("ΟΣ" + strings.Repeat(".", maxIgnorable+1)),
+		t:       Title(language.Und),
+	}, {
+		desc:    "und/title/final sigma: apostrophe",
+		src:     "ΟΣ''a",
+		want:    "Οσ''A",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Title(language.Und),
+	}, {
+		desc:    "el/upper/max ignorables",
+		src:     "ο" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0313",
+		want:    "Ο" + strings.Repeat("\u0321", maxIgnorable-1),
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Upper(language.Greek),
+	}, {
+		desc:    "el/upper/too many ignorables",
+		src:     "ο" + strings.Repeat("\u0321", maxIgnorable) + "\u0313",
+		want:    "Ο" + strings.Repeat("\u0321", maxIgnorable) + "\u0313",
+		dstSize: minBufSize,
+		srcSize: len("ο" + strings.Repeat("\u0321", maxIgnorable)),
+		t:       Upper(language.Greek),
+	}, {
+		desc:     "el/upper/short dst",
+		src:      "123ο",
+		want:     "123Ο",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Upper(language.Greek),
+	}, {
+		desc:    "lt/lower/max ignorables",
+		src:     "I" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0300",
+		want:    "i" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0307\u0300",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Lower(language.Lithuanian),
+	}, {
+		desc:    "lt/lower/too many ignorables",
+		src:     "I" + strings.Repeat("\u0321", maxIgnorable) + "\u0300",
+		want:    "i" + strings.Repeat("\u0321", maxIgnorable) + "\u0300",
+		dstSize: minBufSize,
+		srcSize: len("I" + strings.Repeat("\u0321", maxIgnorable)),
+		t:       Lower(language.Lithuanian),
+	}, {
+		desc:     "lt/lower/decomposition with short dst buffer 1",
+		src:      "aaaaa\u00cc", // U+00CC LATIN CAPITAL LETTER I GRAVE
+		firstErr: transform.ErrShortDst,
+		want:     "aaaaai\u0307\u0300",
+		dstSize:  5,
+		srcSize:  minBufSize,
+		t:        Lower(language.Lithuanian),
+	}, {
+		desc:     "lt/lower/decomposition with short dst buffer 2",
+		src:      "aaaa\u00cc", // U+00CC LATIN CAPITAL LETTER I GRAVE
+		firstErr: transform.ErrShortDst,
+		want:     "aaaai\u0307\u0300",
+		dstSize:  5,
+		srcSize:  minBufSize,
+		t:        Lower(language.Lithuanian),
+	}, {
+		desc:    "lt/upper/max ignorables",
+		src:     "i" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0307\u0300",
+		want:    "I" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0300",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Upper(language.Lithuanian),
+	}, {
+		desc:    "lt/upper/too many ignorables",
+		src:     "i" + strings.Repeat("\u0321", maxIgnorable) + "\u0307\u0300",
+		want:    "I" + strings.Repeat("\u0321", maxIgnorable) + "\u0307\u0300",
+		dstSize: minBufSize,
+		srcSize: len("i" + strings.Repeat("\u0321", maxIgnorable)),
+		t:       Upper(language.Lithuanian),
+	}, {
+		desc:     "lt/upper/short dst",
+		src:      "12i\u0307\u0300",
+		want:     "12\u00cc",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Upper(language.Lithuanian),
+	}, {
+		desc:    "aztr/lower/max ignorables",
+		src:     "I" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0307\u0300",
+		want:    "i" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0300",
+		dstSize: minBufSize,
+		srcSize: minBufSize,
+		t:       Lower(language.Turkish),
+	}, {
+		desc:    "aztr/lower/too many ignorables",
+		src:     "I" + strings.Repeat("\u0321", maxIgnorable) + "\u0307\u0300",
+		want:    "\u0131" + strings.Repeat("\u0321", maxIgnorable) + "\u0307\u0300",
+		dstSize: minBufSize,
+		srcSize: len("I" + strings.Repeat("\u0321", maxIgnorable)),
+		t:       Lower(language.Turkish),
+	}, {
+		desc:     "nl/title/pre-IJ cutoff",
+		src:      "  ij",
+		want:     "  IJ",
+		firstErr: transform.ErrShortDst,
+		dstSize:  2,
+		srcSize:  minBufSize,
+		t:        Title(language.Dutch),
+	}, {
+		desc:     "nl/title/mid-IJ cutoff",
+		src:      "  ij",
+		want:     "  IJ",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Title(language.Dutch),
+	}, {
+		desc:     "af/title/apostrophe",
+		src:      "'n bietje",
+		want:     "'n Bietje",
+		firstErr: transform.ErrShortDst,
+		dstSize:  3,
+		srcSize:  minBufSize,
+		t:        Title(language.Afrikaans),
+	}}
+}
+
+func TestShortBuffersAndOverflow(t *testing.T) {
+	for i, tt := range bufferTests {
+		testtext.Run(t, tt.desc, func(t *testing.T) {
+			buf := make([]byte, tt.dstSize)
+			got := []byte{}
+			var nSrc, nDst int
+			var err error
+			for p := 0; p < len(tt.src); p += nSrc {
+				q := p + tt.srcSize
+				if q > len(tt.src) {
+					q = len(tt.src)
+				}
+				nDst, nSrc, err = tt.t.Transform(buf, []byte(tt.src[p:q]), q == len(tt.src))
+				got = append(got, buf[:nDst]...)
+
+				if p == 0 && err != tt.firstErr {
+					t.Errorf("%d:%s:\n error was %v; want %v", i, tt.desc, err, tt.firstErr)
+					break
+				}
+			}
+			if string(got) != tt.want {
+				t.Errorf("%d:%s:\ngot  %+q;\nwant %+q", i, tt.desc, got, tt.want)
+			}
+			testHandover(t, Caser{tt.t}, tt.src)
+		})
+	}
+}
+
+func TestSpan(t *testing.T) {
+	for _, tt := range []struct {
+		desc  string
+		src   string
+		want  string
+		atEOF bool
+		err   error
+		t     Caser
+	}{{
+		desc:  "und/upper/basic",
+		src:   "abcdefg",
+		want:  "",
+		atEOF: true,
+		err:   transform.ErrEndOfSpan,
+		t:     Upper(language.Und),
+	}, {
+		desc:  "und/upper/short src",
+		src:   "123É"[:4],
+		want:  "123",
+		atEOF: false,
+		err:   transform.ErrShortSrc,
+		t:     Upper(language.Und),
+	}, {
+		desc:  "und/upper/no error on short",
+		src:   "12",
+		want:  "12",
+		atEOF: false,
+		t:     Upper(language.Und),
+	}, {
+		desc:  "und/lower/basic",
+		src:   "ABCDEFG",
+		want:  "",
+		atEOF: true,
+		err:   transform.ErrEndOfSpan,
+		t:     Lower(language.Und),
+	}, {
+		desc:  "und/lower/short src num",
+		src:   "123é"[:4],
+		want:  "123",
+		atEOF: false,
+		err:   transform.ErrShortSrc,
+		t:     Lower(language.Und),
+	}, {
+		desc:  "und/lower/short src greek",
+		src:   "αβγé"[:7],
+		want:  "αβγ",
+		atEOF: false,
+		err:   transform.ErrShortSrc,
+		t:     Lower(language.Und),
+	}, {
+		desc:  "und/lower/no error on short",
+		src:   "12",
+		want:  "12",
+		atEOF: false,
+		t:     Lower(language.Und),
+	}, {
+		desc:  "und/lower/simple (no final sigma)",
+		src:   "ος οσσ",
+		want:  "οσ οσσ",
+		atEOF: true,
+		t:     Lower(language.Und, HandleFinalSigma(false)),
+	}, {
+		desc:  "und/title/simple (no final sigma)",
+		src:   "Οσ Οσσ",
+		want:  "Οσ Οσσ",
+		atEOF: true,
+		t:     Title(language.Und, HandleFinalSigma(false)),
+	}, {
+		desc: "und/lower/final sigma: no error",
+		src:  "οΣ", // Oς
+		want: "ο",  // Oς
+		err:  transform.ErrEndOfSpan,
+		t:    Lower(language.Und),
+	}, {
+		desc: "und/title/final sigma: no error",
+		src:  "ΟΣ", // Oς
+		want: "Ο",  // Oς
+		err:  transform.ErrEndOfSpan,
+		t:    Title(language.Und),
+	}, {
+		desc: "und/title/final sigma: no short source!",
+		src:  "ΟσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσΣ",
+		want: "Οσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσσ",
+		err:  transform.ErrEndOfSpan,
+		t:    Title(language.Und),
+	}, {
+		desc:  "und/title/clipped UTF-8 rune",
+		src:   "Σσ" + string([]byte{0xCF}),
+		want:  "Σσ",
+		atEOF: false,
+		err:   transform.ErrShortSrc,
+		t:     Title(language.Und),
+	}, {
+		desc:  "und/title/clipped UTF-8 rune atEOF",
+		src:   "Σσσ" + string([]byte{0xCF}),
+		want:  "Σσσ" + string([]byte{0xCF}),
+		atEOF: true,
+		t:     Title(language.Und),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc: "und/title/long string",
+		src:  "A" + strings.Repeat("a", maxIgnorable+5),
+		want: "A" + strings.Repeat("a", maxIgnorable+5),
+		t:    Title(language.Und),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc:  "und/title/cyrillic",
+		src:   "При",
+		want:  "При",
+		atEOF: true,
+		t:     Title(language.Und, HandleFinalSigma(false)),
+	}, {
+		// Note: the choice to change the final sigma at the end in case of
+		// too many case ignorables is arbitrary. The main reason for this
+		// choice is that it results in simpler code.
+		desc: "und/title/final sigma: max ignorables",
+		src:  "Οσ" + strings.Repeat(".", maxIgnorable) + "A",
+		want: "Οσ" + strings.Repeat(".", maxIgnorable) + "A",
+		t:    Title(language.Und),
+	}, {
+		desc: "el/upper/max ignorables - not implemented",
+		src:  "Ο" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0313",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Upper(language.Greek),
+	}, {
+		desc: "el/upper/too many ignorables - not implemented",
+		src:  "Ο" + strings.Repeat("\u0321", maxIgnorable) + "\u0313",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Upper(language.Greek),
+	}, {
+		desc: "el/upper/short dst",
+		src:  "123ο",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Upper(language.Greek),
+	}, {
+		desc: "lt/lower/max ignorables",
+		src:  "i" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0307\u0300",
+		want: "i" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0307\u0300",
+		t:    Lower(language.Lithuanian),
+	}, {
+		desc: "lt/lower/isLower",
+		src:  "I" + strings.Repeat("\u0321", maxIgnorable) + "\u0300",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Lower(language.Lithuanian),
+	}, {
+		desc: "lt/lower/not identical",
+		src:  "aaaaa\u00cc", // U+00CC LATIN CAPITAL LETTER I GRAVE
+		err:  transform.ErrEndOfSpan,
+		want: "aaaaa",
+		t:    Lower(language.Lithuanian),
+	}, {
+		desc: "lt/lower/identical",
+		src:  "aaaai\u0307\u0300", // U+00CC LATIN CAPITAL LETTER I GRAVE
+		want: "aaaai\u0307\u0300",
+		t:    Lower(language.Lithuanian),
+	}, {
+		desc: "lt/upper/not implemented",
+		src:  "I" + strings.Repeat("\u0321", maxIgnorable-1) + "\u0300",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Upper(language.Lithuanian),
+	}, {
+		desc: "lt/upper/not implemented, ascii",
+		src:  "AB",
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Upper(language.Lithuanian),
+	}, {
+		desc: "nl/title/pre-IJ cutoff",
+		src:  "  IJ",
+		want: "  IJ",
+		t:    Title(language.Dutch),
+	}, {
+		desc: "nl/title/mid-IJ cutoff",
+		src:  "  Ia",
+		want: "  Ia",
+		t:    Title(language.Dutch),
+	}, {
+		desc: "af/title/apostrophe",
+		src:  "'n Bietje",
+		want: "'n Bietje",
+		t:    Title(language.Afrikaans),
+	}, {
+		desc: "af/title/apostrophe-incorrect",
+		src:  "'N Bietje",
+		// The Single_Quote (a MidWord), needs to be retained as unspanned so
+		// that a successive call to Transform can detect that N should not be
+		// capitalized.
+		want: "",
+		err:  transform.ErrEndOfSpan,
+		t:    Title(language.Afrikaans),
+	}} {
+		testtext.Run(t, tt.desc, func(t *testing.T) {
+			for p := 0; p < len(tt.want); p += utf8.RuneLen([]rune(tt.src[p:])[0]) {
+				tt.t.Reset()
+				n, err := tt.t.Span([]byte(tt.src[:p]), false)
+				if err != nil && err != transform.ErrShortSrc {
+					t.Errorf("early failure:Span(%+q): %v (%d < %d)", tt.src[:p], err, n, len(tt.want))
+					break
+				}
+			}
+			tt.t.Reset()
+			n, err := tt.t.Span([]byte(tt.src), tt.atEOF)
+			if n != len(tt.want) || err != tt.err {
+				t.Errorf("Span(%+q, %v): got %d, %v; want %d, %v", tt.src, tt.atEOF, n, err, len(tt.want), tt.err)
+			}
+			testHandover(t, tt.t, tt.src)
+		})
+	}
+}
+
+var txtASCII = strings.Repeat("The quick brown fox jumps over the lazy dog. ", 50)
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/vn/
+const txt_vn = `Với các điều kiện sau: Ghi nhận công của tác giả.  Nếu bạn sử
+dụng, chuyển đổi, hoặc xây dựng dự án từ  nội dung được chia sẻ này, bạn phải áp
+dụng giấy phép này hoặc  một giấy phép khác có các điều khoản tương tự như giấy
+phép này cho dự án của bạn. Hiểu rằng: Miễn — Bất kỳ các điều kiện nào trên đây
+cũng có thể được miễn bỏ nếu bạn được sự cho phép của người sở hữu bản quyền.
+Phạm vi công chúng — Khi tác phẩm hoặc bất kỳ chương nào của tác phẩm đã trong
+vùng dành cho công chúng theo quy định của pháp luật thì tình trạng của nó không
+bị ảnh hưởng bởi giấy phép trong bất kỳ trường hợp nào.`
+
+// http://creativecommons.org/licenses/by-sa/2.5/cn/
+const txt_cn = `您可以自由： 复制、发行、展览、表演、放映、
+广播或通过信息网络传播本作品 创作演绎作品
+对本作品进行商业性使用 惟须遵守下列条件：
+署名 — 您必须按照作者或者许可人指定的方式对作品进行署名。
+相同方式共享 — 如果您改变、转换本作品或者以本作品为基础进行创作，
+您只能采用与本协议相同的许可协议发布基于本作品的演绎作品。`
+
+// Taken from http://creativecommons.org/licenses/by-sa/1.0/deed.ru
+const txt_ru = `При обязательном соблюдении следующих условий: Attribution — Вы
+должны атрибутировать произведение (указывать автора и источник) в порядке,
+предусмотренном автором или лицензиаром (но только так, чтобы никоим образом не
+подразумевалось, что они поддерживают вас или использование вами данного
+произведения). Υπό τις ακόλουθες προϋποθέσεις:`
+
+// Taken from http://creativecommons.org/licenses/by-sa/3.0/gr/
+const txt_gr = `Αναφορά Δημιουργού — Θα πρέπει να κάνετε την αναφορά στο έργο με
+τον τρόπο που έχει οριστεί από το δημιουργό ή το χορηγούντο την άδεια (χωρίς
+όμως να εννοείται με οποιονδήποτε τρόπο ότι εγκρίνουν εσάς ή τη χρήση του έργου
+από εσάς). Παρόμοια Διανομή — Εάν αλλοιώσετε, τροποποιήσετε ή δημιουργήσετε
+περαιτέρω βασισμένοι στο έργο θα μπορείτε να διανέμετε το έργο που θα προκύψει
+μόνο με την ίδια ή παρόμοια άδεια.`
+
+const txtNonASCII = txt_vn + txt_cn + txt_ru + txt_gr
+
+// TODO: Improve ASCII performance.
+
+func BenchmarkCasers(b *testing.B) {
+	for _, s := range []struct{ name, text string }{
+		{"ascii", txtASCII},
+		{"nonASCII", txtNonASCII},
+		{"short", "При"},
+	} {
+		src := []byte(s.text)
+		// Measure case mappings in bytes package for comparison.
+		for _, f := range []struct {
+			name string
+			fn   func(b []byte) []byte
+		}{
+			{"lower", bytes.ToLower},
+			{"title", bytes.ToTitle},
+			{"upper", bytes.ToUpper},
+		} {
+			testtext.Bench(b, path.Join(s.name, "bytes", f.name), func(b *testing.B) {
+				b.SetBytes(int64(len(src)))
+				for i := 0; i < b.N; i++ {
+					f.fn(src)
+				}
+			})
+		}
+		for _, t := range []struct {
+			name  string
+			caser transform.SpanningTransformer
+		}{
+			{"fold/default", Fold()},
+			{"upper/default", Upper(language.Und)},
+			{"lower/sigma", Lower(language.Und)},
+			{"lower/simple", Lower(language.Und, HandleFinalSigma(false))},
+			{"title/sigma", Title(language.Und)},
+			{"title/simple", Title(language.Und, HandleFinalSigma(false))},
+		} {
+			c := Caser{t.caser}
+			dst := make([]byte, len(src))
+			testtext.Bench(b, path.Join(s.name, t.name, "transform"), func(b *testing.B) {
+				b.SetBytes(int64(len(src)))
+				for i := 0; i < b.N; i++ {
+					c.Reset()
+					c.Transform(dst, src, true)
+				}
+			})
+			// No need to check span for simple cases, as they will be the same
+			// as sigma.
+			if strings.HasSuffix(t.name, "/simple") {
+				continue
+			}
+			spanSrc := c.Bytes(src)
+			testtext.Bench(b, path.Join(s.name, t.name, "span"), func(b *testing.B) {
+				c.Reset()
+				if n, _ := c.Span(spanSrc, true); n < len(spanSrc) {
+					b.Fatalf("spanner is not recognizing text %q as done (at %d)", spanSrc, n)
+				}
+				b.SetBytes(int64(len(spanSrc)))
+				for i := 0; i < b.N; i++ {
+					c.Reset()
+					c.Span(spanSrc, true)
+				}
+			})
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/cases/tables13.0.0.go b/vendor/golang.org/x/text/cases/tables13.0.0.go
new file mode 100644
index 0000000000..68d2981d18
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/tables13.0.0.go
@@ -0,0 +1,2400 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+//go:build go1.16 && !go1.21
+// +build go1.16,!go1.21
+
+package cases
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "13.0.0"
+
+var xorData string = "" + // Size: 192 bytes
+	"\x00\x06\x07\x00\x01?\x00\x0f\x03\x00\x0f\x12\x00\x0f\x1f\x00\x0f\x1d" +
+	"\x00\x01\x13\x00\x0f\x16\x00\x0f\x0b\x00\x0f3\x00\x0f7\x00\x01#\x00\x0f?" +
+	"\x00\x0e'\x00\x0f/\x00\x0e>\x00\x0f*\x00\x0c&\x00\x0c*\x00\x0c;\x00\x0c9" +
+	"\x00\x0c%\x00\x01\x08\x00\x03\x0d\x00\x03\x09\x00\x02\x06\x00\x02\x02" +
+	"\x00\x02\x0c\x00\x01\x00\x00\x01\x03\x00\x01\x01\x00\x01 \x00\x01\x0c" +
+	"\x00\x01\x10\x00\x03\x10\x00\x036 \x00\x037 \x00\x0b#\x10\x00\x0b 0\x00" +
+	"\x0b!\x10\x00\x0b!0\x001\x00\x00\x0b(\x04\x00\x03\x04\x1e\x00\x0b)\x08" +
+	"\x00\x03\x0a\x00\x02:\x00\x02>\x00\x02,\x00\x02\x00\x00\x02\x10\x00\x01<" +
+	"\x00\x01&\x00\x01*\x00\x01.\x00\x010\x003 \x00\x01\x18\x00\x01(\x00\x01" +
+	"\x1e\x00\x01\x22"
+
+var exceptions string = "" + // Size: 2450 bytes
+	"\x00\x12\x12μΜΜ\x12\x12ssSSSs\x13\x18i̇i̇\x10\x09II\x13\x1bʼnʼNʼN\x11" +
+	"\x09sSS\x12\x12dždžDž\x12\x12dždžDŽ\x10\x12DŽDž\x12\x12ljljLj\x12\x12ljljLJ\x10\x12LJLj" +
+	"\x12\x12njnjNj\x12\x12njnjNJ\x10\x12NJNj\x13\x1bǰJ̌J̌\x12\x12dzdzDz\x12\x12dzdzDZ\x10" +
+	"\x12DZDz\x13\x18ⱥⱥ\x13\x18ⱦⱦ\x10\x1bⱾⱾ\x10\x1bⱿⱿ\x10\x1bⱯⱯ\x10\x1bⱭⱭ\x10" +
+	"\x1bⱰⱰ\x10\x1bꞫꞫ\x10\x1bꞬꞬ\x10\x1bꞍꞍ\x10\x1bꞪꞪ\x10\x1bꞮꞮ\x10\x1bⱢⱢ\x10" +
+	"\x1bꞭꞭ\x10\x1bⱮⱮ\x10\x1bⱤⱤ\x10\x1bꟅꟅ\x10\x1bꞱꞱ\x10\x1bꞲꞲ\x10\x1bꞰꞰ2\x12ι" +
+	"ΙΙ\x166ΐΪ́Ϊ́\x166ΰΫ́Ϋ́\x12\x12σΣΣ\x12\x12βΒΒ\x12\x12θΘΘ\x12\x12" +
+	"φΦΦ\x12\x12πΠΠ\x12\x12κΚΚ\x12\x12ρΡΡ\x12\x12εΕΕ\x14$եւԵՒԵւ\x10\x1bᲐა" +
+	"\x10\x1bᲑბ\x10\x1bᲒგ\x10\x1bᲓდ\x10\x1bᲔე\x10\x1bᲕვ\x10\x1bᲖზ\x10\x1bᲗთ" +
+	"\x10\x1bᲘი\x10\x1bᲙკ\x10\x1bᲚლ\x10\x1bᲛმ\x10\x1bᲜნ\x10\x1bᲝო\x10\x1bᲞპ" +
+	"\x10\x1bᲟჟ\x10\x1bᲠრ\x10\x1bᲡს\x10\x1bᲢტ\x10\x1bᲣუ\x10\x1bᲤფ\x10\x1bᲥქ" +
+	"\x10\x1bᲦღ\x10\x1bᲧყ\x10\x1bᲨშ\x10\x1bᲩჩ\x10\x1bᲪც\x10\x1bᲫძ\x10\x1bᲬწ" +
+	"\x10\x1bᲭჭ\x10\x1bᲮხ\x10\x1bᲯჯ\x10\x1bᲰჰ\x10\x1bᲱჱ\x10\x1bᲲჲ\x10\x1bᲳჳ" +
+	"\x10\x1bᲴჴ\x10\x1bᲵჵ\x10\x1bᲶჶ\x10\x1bᲷჷ\x10\x1bᲸჸ\x10\x1bᲹჹ\x10\x1bᲺჺ" +
+	"\x10\x1bᲽჽ\x10\x1bᲾჾ\x10\x1bᲿჿ\x12\x12вВВ\x12\x12дДД\x12\x12оОО\x12\x12с" +
+	"СС\x12\x12тТТ\x12\x12тТТ\x12\x12ъЪЪ\x12\x12ѣѢѢ\x13\x1bꙋꙊꙊ\x13\x1bẖH̱H̱" +
+	"\x13\x1bẗT̈T̈\x13\x1bẘW̊W̊\x13\x1bẙY̊Y̊\x13\x1baʾAʾAʾ\x13\x1bṡṠṠ\x12" +
+	"\x10ssß\x14$ὐΥ̓Υ̓\x166ὒΥ̓̀Υ̓̀\x166ὔΥ̓́Υ̓́\x166ὖΥ̓͂Υ̓͂\x15+ἀιἈΙᾈ" +
+	"\x15+ἁιἉΙᾉ\x15+ἂιἊΙᾊ\x15+ἃιἋΙᾋ\x15+ἄιἌΙᾌ\x15+ἅιἍΙᾍ\x15+ἆιἎΙᾎ\x15+ἇιἏΙᾏ" +
+	"\x15\x1dἀιᾀἈΙ\x15\x1dἁιᾁἉΙ\x15\x1dἂιᾂἊΙ\x15\x1dἃιᾃἋΙ\x15\x1dἄιᾄἌΙ\x15" +
+	"\x1dἅιᾅἍΙ\x15\x1dἆιᾆἎΙ\x15\x1dἇιᾇἏΙ\x15+ἠιἨΙᾘ\x15+ἡιἩΙᾙ\x15+ἢιἪΙᾚ\x15+ἣι" +
+	"ἫΙᾛ\x15+ἤιἬΙᾜ\x15+ἥιἭΙᾝ\x15+ἦιἮΙᾞ\x15+ἧιἯΙᾟ\x15\x1dἠιᾐἨΙ\x15\x1dἡιᾑἩΙ" +
+	"\x15\x1dἢιᾒἪΙ\x15\x1dἣιᾓἫΙ\x15\x1dἤιᾔἬΙ\x15\x1dἥιᾕἭΙ\x15\x1dἦιᾖἮΙ\x15" +
+	"\x1dἧιᾗἯΙ\x15+ὠιὨΙᾨ\x15+ὡιὩΙᾩ\x15+ὢιὪΙᾪ\x15+ὣιὫΙᾫ\x15+ὤιὬΙᾬ\x15+ὥιὭΙᾭ" +
+	"\x15+ὦιὮΙᾮ\x15+ὧιὯΙᾯ\x15\x1dὠιᾠὨΙ\x15\x1dὡιᾡὩΙ\x15\x1dὢιᾢὪΙ\x15\x1dὣιᾣὫΙ" +
+	"\x15\x1dὤιᾤὬΙ\x15\x1dὥιᾥὭΙ\x15\x1dὦιᾦὮΙ\x15\x1dὧιᾧὯΙ\x15-ὰιᾺΙᾺͅ\x14#αιΑΙ" +
+	"ᾼ\x14$άιΆΙΆͅ\x14$ᾶΑ͂Α͂\x166ᾶιΑ͂Ιᾼ͂\x14\x1cαιᾳΑΙ\x12\x12ιΙΙ\x15-ὴιῊΙ" +
+	"Ὴͅ\x14#ηιΗΙῌ\x14$ήιΉΙΉͅ\x14$ῆΗ͂Η͂\x166ῆιΗ͂Ιῌ͂\x14\x1cηιῃΗΙ\x166ῒΙ" +
+	"̈̀Ϊ̀\x166ΐΪ́Ϊ́\x14$ῖΙ͂Ι͂\x166ῗΪ͂Ϊ͂\x166ῢΫ̀Ϋ̀\x166ΰΫ́Ϋ" +
+	"́\x14$ῤΡ̓Ρ̓\x14$ῦΥ͂Υ͂\x166ῧΫ͂Ϋ͂\x15-ὼιῺΙῺͅ\x14#ωιΩΙῼ\x14$ώιΏΙΏͅ" +
+	"\x14$ῶΩ͂Ω͂\x166ῶιΩ͂Ιῼ͂\x14\x1cωιῳΩΙ\x12\x10ωω\x11\x08kk\x12\x10åå\x12" +
+	"\x10ɫɫ\x12\x10ɽɽ\x10\x12ȺȺ\x10\x12ȾȾ\x12\x10ɑɑ\x12\x10ɱɱ\x12\x10ɐɐ\x12" +
+	"\x10ɒɒ\x12\x10ȿȿ\x12\x10ɀɀ\x12\x10ɥɥ\x12\x10ɦɦ\x12\x10ɜɜ\x12\x10ɡɡ\x12" +
+	"\x10ɬɬ\x12\x10ɪɪ\x12\x10ʞʞ\x12\x10ʇʇ\x12\x10ʝʝ\x12\x10ʂʂ\x12\x12ffFFFf" +
+	"\x12\x12fiFIFi\x12\x12flFLFl\x13\x1bffiFFIFfi\x13\x1bfflFFLFfl\x12\x12st" +
+	"STSt\x12\x12stSTSt\x14$մնՄՆՄն\x14$մեՄԵՄե\x14$միՄԻՄի\x14$վնՎՆՎն\x14$մխՄԽՄ" +
+	"խ"
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *caseTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = caseIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = caseIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = caseIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *caseTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *caseTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = caseIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := caseIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = caseIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = caseIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *caseTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// caseTrie. Total size: 12538 bytes (12.24 KiB). Checksum: af4dfa7d60c71d4c.
+type caseTrie struct{}
+
+func newCaseTrie(i int) *caseTrie {
+	return &caseTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *caseTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 20:
+		return uint16(caseValues[n<<6+uint32(b)])
+	default:
+		n -= 20
+		return uint16(sparse.lookup(n, b))
+	}
+}
+
+// caseValues: 22 blocks, 1408 entries, 2816 bytes
+// The third block is the zero block.
+var caseValues = [1408]uint16{
+	// Block 0x0, offset 0x0
+	0x27: 0x0054,
+	0x2e: 0x0054,
+	0x30: 0x0010, 0x31: 0x0010, 0x32: 0x0010, 0x33: 0x0010, 0x34: 0x0010, 0x35: 0x0010,
+	0x36: 0x0010, 0x37: 0x0010, 0x38: 0x0010, 0x39: 0x0010, 0x3a: 0x0054,
+	// Block 0x1, offset 0x40
+	0x41: 0x2013, 0x42: 0x2013, 0x43: 0x2013, 0x44: 0x2013, 0x45: 0x2013,
+	0x46: 0x2013, 0x47: 0x2013, 0x48: 0x2013, 0x49: 0x2013, 0x4a: 0x2013, 0x4b: 0x2013,
+	0x4c: 0x2013, 0x4d: 0x2013, 0x4e: 0x2013, 0x4f: 0x2013, 0x50: 0x2013, 0x51: 0x2013,
+	0x52: 0x2013, 0x53: 0x2013, 0x54: 0x2013, 0x55: 0x2013, 0x56: 0x2013, 0x57: 0x2013,
+	0x58: 0x2013, 0x59: 0x2013, 0x5a: 0x2013,
+	0x5e: 0x0004, 0x5f: 0x0010, 0x60: 0x0004, 0x61: 0x2012, 0x62: 0x2012, 0x63: 0x2012,
+	0x64: 0x2012, 0x65: 0x2012, 0x66: 0x2012, 0x67: 0x2012, 0x68: 0x2012, 0x69: 0x2012,
+	0x6a: 0x2012, 0x6b: 0x2012, 0x6c: 0x2012, 0x6d: 0x2012, 0x6e: 0x2012, 0x6f: 0x2012,
+	0x70: 0x2012, 0x71: 0x2012, 0x72: 0x2012, 0x73: 0x2012, 0x74: 0x2012, 0x75: 0x2012,
+	0x76: 0x2012, 0x77: 0x2012, 0x78: 0x2012, 0x79: 0x2012, 0x7a: 0x2012,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x0852, 0xc1: 0x0b53, 0xc2: 0x0113, 0xc3: 0x0112, 0xc4: 0x0113, 0xc5: 0x0112,
+	0xc6: 0x0b53, 0xc7: 0x0f13, 0xc8: 0x0f12, 0xc9: 0x0e53, 0xca: 0x1153, 0xcb: 0x0713,
+	0xcc: 0x0712, 0xcd: 0x0012, 0xce: 0x1453, 0xcf: 0x1753, 0xd0: 0x1a53, 0xd1: 0x0313,
+	0xd2: 0x0312, 0xd3: 0x1d53, 0xd4: 0x2053, 0xd5: 0x2352, 0xd6: 0x2653, 0xd7: 0x2653,
+	0xd8: 0x0113, 0xd9: 0x0112, 0xda: 0x2952, 0xdb: 0x0012, 0xdc: 0x1d53, 0xdd: 0x2c53,
+	0xde: 0x2f52, 0xdf: 0x3253, 0xe0: 0x0113, 0xe1: 0x0112, 0xe2: 0x0113, 0xe3: 0x0112,
+	0xe4: 0x0113, 0xe5: 0x0112, 0xe6: 0x3553, 0xe7: 0x0f13, 0xe8: 0x0f12, 0xe9: 0x3853,
+	0xea: 0x0012, 0xeb: 0x0012, 0xec: 0x0113, 0xed: 0x0112, 0xee: 0x3553, 0xef: 0x1f13,
+	0xf0: 0x1f12, 0xf1: 0x3b53, 0xf2: 0x3e53, 0xf3: 0x0713, 0xf4: 0x0712, 0xf5: 0x0313,
+	0xf6: 0x0312, 0xf7: 0x4153, 0xf8: 0x0113, 0xf9: 0x0112, 0xfa: 0x0012, 0xfb: 0x0010,
+	0xfc: 0x0113, 0xfd: 0x0112, 0xfe: 0x0012, 0xff: 0x4452,
+	// Block 0x4, offset 0x100
+	0x100: 0x0010, 0x101: 0x0010, 0x102: 0x0010, 0x103: 0x0010, 0x104: 0x02db, 0x105: 0x0359,
+	0x106: 0x03da, 0x107: 0x043b, 0x108: 0x04b9, 0x109: 0x053a, 0x10a: 0x059b, 0x10b: 0x0619,
+	0x10c: 0x069a, 0x10d: 0x0313, 0x10e: 0x0312, 0x10f: 0x1f13, 0x110: 0x1f12, 0x111: 0x0313,
+	0x112: 0x0312, 0x113: 0x0713, 0x114: 0x0712, 0x115: 0x0313, 0x116: 0x0312, 0x117: 0x0f13,
+	0x118: 0x0f12, 0x119: 0x0313, 0x11a: 0x0312, 0x11b: 0x0713, 0x11c: 0x0712, 0x11d: 0x1452,
+	0x11e: 0x0113, 0x11f: 0x0112, 0x120: 0x0113, 0x121: 0x0112, 0x122: 0x0113, 0x123: 0x0112,
+	0x124: 0x0113, 0x125: 0x0112, 0x126: 0x0113, 0x127: 0x0112, 0x128: 0x0113, 0x129: 0x0112,
+	0x12a: 0x0113, 0x12b: 0x0112, 0x12c: 0x0113, 0x12d: 0x0112, 0x12e: 0x0113, 0x12f: 0x0112,
+	0x130: 0x06fa, 0x131: 0x07ab, 0x132: 0x0829, 0x133: 0x08aa, 0x134: 0x0113, 0x135: 0x0112,
+	0x136: 0x2353, 0x137: 0x4453, 0x138: 0x0113, 0x139: 0x0112, 0x13a: 0x0113, 0x13b: 0x0112,
+	0x13c: 0x0113, 0x13d: 0x0112, 0x13e: 0x0113, 0x13f: 0x0112,
+	// Block 0x5, offset 0x140
+	0x140: 0x0a8a, 0x141: 0x0313, 0x142: 0x0312, 0x143: 0x0853, 0x144: 0x4753, 0x145: 0x4a53,
+	0x146: 0x0113, 0x147: 0x0112, 0x148: 0x0113, 0x149: 0x0112, 0x14a: 0x0113, 0x14b: 0x0112,
+	0x14c: 0x0113, 0x14d: 0x0112, 0x14e: 0x0113, 0x14f: 0x0112, 0x150: 0x0b0a, 0x151: 0x0b8a,
+	0x152: 0x0c0a, 0x153: 0x0b52, 0x154: 0x0b52, 0x155: 0x0012, 0x156: 0x0e52, 0x157: 0x1152,
+	0x158: 0x0012, 0x159: 0x1752, 0x15a: 0x0012, 0x15b: 0x1a52, 0x15c: 0x0c8a, 0x15d: 0x0012,
+	0x15e: 0x0012, 0x15f: 0x0012, 0x160: 0x1d52, 0x161: 0x0d0a, 0x162: 0x0012, 0x163: 0x2052,
+	0x164: 0x0012, 0x165: 0x0d8a, 0x166: 0x0e0a, 0x167: 0x0012, 0x168: 0x2652, 0x169: 0x2652,
+	0x16a: 0x0e8a, 0x16b: 0x0f0a, 0x16c: 0x0f8a, 0x16d: 0x0012, 0x16e: 0x0012, 0x16f: 0x1d52,
+	0x170: 0x0012, 0x171: 0x100a, 0x172: 0x2c52, 0x173: 0x0012, 0x174: 0x0012, 0x175: 0x3252,
+	0x176: 0x0012, 0x177: 0x0012, 0x178: 0x0012, 0x179: 0x0012, 0x17a: 0x0012, 0x17b: 0x0012,
+	0x17c: 0x0012, 0x17d: 0x108a, 0x17e: 0x0012, 0x17f: 0x0012,
+	// Block 0x6, offset 0x180
+	0x180: 0x3552, 0x181: 0x0012, 0x182: 0x110a, 0x183: 0x3852, 0x184: 0x0012, 0x185: 0x0012,
+	0x186: 0x0012, 0x187: 0x118a, 0x188: 0x3552, 0x189: 0x4752, 0x18a: 0x3b52, 0x18b: 0x3e52,
+	0x18c: 0x4a52, 0x18d: 0x0012, 0x18e: 0x0012, 0x18f: 0x0012, 0x190: 0x0012, 0x191: 0x0012,
+	0x192: 0x4152, 0x193: 0x0012, 0x194: 0x0010, 0x195: 0x0012, 0x196: 0x0012, 0x197: 0x0012,
+	0x198: 0x0012, 0x199: 0x0012, 0x19a: 0x0012, 0x19b: 0x0012, 0x19c: 0x0012, 0x19d: 0x120a,
+	0x19e: 0x128a, 0x19f: 0x0012, 0x1a0: 0x0012, 0x1a1: 0x0012, 0x1a2: 0x0012, 0x1a3: 0x0012,
+	0x1a4: 0x0012, 0x1a5: 0x0012, 0x1a6: 0x0012, 0x1a7: 0x0012, 0x1a8: 0x0012, 0x1a9: 0x0012,
+	0x1aa: 0x0012, 0x1ab: 0x0012, 0x1ac: 0x0012, 0x1ad: 0x0012, 0x1ae: 0x0012, 0x1af: 0x0012,
+	0x1b0: 0x0015, 0x1b1: 0x0015, 0x1b2: 0x0015, 0x1b3: 0x0015, 0x1b4: 0x0015, 0x1b5: 0x0015,
+	0x1b6: 0x0015, 0x1b7: 0x0015, 0x1b8: 0x0015, 0x1b9: 0x0014, 0x1ba: 0x0014, 0x1bb: 0x0014,
+	0x1bc: 0x0014, 0x1bd: 0x0014, 0x1be: 0x0014, 0x1bf: 0x0014,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x0024, 0x1c1: 0x0024, 0x1c2: 0x0024, 0x1c3: 0x0024, 0x1c4: 0x0024, 0x1c5: 0x130d,
+	0x1c6: 0x0024, 0x1c7: 0x0034, 0x1c8: 0x0034, 0x1c9: 0x0034, 0x1ca: 0x0024, 0x1cb: 0x0024,
+	0x1cc: 0x0024, 0x1cd: 0x0034, 0x1ce: 0x0034, 0x1cf: 0x0014, 0x1d0: 0x0024, 0x1d1: 0x0024,
+	0x1d2: 0x0024, 0x1d3: 0x0034, 0x1d4: 0x0034, 0x1d5: 0x0034, 0x1d6: 0x0034, 0x1d7: 0x0024,
+	0x1d8: 0x0034, 0x1d9: 0x0034, 0x1da: 0x0034, 0x1db: 0x0024, 0x1dc: 0x0034, 0x1dd: 0x0034,
+	0x1de: 0x0034, 0x1df: 0x0034, 0x1e0: 0x0034, 0x1e1: 0x0034, 0x1e2: 0x0034, 0x1e3: 0x0024,
+	0x1e4: 0x0024, 0x1e5: 0x0024, 0x1e6: 0x0024, 0x1e7: 0x0024, 0x1e8: 0x0024, 0x1e9: 0x0024,
+	0x1ea: 0x0024, 0x1eb: 0x0024, 0x1ec: 0x0024, 0x1ed: 0x0024, 0x1ee: 0x0024, 0x1ef: 0x0024,
+	0x1f0: 0x0113, 0x1f1: 0x0112, 0x1f2: 0x0113, 0x1f3: 0x0112, 0x1f4: 0x0014, 0x1f5: 0x0004,
+	0x1f6: 0x0113, 0x1f7: 0x0112, 0x1fa: 0x0015, 0x1fb: 0x4d52,
+	0x1fc: 0x5052, 0x1fd: 0x5052, 0x1ff: 0x5353,
+	// Block 0x8, offset 0x200
+	0x204: 0x0004, 0x205: 0x0004,
+	0x206: 0x2a13, 0x207: 0x0054, 0x208: 0x2513, 0x209: 0x2713, 0x20a: 0x2513,
+	0x20c: 0x5653, 0x20e: 0x5953, 0x20f: 0x5c53, 0x210: 0x138a, 0x211: 0x2013,
+	0x212: 0x2013, 0x213: 0x2013, 0x214: 0x2013, 0x215: 0x2013, 0x216: 0x2013, 0x217: 0x2013,
+	0x218: 0x2013, 0x219: 0x2013, 0x21a: 0x2013, 0x21b: 0x2013, 0x21c: 0x2013, 0x21d: 0x2013,
+	0x21e: 0x2013, 0x21f: 0x2013, 0x220: 0x5f53, 0x221: 0x5f53, 0x223: 0x5f53,
+	0x224: 0x5f53, 0x225: 0x5f53, 0x226: 0x5f53, 0x227: 0x5f53, 0x228: 0x5f53, 0x229: 0x5f53,
+	0x22a: 0x5f53, 0x22b: 0x5f53, 0x22c: 0x2a12, 0x22d: 0x2512, 0x22e: 0x2712, 0x22f: 0x2512,
+	0x230: 0x14ca, 0x231: 0x2012, 0x232: 0x2012, 0x233: 0x2012, 0x234: 0x2012, 0x235: 0x2012,
+	0x236: 0x2012, 0x237: 0x2012, 0x238: 0x2012, 0x239: 0x2012, 0x23a: 0x2012, 0x23b: 0x2012,
+	0x23c: 0x2012, 0x23d: 0x2012, 0x23e: 0x2012, 0x23f: 0x2012,
+	// Block 0x9, offset 0x240
+	0x240: 0x5f52, 0x241: 0x5f52, 0x242: 0x160a, 0x243: 0x5f52, 0x244: 0x5f52, 0x245: 0x5f52,
+	0x246: 0x5f52, 0x247: 0x5f52, 0x248: 0x5f52, 0x249: 0x5f52, 0x24a: 0x5f52, 0x24b: 0x5f52,
+	0x24c: 0x5652, 0x24d: 0x5952, 0x24e: 0x5c52, 0x24f: 0x1813, 0x250: 0x168a, 0x251: 0x170a,
+	0x252: 0x0013, 0x253: 0x0013, 0x254: 0x0013, 0x255: 0x178a, 0x256: 0x180a, 0x257: 0x1812,
+	0x258: 0x0113, 0x259: 0x0112, 0x25a: 0x0113, 0x25b: 0x0112, 0x25c: 0x0113, 0x25d: 0x0112,
+	0x25e: 0x0113, 0x25f: 0x0112, 0x260: 0x0113, 0x261: 0x0112, 0x262: 0x0113, 0x263: 0x0112,
+	0x264: 0x0113, 0x265: 0x0112, 0x266: 0x0113, 0x267: 0x0112, 0x268: 0x0113, 0x269: 0x0112,
+	0x26a: 0x0113, 0x26b: 0x0112, 0x26c: 0x0113, 0x26d: 0x0112, 0x26e: 0x0113, 0x26f: 0x0112,
+	0x270: 0x188a, 0x271: 0x190a, 0x272: 0x0b12, 0x273: 0x5352, 0x274: 0x6253, 0x275: 0x198a,
+	0x277: 0x0f13, 0x278: 0x0f12, 0x279: 0x0b13, 0x27a: 0x0113, 0x27b: 0x0112,
+	0x27c: 0x0012, 0x27d: 0x4d53, 0x27e: 0x5053, 0x27f: 0x5053,
+	// Block 0xa, offset 0x280
+	0x280: 0x6852, 0x281: 0x6852, 0x282: 0x6852, 0x283: 0x6852, 0x284: 0x6852, 0x285: 0x6852,
+	0x286: 0x6852, 0x287: 0x1a0a, 0x288: 0x0012, 0x28a: 0x0010,
+	0x291: 0x0034,
+	0x292: 0x0024, 0x293: 0x0024, 0x294: 0x0024, 0x295: 0x0024, 0x296: 0x0034, 0x297: 0x0024,
+	0x298: 0x0024, 0x299: 0x0024, 0x29a: 0x0034, 0x29b: 0x0034, 0x29c: 0x0024, 0x29d: 0x0024,
+	0x29e: 0x0024, 0x29f: 0x0024, 0x2a0: 0x0024, 0x2a1: 0x0024, 0x2a2: 0x0034, 0x2a3: 0x0034,
+	0x2a4: 0x0034, 0x2a5: 0x0034, 0x2a6: 0x0034, 0x2a7: 0x0034, 0x2a8: 0x0024, 0x2a9: 0x0024,
+	0x2aa: 0x0034, 0x2ab: 0x0024, 0x2ac: 0x0024, 0x2ad: 0x0034, 0x2ae: 0x0034, 0x2af: 0x0024,
+	0x2b0: 0x0034, 0x2b1: 0x0034, 0x2b2: 0x0034, 0x2b3: 0x0034, 0x2b4: 0x0034, 0x2b5: 0x0034,
+	0x2b6: 0x0034, 0x2b7: 0x0034, 0x2b8: 0x0034, 0x2b9: 0x0034, 0x2ba: 0x0034, 0x2bb: 0x0034,
+	0x2bc: 0x0034, 0x2bd: 0x0034, 0x2bf: 0x0034,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x7053, 0x2c1: 0x7053, 0x2c2: 0x7053, 0x2c3: 0x7053, 0x2c4: 0x7053, 0x2c5: 0x7053,
+	0x2c7: 0x7053,
+	0x2cd: 0x7053, 0x2d0: 0x1aea, 0x2d1: 0x1b6a,
+	0x2d2: 0x1bea, 0x2d3: 0x1c6a, 0x2d4: 0x1cea, 0x2d5: 0x1d6a, 0x2d6: 0x1dea, 0x2d7: 0x1e6a,
+	0x2d8: 0x1eea, 0x2d9: 0x1f6a, 0x2da: 0x1fea, 0x2db: 0x206a, 0x2dc: 0x20ea, 0x2dd: 0x216a,
+	0x2de: 0x21ea, 0x2df: 0x226a, 0x2e0: 0x22ea, 0x2e1: 0x236a, 0x2e2: 0x23ea, 0x2e3: 0x246a,
+	0x2e4: 0x24ea, 0x2e5: 0x256a, 0x2e6: 0x25ea, 0x2e7: 0x266a, 0x2e8: 0x26ea, 0x2e9: 0x276a,
+	0x2ea: 0x27ea, 0x2eb: 0x286a, 0x2ec: 0x28ea, 0x2ed: 0x296a, 0x2ee: 0x29ea, 0x2ef: 0x2a6a,
+	0x2f0: 0x2aea, 0x2f1: 0x2b6a, 0x2f2: 0x2bea, 0x2f3: 0x2c6a, 0x2f4: 0x2cea, 0x2f5: 0x2d6a,
+	0x2f6: 0x2dea, 0x2f7: 0x2e6a, 0x2f8: 0x2eea, 0x2f9: 0x2f6a, 0x2fa: 0x2fea,
+	0x2fc: 0x0014, 0x2fd: 0x306a, 0x2fe: 0x30ea, 0x2ff: 0x316a,
+	// Block 0xc, offset 0x300
+	0x300: 0x0812, 0x301: 0x0812, 0x302: 0x0812, 0x303: 0x0812, 0x304: 0x0812, 0x305: 0x0812,
+	0x308: 0x0813, 0x309: 0x0813, 0x30a: 0x0813, 0x30b: 0x0813,
+	0x30c: 0x0813, 0x30d: 0x0813, 0x310: 0x3b1a, 0x311: 0x0812,
+	0x312: 0x3bfa, 0x313: 0x0812, 0x314: 0x3d3a, 0x315: 0x0812, 0x316: 0x3e7a, 0x317: 0x0812,
+	0x319: 0x0813, 0x31b: 0x0813, 0x31d: 0x0813,
+	0x31f: 0x0813, 0x320: 0x0812, 0x321: 0x0812, 0x322: 0x0812, 0x323: 0x0812,
+	0x324: 0x0812, 0x325: 0x0812, 0x326: 0x0812, 0x327: 0x0812, 0x328: 0x0813, 0x329: 0x0813,
+	0x32a: 0x0813, 0x32b: 0x0813, 0x32c: 0x0813, 0x32d: 0x0813, 0x32e: 0x0813, 0x32f: 0x0813,
+	0x330: 0x9252, 0x331: 0x9252, 0x332: 0x9552, 0x333: 0x9552, 0x334: 0x9852, 0x335: 0x9852,
+	0x336: 0x9b52, 0x337: 0x9b52, 0x338: 0x9e52, 0x339: 0x9e52, 0x33a: 0xa152, 0x33b: 0xa152,
+	0x33c: 0x4d52, 0x33d: 0x4d52,
+	// Block 0xd, offset 0x340
+	0x340: 0x3fba, 0x341: 0x40aa, 0x342: 0x419a, 0x343: 0x428a, 0x344: 0x437a, 0x345: 0x446a,
+	0x346: 0x455a, 0x347: 0x464a, 0x348: 0x4739, 0x349: 0x4829, 0x34a: 0x4919, 0x34b: 0x4a09,
+	0x34c: 0x4af9, 0x34d: 0x4be9, 0x34e: 0x4cd9, 0x34f: 0x4dc9, 0x350: 0x4eba, 0x351: 0x4faa,
+	0x352: 0x509a, 0x353: 0x518a, 0x354: 0x527a, 0x355: 0x536a, 0x356: 0x545a, 0x357: 0x554a,
+	0x358: 0x5639, 0x359: 0x5729, 0x35a: 0x5819, 0x35b: 0x5909, 0x35c: 0x59f9, 0x35d: 0x5ae9,
+	0x35e: 0x5bd9, 0x35f: 0x5cc9, 0x360: 0x5dba, 0x361: 0x5eaa, 0x362: 0x5f9a, 0x363: 0x608a,
+	0x364: 0x617a, 0x365: 0x626a, 0x366: 0x635a, 0x367: 0x644a, 0x368: 0x6539, 0x369: 0x6629,
+	0x36a: 0x6719, 0x36b: 0x6809, 0x36c: 0x68f9, 0x36d: 0x69e9, 0x36e: 0x6ad9, 0x36f: 0x6bc9,
+	0x370: 0x0812, 0x371: 0x0812, 0x372: 0x6cba, 0x373: 0x6dca, 0x374: 0x6e9a,
+	0x376: 0x6f7a, 0x377: 0x705a, 0x378: 0x0813, 0x379: 0x0813, 0x37a: 0x9253, 0x37b: 0x9253,
+	0x37c: 0x7199, 0x37d: 0x0004, 0x37e: 0x726a, 0x37f: 0x0004,
+	// Block 0xe, offset 0x380
+	0x380: 0x0004, 0x381: 0x0004, 0x382: 0x72ea, 0x383: 0x73fa, 0x384: 0x74ca,
+	0x386: 0x75aa, 0x387: 0x768a, 0x388: 0x9553, 0x389: 0x9553, 0x38a: 0x9853, 0x38b: 0x9853,
+	0x38c: 0x77c9, 0x38d: 0x0004, 0x38e: 0x0004, 0x38f: 0x0004, 0x390: 0x0812, 0x391: 0x0812,
+	0x392: 0x789a, 0x393: 0x79da, 0x396: 0x7b1a, 0x397: 0x7bfa,
+	0x398: 0x0813, 0x399: 0x0813, 0x39a: 0x9b53, 0x39b: 0x9b53, 0x39d: 0x0004,
+	0x39e: 0x0004, 0x39f: 0x0004, 0x3a0: 0x0812, 0x3a1: 0x0812, 0x3a2: 0x7d3a, 0x3a3: 0x7e7a,
+	0x3a4: 0x7fba, 0x3a5: 0x0912, 0x3a6: 0x809a, 0x3a7: 0x817a, 0x3a8: 0x0813, 0x3a9: 0x0813,
+	0x3aa: 0xa153, 0x3ab: 0xa153, 0x3ac: 0x0913, 0x3ad: 0x0004, 0x3ae: 0x0004, 0x3af: 0x0004,
+	0x3b2: 0x82ba, 0x3b3: 0x83ca, 0x3b4: 0x849a,
+	0x3b6: 0x857a, 0x3b7: 0x865a, 0x3b8: 0x9e53, 0x3b9: 0x9e53, 0x3ba: 0x4d53, 0x3bb: 0x4d53,
+	0x3bc: 0x8799, 0x3bd: 0x0004, 0x3be: 0x0004,
+	// Block 0xf, offset 0x3c0
+	0x3c2: 0x0013,
+	0x3c7: 0x0013, 0x3ca: 0x0012, 0x3cb: 0x0013,
+	0x3cc: 0x0013, 0x3cd: 0x0013, 0x3ce: 0x0012, 0x3cf: 0x0012, 0x3d0: 0x0013, 0x3d1: 0x0013,
+	0x3d2: 0x0013, 0x3d3: 0x0012, 0x3d5: 0x0013,
+	0x3d9: 0x0013, 0x3da: 0x0013, 0x3db: 0x0013, 0x3dc: 0x0013, 0x3dd: 0x0013,
+	0x3e4: 0x0013, 0x3e6: 0x886b, 0x3e8: 0x0013,
+	0x3ea: 0x88cb, 0x3eb: 0x890b, 0x3ec: 0x0013, 0x3ed: 0x0013, 0x3ef: 0x0012,
+	0x3f0: 0x0013, 0x3f1: 0x0013, 0x3f2: 0xa453, 0x3f3: 0x0013, 0x3f4: 0x0012, 0x3f5: 0x0010,
+	0x3f6: 0x0010, 0x3f7: 0x0010, 0x3f8: 0x0010, 0x3f9: 0x0012,
+	0x3fc: 0x0012, 0x3fd: 0x0012, 0x3fe: 0x0013, 0x3ff: 0x0013,
+	// Block 0x10, offset 0x400
+	0x400: 0x1a13, 0x401: 0x1a13, 0x402: 0x1e13, 0x403: 0x1e13, 0x404: 0x1a13, 0x405: 0x1a13,
+	0x406: 0x2613, 0x407: 0x2613, 0x408: 0x2a13, 0x409: 0x2a13, 0x40a: 0x2e13, 0x40b: 0x2e13,
+	0x40c: 0x2a13, 0x40d: 0x2a13, 0x40e: 0x2613, 0x40f: 0x2613, 0x410: 0xa752, 0x411: 0xa752,
+	0x412: 0xaa52, 0x413: 0xaa52, 0x414: 0xad52, 0x415: 0xad52, 0x416: 0xaa52, 0x417: 0xaa52,
+	0x418: 0xa752, 0x419: 0xa752, 0x41a: 0x1a12, 0x41b: 0x1a12, 0x41c: 0x1e12, 0x41d: 0x1e12,
+	0x41e: 0x1a12, 0x41f: 0x1a12, 0x420: 0x2612, 0x421: 0x2612, 0x422: 0x2a12, 0x423: 0x2a12,
+	0x424: 0x2e12, 0x425: 0x2e12, 0x426: 0x2a12, 0x427: 0x2a12, 0x428: 0x2612, 0x429: 0x2612,
+	// Block 0x11, offset 0x440
+	0x440: 0x6552, 0x441: 0x6552, 0x442: 0x6552, 0x443: 0x6552, 0x444: 0x6552, 0x445: 0x6552,
+	0x446: 0x6552, 0x447: 0x6552, 0x448: 0x6552, 0x449: 0x6552, 0x44a: 0x6552, 0x44b: 0x6552,
+	0x44c: 0x6552, 0x44d: 0x6552, 0x44e: 0x6552, 0x44f: 0x6552, 0x450: 0xb052, 0x451: 0xb052,
+	0x452: 0xb052, 0x453: 0xb052, 0x454: 0xb052, 0x455: 0xb052, 0x456: 0xb052, 0x457: 0xb052,
+	0x458: 0xb052, 0x459: 0xb052, 0x45a: 0xb052, 0x45b: 0xb052, 0x45c: 0xb052, 0x45d: 0xb052,
+	0x45e: 0xb052, 0x460: 0x0113, 0x461: 0x0112, 0x462: 0x896b, 0x463: 0x8b53,
+	0x464: 0x89cb, 0x465: 0x8a2a, 0x466: 0x8a8a, 0x467: 0x0f13, 0x468: 0x0f12, 0x469: 0x0313,
+	0x46a: 0x0312, 0x46b: 0x0713, 0x46c: 0x0712, 0x46d: 0x8aeb, 0x46e: 0x8b4b, 0x46f: 0x8bab,
+	0x470: 0x8c0b, 0x471: 0x0012, 0x472: 0x0113, 0x473: 0x0112, 0x474: 0x0012, 0x475: 0x0313,
+	0x476: 0x0312, 0x477: 0x0012, 0x478: 0x0012, 0x479: 0x0012, 0x47a: 0x0012, 0x47b: 0x0012,
+	0x47c: 0x0015, 0x47d: 0x0015, 0x47e: 0x8c6b, 0x47f: 0x8ccb,
+	// Block 0x12, offset 0x480
+	0x480: 0x0113, 0x481: 0x0112, 0x482: 0x0113, 0x483: 0x0112, 0x484: 0x0113, 0x485: 0x0112,
+	0x486: 0x0113, 0x487: 0x0112, 0x488: 0x0014, 0x489: 0x0014, 0x48a: 0x0014, 0x48b: 0x0713,
+	0x48c: 0x0712, 0x48d: 0x8d2b, 0x48e: 0x0012, 0x48f: 0x0010, 0x490: 0x0113, 0x491: 0x0112,
+	0x492: 0x0113, 0x493: 0x0112, 0x494: 0x6552, 0x495: 0x0012, 0x496: 0x0113, 0x497: 0x0112,
+	0x498: 0x0113, 0x499: 0x0112, 0x49a: 0x0113, 0x49b: 0x0112, 0x49c: 0x0113, 0x49d: 0x0112,
+	0x49e: 0x0113, 0x49f: 0x0112, 0x4a0: 0x0113, 0x4a1: 0x0112, 0x4a2: 0x0113, 0x4a3: 0x0112,
+	0x4a4: 0x0113, 0x4a5: 0x0112, 0x4a6: 0x0113, 0x4a7: 0x0112, 0x4a8: 0x0113, 0x4a9: 0x0112,
+	0x4aa: 0x8d8b, 0x4ab: 0x8deb, 0x4ac: 0x8e4b, 0x4ad: 0x8eab, 0x4ae: 0x8f0b, 0x4af: 0x0012,
+	0x4b0: 0x8f6b, 0x4b1: 0x8fcb, 0x4b2: 0x902b, 0x4b3: 0xb353, 0x4b4: 0x0113, 0x4b5: 0x0112,
+	0x4b6: 0x0113, 0x4b7: 0x0112, 0x4b8: 0x0113, 0x4b9: 0x0112, 0x4ba: 0x0113, 0x4bb: 0x0112,
+	0x4bc: 0x0113, 0x4bd: 0x0112, 0x4be: 0x0113, 0x4bf: 0x0112,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x90ea, 0x4c1: 0x916a, 0x4c2: 0x91ea, 0x4c3: 0x926a, 0x4c4: 0x931a, 0x4c5: 0x93ca,
+	0x4c6: 0x944a,
+	0x4d3: 0x94ca, 0x4d4: 0x95aa, 0x4d5: 0x968a, 0x4d6: 0x976a, 0x4d7: 0x984a,
+	0x4dd: 0x0010,
+	0x4de: 0x0034, 0x4df: 0x0010, 0x4e0: 0x0010, 0x4e1: 0x0010, 0x4e2: 0x0010, 0x4e3: 0x0010,
+	0x4e4: 0x0010, 0x4e5: 0x0010, 0x4e6: 0x0010, 0x4e7: 0x0010, 0x4e8: 0x0010,
+	0x4ea: 0x0010, 0x4eb: 0x0010, 0x4ec: 0x0010, 0x4ed: 0x0010, 0x4ee: 0x0010, 0x4ef: 0x0010,
+	0x4f0: 0x0010, 0x4f1: 0x0010, 0x4f2: 0x0010, 0x4f3: 0x0010, 0x4f4: 0x0010, 0x4f5: 0x0010,
+	0x4f6: 0x0010, 0x4f8: 0x0010, 0x4f9: 0x0010, 0x4fa: 0x0010, 0x4fb: 0x0010,
+	0x4fc: 0x0010, 0x4fe: 0x0010,
+	// Block 0x14, offset 0x500
+	0x500: 0x2213, 0x501: 0x2213, 0x502: 0x2613, 0x503: 0x2613, 0x504: 0x2213, 0x505: 0x2213,
+	0x506: 0x2e13, 0x507: 0x2e13, 0x508: 0x2213, 0x509: 0x2213, 0x50a: 0x2613, 0x50b: 0x2613,
+	0x50c: 0x2213, 0x50d: 0x2213, 0x50e: 0x3e13, 0x50f: 0x3e13, 0x510: 0x2213, 0x511: 0x2213,
+	0x512: 0x2613, 0x513: 0x2613, 0x514: 0x2213, 0x515: 0x2213, 0x516: 0x2e13, 0x517: 0x2e13,
+	0x518: 0x2213, 0x519: 0x2213, 0x51a: 0x2613, 0x51b: 0x2613, 0x51c: 0x2213, 0x51d: 0x2213,
+	0x51e: 0xbc53, 0x51f: 0xbc53, 0x520: 0xbf53, 0x521: 0xbf53, 0x522: 0x2212, 0x523: 0x2212,
+	0x524: 0x2612, 0x525: 0x2612, 0x526: 0x2212, 0x527: 0x2212, 0x528: 0x2e12, 0x529: 0x2e12,
+	0x52a: 0x2212, 0x52b: 0x2212, 0x52c: 0x2612, 0x52d: 0x2612, 0x52e: 0x2212, 0x52f: 0x2212,
+	0x530: 0x3e12, 0x531: 0x3e12, 0x532: 0x2212, 0x533: 0x2212, 0x534: 0x2612, 0x535: 0x2612,
+	0x536: 0x2212, 0x537: 0x2212, 0x538: 0x2e12, 0x539: 0x2e12, 0x53a: 0x2212, 0x53b: 0x2212,
+	0x53c: 0x2612, 0x53d: 0x2612, 0x53e: 0x2212, 0x53f: 0x2212,
+	// Block 0x15, offset 0x540
+	0x542: 0x0010,
+	0x547: 0x0010, 0x549: 0x0010, 0x54b: 0x0010,
+	0x54d: 0x0010, 0x54e: 0x0010, 0x54f: 0x0010, 0x551: 0x0010,
+	0x552: 0x0010, 0x554: 0x0010, 0x557: 0x0010,
+	0x559: 0x0010, 0x55b: 0x0010, 0x55d: 0x0010,
+	0x55f: 0x0010, 0x561: 0x0010, 0x562: 0x0010,
+	0x564: 0x0010, 0x567: 0x0010, 0x568: 0x0010, 0x569: 0x0010,
+	0x56a: 0x0010, 0x56c: 0x0010, 0x56d: 0x0010, 0x56e: 0x0010, 0x56f: 0x0010,
+	0x570: 0x0010, 0x571: 0x0010, 0x572: 0x0010, 0x574: 0x0010, 0x575: 0x0010,
+	0x576: 0x0010, 0x577: 0x0010, 0x579: 0x0010, 0x57a: 0x0010, 0x57b: 0x0010,
+	0x57c: 0x0010, 0x57e: 0x0010,
+}
+
+// caseIndex: 25 blocks, 1600 entries, 3200 bytes
+// Block 0 is the zero block.
+var caseIndex = [1600]uint16{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x14, 0xc3: 0x15, 0xc4: 0x16, 0xc5: 0x17, 0xc6: 0x01, 0xc7: 0x02,
+	0xc8: 0x18, 0xc9: 0x03, 0xca: 0x04, 0xcb: 0x19, 0xcc: 0x1a, 0xcd: 0x05, 0xce: 0x06, 0xcf: 0x07,
+	0xd0: 0x1b, 0xd1: 0x1c, 0xd2: 0x1d, 0xd3: 0x1e, 0xd4: 0x1f, 0xd5: 0x20, 0xd6: 0x08, 0xd7: 0x21,
+	0xd8: 0x22, 0xd9: 0x23, 0xda: 0x24, 0xdb: 0x25, 0xdc: 0x26, 0xdd: 0x27, 0xde: 0x28, 0xdf: 0x29,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x08, 0xef: 0x09,
+	0xf0: 0x14, 0xf3: 0x16,
+	// Block 0x4, offset 0x100
+	0x120: 0x2a, 0x121: 0x2b, 0x122: 0x2c, 0x123: 0x2d, 0x124: 0x2e, 0x125: 0x2f, 0x126: 0x30, 0x127: 0x31,
+	0x128: 0x32, 0x129: 0x33, 0x12a: 0x34, 0x12b: 0x35, 0x12c: 0x36, 0x12d: 0x37, 0x12e: 0x38, 0x12f: 0x39,
+	0x130: 0x3a, 0x131: 0x3b, 0x132: 0x3c, 0x133: 0x3d, 0x134: 0x3e, 0x135: 0x3f, 0x136: 0x40, 0x137: 0x41,
+	0x138: 0x42, 0x139: 0x43, 0x13a: 0x44, 0x13b: 0x45, 0x13c: 0x46, 0x13d: 0x47, 0x13e: 0x48, 0x13f: 0x49,
+	// Block 0x5, offset 0x140
+	0x140: 0x4a, 0x141: 0x4b, 0x142: 0x4c, 0x143: 0x09, 0x144: 0x24, 0x145: 0x24, 0x146: 0x24, 0x147: 0x24,
+	0x148: 0x24, 0x149: 0x4d, 0x14a: 0x4e, 0x14b: 0x4f, 0x14c: 0x50, 0x14d: 0x51, 0x14e: 0x52, 0x14f: 0x53,
+	0x150: 0x54, 0x151: 0x24, 0x152: 0x24, 0x153: 0x24, 0x154: 0x24, 0x155: 0x24, 0x156: 0x24, 0x157: 0x24,
+	0x158: 0x24, 0x159: 0x55, 0x15a: 0x56, 0x15b: 0x57, 0x15c: 0x58, 0x15d: 0x59, 0x15e: 0x5a, 0x15f: 0x5b,
+	0x160: 0x5c, 0x161: 0x5d, 0x162: 0x5e, 0x163: 0x5f, 0x164: 0x60, 0x165: 0x61, 0x167: 0x62,
+	0x168: 0x63, 0x169: 0x64, 0x16a: 0x65, 0x16b: 0x66, 0x16c: 0x67, 0x16d: 0x68, 0x16e: 0x69, 0x16f: 0x6a,
+	0x170: 0x6b, 0x171: 0x6c, 0x172: 0x6d, 0x173: 0x6e, 0x174: 0x6f, 0x175: 0x70, 0x176: 0x71, 0x177: 0x72,
+	0x178: 0x73, 0x179: 0x73, 0x17a: 0x74, 0x17b: 0x73, 0x17c: 0x75, 0x17d: 0x0a, 0x17e: 0x0b, 0x17f: 0x0c,
+	// Block 0x6, offset 0x180
+	0x180: 0x76, 0x181: 0x77, 0x182: 0x78, 0x183: 0x79, 0x184: 0x0d, 0x185: 0x7a, 0x186: 0x7b,
+	0x192: 0x7c, 0x193: 0x0e,
+	0x1b0: 0x7d, 0x1b1: 0x0f, 0x1b2: 0x73, 0x1b3: 0x7e, 0x1b4: 0x7f, 0x1b5: 0x80, 0x1b6: 0x81, 0x1b7: 0x82,
+	0x1b8: 0x83,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x84, 0x1c2: 0x85, 0x1c3: 0x86, 0x1c4: 0x87, 0x1c5: 0x24, 0x1c6: 0x88,
+	// Block 0x8, offset 0x200
+	0x200: 0x89, 0x201: 0x24, 0x202: 0x24, 0x203: 0x24, 0x204: 0x24, 0x205: 0x24, 0x206: 0x24, 0x207: 0x24,
+	0x208: 0x24, 0x209: 0x24, 0x20a: 0x24, 0x20b: 0x24, 0x20c: 0x24, 0x20d: 0x24, 0x20e: 0x24, 0x20f: 0x24,
+	0x210: 0x24, 0x211: 0x24, 0x212: 0x8a, 0x213: 0x8b, 0x214: 0x24, 0x215: 0x24, 0x216: 0x24, 0x217: 0x24,
+	0x218: 0x8c, 0x219: 0x8d, 0x21a: 0x8e, 0x21b: 0x8f, 0x21c: 0x90, 0x21d: 0x91, 0x21e: 0x10, 0x21f: 0x92,
+	0x220: 0x93, 0x221: 0x94, 0x222: 0x24, 0x223: 0x95, 0x224: 0x96, 0x225: 0x97, 0x226: 0x98, 0x227: 0x99,
+	0x228: 0x9a, 0x229: 0x9b, 0x22a: 0x9c, 0x22b: 0x9d, 0x22c: 0x9e, 0x22d: 0x9f, 0x22e: 0xa0, 0x22f: 0xa1,
+	0x230: 0x24, 0x231: 0x24, 0x232: 0x24, 0x233: 0x24, 0x234: 0x24, 0x235: 0x24, 0x236: 0x24, 0x237: 0x24,
+	0x238: 0x24, 0x239: 0x24, 0x23a: 0x24, 0x23b: 0x24, 0x23c: 0x24, 0x23d: 0x24, 0x23e: 0x24, 0x23f: 0x24,
+	// Block 0x9, offset 0x240
+	0x240: 0x24, 0x241: 0x24, 0x242: 0x24, 0x243: 0x24, 0x244: 0x24, 0x245: 0x24, 0x246: 0x24, 0x247: 0x24,
+	0x248: 0x24, 0x249: 0x24, 0x24a: 0x24, 0x24b: 0x24, 0x24c: 0x24, 0x24d: 0x24, 0x24e: 0x24, 0x24f: 0x24,
+	0x250: 0x24, 0x251: 0x24, 0x252: 0x24, 0x253: 0x24, 0x254: 0x24, 0x255: 0x24, 0x256: 0x24, 0x257: 0x24,
+	0x258: 0x24, 0x259: 0x24, 0x25a: 0x24, 0x25b: 0x24, 0x25c: 0x24, 0x25d: 0x24, 0x25e: 0x24, 0x25f: 0x24,
+	0x260: 0x24, 0x261: 0x24, 0x262: 0x24, 0x263: 0x24, 0x264: 0x24, 0x265: 0x24, 0x266: 0x24, 0x267: 0x24,
+	0x268: 0x24, 0x269: 0x24, 0x26a: 0x24, 0x26b: 0x24, 0x26c: 0x24, 0x26d: 0x24, 0x26e: 0x24, 0x26f: 0x24,
+	0x270: 0x24, 0x271: 0x24, 0x272: 0x24, 0x273: 0x24, 0x274: 0x24, 0x275: 0x24, 0x276: 0x24, 0x277: 0x24,
+	0x278: 0x24, 0x279: 0x24, 0x27a: 0x24, 0x27b: 0x24, 0x27c: 0x24, 0x27d: 0x24, 0x27e: 0x24, 0x27f: 0x24,
+	// Block 0xa, offset 0x280
+	0x280: 0x24, 0x281: 0x24, 0x282: 0x24, 0x283: 0x24, 0x284: 0x24, 0x285: 0x24, 0x286: 0x24, 0x287: 0x24,
+	0x288: 0x24, 0x289: 0x24, 0x28a: 0x24, 0x28b: 0x24, 0x28c: 0x24, 0x28d: 0x24, 0x28e: 0x24, 0x28f: 0x24,
+	0x290: 0x24, 0x291: 0x24, 0x292: 0x24, 0x293: 0x24, 0x294: 0x24, 0x295: 0x24, 0x296: 0x24, 0x297: 0x24,
+	0x298: 0x24, 0x299: 0x24, 0x29a: 0x24, 0x29b: 0x24, 0x29c: 0x24, 0x29d: 0x24, 0x29e: 0xa2, 0x29f: 0xa3,
+	// Block 0xb, offset 0x2c0
+	0x2ec: 0x11, 0x2ed: 0xa4, 0x2ee: 0xa5, 0x2ef: 0xa6,
+	0x2f0: 0x24, 0x2f1: 0x24, 0x2f2: 0x24, 0x2f3: 0x24, 0x2f4: 0xa7, 0x2f5: 0xa8, 0x2f6: 0xa9, 0x2f7: 0xaa,
+	0x2f8: 0xab, 0x2f9: 0xac, 0x2fa: 0x24, 0x2fb: 0xad, 0x2fc: 0xae, 0x2fd: 0xaf, 0x2fe: 0xb0, 0x2ff: 0xb1,
+	// Block 0xc, offset 0x300
+	0x300: 0xb2, 0x301: 0xb3, 0x302: 0x24, 0x303: 0xb4, 0x305: 0xb5, 0x307: 0xb6,
+	0x30a: 0xb7, 0x30b: 0xb8, 0x30c: 0xb9, 0x30d: 0xba, 0x30e: 0xbb, 0x30f: 0xbc,
+	0x310: 0xbd, 0x311: 0xbe, 0x312: 0xbf, 0x313: 0xc0, 0x314: 0xc1, 0x315: 0xc2,
+	0x318: 0x24, 0x319: 0x24, 0x31a: 0x24, 0x31b: 0x24, 0x31c: 0xc3, 0x31d: 0xc4,
+	0x320: 0xc5, 0x321: 0xc6, 0x322: 0xc7, 0x323: 0xc8, 0x324: 0xc9, 0x326: 0xca,
+	0x328: 0xcb, 0x329: 0xcc, 0x32a: 0xcd, 0x32b: 0xce, 0x32c: 0x5f, 0x32d: 0xcf, 0x32e: 0xd0,
+	0x330: 0x24, 0x331: 0xd1, 0x332: 0xd2, 0x333: 0xd3, 0x334: 0xd4,
+	0x33a: 0xd5, 0x33c: 0xd6, 0x33d: 0xd7, 0x33e: 0xd8, 0x33f: 0xd9,
+	// Block 0xd, offset 0x340
+	0x340: 0xda, 0x341: 0xdb, 0x342: 0xdc, 0x343: 0xdd, 0x344: 0xde, 0x345: 0xdf, 0x346: 0xe0, 0x347: 0xe1,
+	0x348: 0xe2, 0x34a: 0xe3, 0x34b: 0xe4, 0x34c: 0xe5, 0x34d: 0xe6,
+	0x350: 0xe7, 0x351: 0xe8, 0x352: 0xe9, 0x353: 0xea, 0x356: 0xeb, 0x357: 0xec,
+	0x358: 0xed, 0x359: 0xee, 0x35a: 0xef, 0x35b: 0xf0, 0x35c: 0xf1,
+	0x360: 0xf2, 0x362: 0xf3, 0x363: 0xf4, 0x364: 0xf5, 0x365: 0xf6, 0x366: 0xf7, 0x367: 0xf8,
+	0x368: 0xf9, 0x369: 0xfa, 0x36a: 0xfb, 0x36b: 0xfc,
+	0x370: 0xfd, 0x371: 0xfe, 0x372: 0xff, 0x374: 0x100, 0x375: 0x101, 0x376: 0x102,
+	0x37b: 0x103, 0x37e: 0x104,
+	// Block 0xe, offset 0x380
+	0x380: 0x24, 0x381: 0x24, 0x382: 0x24, 0x383: 0x24, 0x384: 0x24, 0x385: 0x24, 0x386: 0x24, 0x387: 0x24,
+	0x388: 0x24, 0x389: 0x24, 0x38a: 0x24, 0x38b: 0x24, 0x38c: 0x24, 0x38d: 0x24, 0x38e: 0x105,
+	0x390: 0x24, 0x391: 0x106, 0x392: 0x24, 0x393: 0x24, 0x394: 0x24, 0x395: 0x107,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x24, 0x3c1: 0x24, 0x3c2: 0x24, 0x3c3: 0x24, 0x3c4: 0x24, 0x3c5: 0x24, 0x3c6: 0x24, 0x3c7: 0x24,
+	0x3c8: 0x24, 0x3c9: 0x24, 0x3ca: 0x24, 0x3cb: 0x24, 0x3cc: 0x24, 0x3cd: 0x24, 0x3ce: 0x24, 0x3cf: 0x24,
+	0x3d0: 0x108,
+	// Block 0x10, offset 0x400
+	0x410: 0x24, 0x411: 0x24, 0x412: 0x24, 0x413: 0x24, 0x414: 0x24, 0x415: 0x24, 0x416: 0x24, 0x417: 0x24,
+	0x418: 0x24, 0x419: 0x109,
+	// Block 0x11, offset 0x440
+	0x460: 0x24, 0x461: 0x24, 0x462: 0x24, 0x463: 0x24, 0x464: 0x24, 0x465: 0x24, 0x466: 0x24, 0x467: 0x24,
+	0x468: 0xfc, 0x469: 0x10a, 0x46b: 0x10b, 0x46c: 0x10c, 0x46d: 0x10d, 0x46e: 0x10e,
+	0x479: 0x10f, 0x47c: 0x24, 0x47d: 0x110, 0x47e: 0x111, 0x47f: 0x112,
+	// Block 0x12, offset 0x480
+	0x4b0: 0x24, 0x4b1: 0x113, 0x4b2: 0x114,
+	// Block 0x13, offset 0x4c0
+	0x4c5: 0x115, 0x4c6: 0x116,
+	0x4c9: 0x117,
+	0x4d0: 0x118, 0x4d1: 0x119, 0x4d2: 0x11a, 0x4d3: 0x11b, 0x4d4: 0x11c, 0x4d5: 0x11d, 0x4d6: 0x11e, 0x4d7: 0x11f,
+	0x4d8: 0x120, 0x4d9: 0x121, 0x4da: 0x122, 0x4db: 0x123, 0x4dc: 0x124, 0x4dd: 0x125, 0x4de: 0x126, 0x4df: 0x127,
+	0x4e8: 0x128, 0x4e9: 0x129, 0x4ea: 0x12a,
+	// Block 0x14, offset 0x500
+	0x500: 0x12b, 0x504: 0x12c, 0x505: 0x12d,
+	0x50b: 0x12e,
+	0x520: 0x24, 0x521: 0x24, 0x522: 0x24, 0x523: 0x12f, 0x524: 0x12, 0x525: 0x130,
+	0x538: 0x131, 0x539: 0x13, 0x53a: 0x132,
+	// Block 0x15, offset 0x540
+	0x544: 0x133, 0x545: 0x134, 0x546: 0x135,
+	0x54f: 0x136,
+	0x56f: 0x137,
+	// Block 0x16, offset 0x580
+	0x590: 0x0a, 0x591: 0x0b, 0x592: 0x0c, 0x593: 0x0d, 0x594: 0x0e, 0x596: 0x0f,
+	0x59b: 0x10, 0x59d: 0x11, 0x59e: 0x12, 0x59f: 0x13,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x138, 0x5c1: 0x139, 0x5c4: 0x139, 0x5c5: 0x139, 0x5c6: 0x139, 0x5c7: 0x13a,
+	// Block 0x18, offset 0x600
+	0x620: 0x15,
+}
+
+// sparseOffsets: 296 entries, 592 bytes
+var sparseOffsets = []uint16{0x0, 0x9, 0xf, 0x18, 0x24, 0x2e, 0x34, 0x37, 0x3b, 0x3e, 0x42, 0x4c, 0x4e, 0x57, 0x5e, 0x63, 0x71, 0x72, 0x80, 0x8f, 0x99, 0x9c, 0xa3, 0xab, 0xae, 0xb0, 0xc0, 0xc6, 0xd4, 0xdf, 0xec, 0xf7, 0x103, 0x10d, 0x119, 0x124, 0x130, 0x13c, 0x144, 0x14d, 0x157, 0x162, 0x16e, 0x174, 0x17f, 0x185, 0x18d, 0x190, 0x195, 0x199, 0x19d, 0x1a4, 0x1ad, 0x1b5, 0x1b6, 0x1bf, 0x1c6, 0x1ce, 0x1d4, 0x1d9, 0x1dd, 0x1e0, 0x1e2, 0x1e5, 0x1ea, 0x1eb, 0x1ed, 0x1ef, 0x1f1, 0x1f8, 0x1fd, 0x201, 0x20a, 0x20d, 0x210, 0x216, 0x217, 0x222, 0x223, 0x224, 0x229, 0x236, 0x23f, 0x240, 0x248, 0x251, 0x25a, 0x263, 0x268, 0x26b, 0x276, 0x284, 0x286, 0x28d, 0x291, 0x29d, 0x29e, 0x2a9, 0x2b1, 0x2b9, 0x2bf, 0x2c0, 0x2ce, 0x2d3, 0x2d6, 0x2db, 0x2df, 0x2e5, 0x2ea, 0x2ed, 0x2f2, 0x2f7, 0x2f8, 0x2fe, 0x300, 0x301, 0x303, 0x305, 0x308, 0x309, 0x30b, 0x30e, 0x314, 0x318, 0x31a, 0x31f, 0x326, 0x331, 0x33b, 0x33c, 0x345, 0x349, 0x34e, 0x356, 0x35c, 0x362, 0x36c, 0x371, 0x37a, 0x380, 0x389, 0x38d, 0x395, 0x397, 0x399, 0x39c, 0x39e, 0x3a0, 0x3a1, 0x3a2, 0x3a4, 0x3a6, 0x3ac, 0x3b1, 0x3b3, 0x3ba, 0x3bd, 0x3bf, 0x3c5, 0x3ca, 0x3cc, 0x3cd, 0x3ce, 0x3cf, 0x3d1, 0x3d3, 0x3d5, 0x3d8, 0x3da, 0x3dd, 0x3e5, 0x3e8, 0x3ec, 0x3f4, 0x3f6, 0x3f7, 0x3f8, 0x3fa, 0x400, 0x402, 0x403, 0x405, 0x407, 0x409, 0x416, 0x417, 0x418, 0x41c, 0x41e, 0x41f, 0x420, 0x421, 0x422, 0x425, 0x428, 0x42b, 0x431, 0x432, 0x434, 0x438, 0x43c, 0x442, 0x445, 0x44c, 0x450, 0x454, 0x45d, 0x466, 0x46c, 0x472, 0x47c, 0x486, 0x488, 0x491, 0x497, 0x49d, 0x4a3, 0x4a6, 0x4ac, 0x4af, 0x4b8, 0x4b9, 0x4c0, 0x4c4, 0x4c5, 0x4c8, 0x4d2, 0x4d5, 0x4d7, 0x4de, 0x4e6, 0x4ec, 0x4f2, 0x4f3, 0x4f9, 0x4fc, 0x504, 0x50b, 0x515, 0x51d, 0x520, 0x521, 0x522, 0x523, 0x524, 0x526, 0x527, 0x529, 0x52b, 0x52d, 0x531, 0x532, 0x534, 0x537, 0x539, 0x53c, 0x53e, 0x543, 0x548, 0x54c, 0x54d, 0x550, 0x554, 0x55f, 0x563, 0x56b, 0x570, 0x574, 0x577, 0x57b, 0x57e, 0x581, 0x586, 0x58a, 0x58e, 0x592, 0x596, 0x598, 0x59a, 0x59d, 0x5a2, 0x5a5, 0x5a7, 0x5aa, 0x5ac, 0x5b2, 0x5bb, 0x5c0, 0x5c1, 0x5c4, 0x5c5, 0x5c6, 0x5c7, 0x5c9, 0x5ca, 0x5cb}
+
+// sparseValues: 1483 entries, 5932 bytes
+var sparseValues = [1483]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0004, lo: 0xa8, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xaa},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0004, lo: 0xaf, hi: 0xaf},
+	{value: 0x0004, lo: 0xb4, hi: 0xb4},
+	{value: 0x001a, lo: 0xb5, hi: 0xb5},
+	{value: 0x0054, lo: 0xb7, hi: 0xb7},
+	{value: 0x0004, lo: 0xb8, hi: 0xb8},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	// Block 0x1, offset 0x9
+	{value: 0x2013, lo: 0x80, hi: 0x96},
+	{value: 0x2013, lo: 0x98, hi: 0x9e},
+	{value: 0x009a, lo: 0x9f, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xb6},
+	{value: 0x2012, lo: 0xb8, hi: 0xbe},
+	{value: 0x0252, lo: 0xbf, hi: 0xbf},
+	// Block 0x2, offset 0xf
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x011b, lo: 0xb0, hi: 0xb0},
+	{value: 0x019a, lo: 0xb1, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb7},
+	{value: 0x0012, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x0553, lo: 0xbf, hi: 0xbf},
+	// Block 0x3, offset 0x18
+	{value: 0x0552, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x01da, lo: 0x89, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xb7},
+	{value: 0x0253, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x028a, lo: 0xbf, hi: 0xbf},
+	// Block 0x4, offset 0x24
+	{value: 0x0117, lo: 0x80, hi: 0x9f},
+	{value: 0x2f53, lo: 0xa0, hi: 0xa0},
+	{value: 0x0012, lo: 0xa1, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xb3},
+	{value: 0x0012, lo: 0xb4, hi: 0xb9},
+	{value: 0x090b, lo: 0xba, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x2953, lo: 0xbd, hi: 0xbd},
+	{value: 0x098b, lo: 0xbe, hi: 0xbe},
+	{value: 0x0a0a, lo: 0xbf, hi: 0xbf},
+	// Block 0x5, offset 0x2e
+	{value: 0x0015, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x97},
+	{value: 0x0004, lo: 0x98, hi: 0x9d},
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0015, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xbf},
+	// Block 0x6, offset 0x34
+	{value: 0x0024, lo: 0x80, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbf},
+	// Block 0x7, offset 0x37
+	{value: 0x6553, lo: 0x80, hi: 0x8f},
+	{value: 0x2013, lo: 0x90, hi: 0x9f},
+	{value: 0x5f53, lo: 0xa0, hi: 0xaf},
+	{value: 0x2012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8, offset 0x3b
+	{value: 0x5f52, lo: 0x80, hi: 0x8f},
+	{value: 0x6552, lo: 0x90, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x9, offset 0x3e
+	{value: 0x0117, lo: 0x80, hi: 0x81},
+	{value: 0x0024, lo: 0x83, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xbf},
+	// Block 0xa, offset 0x42
+	{value: 0x0f13, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x0716, lo: 0x8b, hi: 0x8c},
+	{value: 0x0316, lo: 0x8d, hi: 0x8e},
+	{value: 0x0f12, lo: 0x8f, hi: 0x8f},
+	{value: 0x0117, lo: 0x90, hi: 0xbf},
+	// Block 0xb, offset 0x4c
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x6553, lo: 0xb1, hi: 0xbf},
+	// Block 0xc, offset 0x4e
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6853, lo: 0x90, hi: 0x96},
+	{value: 0x0014, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0054, lo: 0x9f, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa0},
+	{value: 0x6552, lo: 0xa1, hi: 0xaf},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0xd, offset 0x57
+	{value: 0x0034, lo: 0x81, hi: 0x82},
+	{value: 0x0024, lo: 0x84, hi: 0x84},
+	{value: 0x0034, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xaa},
+	{value: 0x0010, lo: 0xaf, hi: 0xb3},
+	{value: 0x0054, lo: 0xb4, hi: 0xb4},
+	// Block 0xe, offset 0x5e
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0024, lo: 0x90, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0014, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xf, offset 0x63
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9c},
+	{value: 0x0024, lo: 0x9d, hi: 0x9e},
+	{value: 0x0034, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0034, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x10, offset 0x71
+	{value: 0x0010, lo: 0x80, hi: 0xbf},
+	// Block 0x11, offset 0x72
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0024, lo: 0x9f, hi: 0xa2},
+	{value: 0x0034, lo: 0xa3, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa8},
+	{value: 0x0034, lo: 0xaa, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x12, offset 0x80
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0034, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0034, lo: 0xb1, hi: 0xb1},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0024, lo: 0xbf, hi: 0xbf},
+	// Block 0x13, offset 0x8f
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0024, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x88},
+	{value: 0x0024, lo: 0x89, hi: 0x8a},
+	{value: 0x0010, lo: 0x8d, hi: 0xbf},
+	// Block 0x14, offset 0x99
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x15, offset 0x9c
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xb1},
+	{value: 0x0034, lo: 0xb2, hi: 0xb2},
+	{value: 0x0024, lo: 0xb3, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0x16, offset 0xa3
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x99},
+	{value: 0x0014, lo: 0x9a, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0xa3},
+	{value: 0x0014, lo: 0xa4, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xad},
+	// Block 0x17, offset 0xab
+	{value: 0x0010, lo: 0x80, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0xa0, hi: 0xaa},
+	// Block 0x18, offset 0xae
+	{value: 0x0010, lo: 0xa0, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0x19, offset 0xb0
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0034, lo: 0x93, hi: 0x93},
+	{value: 0x0024, lo: 0x94, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa2},
+	{value: 0x0034, lo: 0xa3, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xa9},
+	{value: 0x0024, lo: 0xaa, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xb2},
+	{value: 0x0024, lo: 0xb3, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	{value: 0x0024, lo: 0xb7, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbf},
+	// Block 0x1a, offset 0xc0
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1b, offset 0xc6
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0x1c, offset 0xd4
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb6, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1d, offset 0xdf
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xb1},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	// Block 0x1e, offset 0xec
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x1f, offset 0xf7
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x99, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x20, offset 0x103
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x21, offset 0x10d
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x85},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xbf},
+	// Block 0x22, offset 0x119
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x23, offset 0x124
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x24, offset 0x130
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0010, lo: 0xa8, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x25, offset 0x13c
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x26, offset 0x144
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb9},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbf},
+	// Block 0x27, offset 0x14d
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x88},
+	{value: 0x0014, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9a},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x28, offset 0x157
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x29, offset 0x162
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb2},
+	// Block 0x2a, offset 0x16e
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x2b, offset 0x174
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x94, hi: 0x97},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xba, hi: 0xbf},
+	// Block 0x2c, offset 0x17f
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x96},
+	{value: 0x0010, lo: 0x9a, hi: 0xb1},
+	{value: 0x0010, lo: 0xb3, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x2d, offset 0x185
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x94},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9f},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	// Block 0x2e, offset 0x18d
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	// Block 0x2f, offset 0x190
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x30, offset 0x195
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	// Block 0x31, offset 0x199
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x32, offset 0x19d
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0034, lo: 0x98, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0034, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x33, offset 0x1a4
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xac},
+	{value: 0x0034, lo: 0xb1, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xba, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x34, offset 0x1ad
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0024, lo: 0x82, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x86, hi: 0x87},
+	{value: 0x0010, lo: 0x88, hi: 0x8c},
+	{value: 0x0014, lo: 0x8d, hi: 0x97},
+	{value: 0x0014, lo: 0x99, hi: 0xbc},
+	// Block 0x35, offset 0x1b5
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	// Block 0x36, offset 0x1b6
+	{value: 0x0010, lo: 0xab, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbe},
+	// Block 0x37, offset 0x1bf
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x96, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x99},
+	{value: 0x0014, lo: 0x9e, hi: 0xa0},
+	{value: 0x0010, lo: 0xa2, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xad},
+	{value: 0x0014, lo: 0xb1, hi: 0xb4},
+	// Block 0x38, offset 0x1c6
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x6c53, lo: 0xa0, hi: 0xbf},
+	// Block 0x39, offset 0x1ce
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x9a, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x3a, offset 0x1d4
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x3b, offset 0x1d9
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x82, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3c, offset 0x1dd
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3d, offset 0x1e0
+	{value: 0x0010, lo: 0x80, hi: 0x9a},
+	{value: 0x0024, lo: 0x9d, hi: 0x9f},
+	// Block 0x3e, offset 0x1e2
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x7453, lo: 0xa0, hi: 0xaf},
+	{value: 0x7853, lo: 0xb0, hi: 0xbf},
+	// Block 0x3f, offset 0x1e5
+	{value: 0x7c53, lo: 0x80, hi: 0x8f},
+	{value: 0x8053, lo: 0x90, hi: 0x9f},
+	{value: 0x7c53, lo: 0xa0, hi: 0xaf},
+	{value: 0x0813, lo: 0xb0, hi: 0xb5},
+	{value: 0x0892, lo: 0xb8, hi: 0xbd},
+	// Block 0x40, offset 0x1ea
+	{value: 0x0010, lo: 0x81, hi: 0xbf},
+	// Block 0x41, offset 0x1eb
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0010, lo: 0xaf, hi: 0xbf},
+	// Block 0x42, offset 0x1ed
+	{value: 0x0010, lo: 0x81, hi: 0x9a},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x43, offset 0x1ef
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb8},
+	// Block 0x44, offset 0x1f1
+	{value: 0x0010, lo: 0x80, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0034, lo: 0x94, hi: 0x94},
+	{value: 0x0010, lo: 0xa0, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	// Block 0x45, offset 0x1f8
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xac},
+	{value: 0x0010, lo: 0xae, hi: 0xb0},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	// Block 0x46, offset 0x1fd
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x47, offset 0x201
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x89, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0014, lo: 0x93, hi: 0x93},
+	{value: 0x0004, lo: 0x97, hi: 0x97},
+	{value: 0x0024, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0x48, offset 0x20a
+	{value: 0x0014, lo: 0x8b, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x49, offset 0x20d
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb8},
+	// Block 0x4a, offset 0x210
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x4b, offset 0x216
+	{value: 0x0010, lo: 0x80, hi: 0xb5},
+	// Block 0x4c, offset 0x217
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbb},
+	// Block 0x4d, offset 0x222
+	{value: 0x0010, lo: 0x86, hi: 0x8f},
+	// Block 0x4e, offset 0x223
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x4f, offset 0x224
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	// Block 0x50, offset 0x229
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x9e},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xac},
+	{value: 0x0010, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xbc},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x51, offset 0x236
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xa7, hi: 0xa7},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	{value: 0x0034, lo: 0xb5, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbc},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x52, offset 0x23f
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	// Block 0x53, offset 0x240
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x54, offset 0x248
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0030, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8b},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xab, hi: 0xab},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	{value: 0x0024, lo: 0xad, hi: 0xb3},
+	// Block 0x55, offset 0x251
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0030, lo: 0xaa, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbf},
+	// Block 0x56, offset 0x25a
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0030, lo: 0xb2, hi: 0xb3},
+	// Block 0x57, offset 0x263
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	// Block 0x58, offset 0x268
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8d, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x59, offset 0x26b
+	{value: 0x31ea, lo: 0x80, hi: 0x80},
+	{value: 0x326a, lo: 0x81, hi: 0x81},
+	{value: 0x32ea, lo: 0x82, hi: 0x82},
+	{value: 0x336a, lo: 0x83, hi: 0x83},
+	{value: 0x33ea, lo: 0x84, hi: 0x84},
+	{value: 0x346a, lo: 0x85, hi: 0x85},
+	{value: 0x34ea, lo: 0x86, hi: 0x86},
+	{value: 0x356a, lo: 0x87, hi: 0x87},
+	{value: 0x35ea, lo: 0x88, hi: 0x88},
+	{value: 0x8353, lo: 0x90, hi: 0xba},
+	{value: 0x8353, lo: 0xbd, hi: 0xbf},
+	// Block 0x5a, offset 0x276
+	{value: 0x0024, lo: 0x90, hi: 0x92},
+	{value: 0x0034, lo: 0x94, hi: 0x99},
+	{value: 0x0024, lo: 0x9a, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9f},
+	{value: 0x0024, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0034, lo: 0xa2, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xb3},
+	{value: 0x0024, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb7},
+	{value: 0x0024, lo: 0xb8, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xba},
+	// Block 0x5b, offset 0x284
+	{value: 0x0012, lo: 0x80, hi: 0xab},
+	{value: 0x0015, lo: 0xac, hi: 0xbf},
+	// Block 0x5c, offset 0x286
+	{value: 0x0015, lo: 0x80, hi: 0xaa},
+	{value: 0x0012, lo: 0xab, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb8},
+	{value: 0x8752, lo: 0xb9, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbc},
+	{value: 0x8b52, lo: 0xbd, hi: 0xbd},
+	{value: 0x0012, lo: 0xbe, hi: 0xbf},
+	// Block 0x5d, offset 0x28d
+	{value: 0x0012, lo: 0x80, hi: 0x8d},
+	{value: 0x8f52, lo: 0x8e, hi: 0x8e},
+	{value: 0x0012, lo: 0x8f, hi: 0x9a},
+	{value: 0x0015, lo: 0x9b, hi: 0xbf},
+	// Block 0x5e, offset 0x291
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0024, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb9},
+	{value: 0x0024, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbd},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x5f, offset 0x29d
+	{value: 0x0117, lo: 0x80, hi: 0xbf},
+	// Block 0x60, offset 0x29e
+	{value: 0x0117, lo: 0x80, hi: 0x95},
+	{value: 0x369a, lo: 0x96, hi: 0x96},
+	{value: 0x374a, lo: 0x97, hi: 0x97},
+	{value: 0x37fa, lo: 0x98, hi: 0x98},
+	{value: 0x38aa, lo: 0x99, hi: 0x99},
+	{value: 0x395a, lo: 0x9a, hi: 0x9a},
+	{value: 0x3a0a, lo: 0x9b, hi: 0x9b},
+	{value: 0x0012, lo: 0x9c, hi: 0x9d},
+	{value: 0x3abb, lo: 0x9e, hi: 0x9e},
+	{value: 0x0012, lo: 0x9f, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x61, offset 0x2a9
+	{value: 0x0812, lo: 0x80, hi: 0x87},
+	{value: 0x0813, lo: 0x88, hi: 0x8f},
+	{value: 0x0812, lo: 0x90, hi: 0x95},
+	{value: 0x0813, lo: 0x98, hi: 0x9d},
+	{value: 0x0812, lo: 0xa0, hi: 0xa7},
+	{value: 0x0813, lo: 0xa8, hi: 0xaf},
+	{value: 0x0812, lo: 0xb0, hi: 0xb7},
+	{value: 0x0813, lo: 0xb8, hi: 0xbf},
+	// Block 0x62, offset 0x2b1
+	{value: 0x0004, lo: 0x8b, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8f},
+	{value: 0x0054, lo: 0x98, hi: 0x99},
+	{value: 0x0054, lo: 0xa4, hi: 0xa4},
+	{value: 0x0054, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xaa, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x63, offset 0x2b9
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x94, hi: 0x94},
+	{value: 0x0014, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa6, hi: 0xaf},
+	{value: 0x0015, lo: 0xb1, hi: 0xb1},
+	{value: 0x0015, lo: 0xbf, hi: 0xbf},
+	// Block 0x64, offset 0x2bf
+	{value: 0x0015, lo: 0x90, hi: 0x9c},
+	// Block 0x65, offset 0x2c0
+	{value: 0x0024, lo: 0x90, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x93},
+	{value: 0x0024, lo: 0x94, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0xa0},
+	{value: 0x0024, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa4},
+	{value: 0x0034, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xa9},
+	{value: 0x0034, lo: 0xaa, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	// Block 0x66, offset 0x2ce
+	{value: 0x0016, lo: 0x85, hi: 0x86},
+	{value: 0x0012, lo: 0x87, hi: 0x89},
+	{value: 0xa452, lo: 0x8e, hi: 0x8e},
+	{value: 0x1013, lo: 0xa0, hi: 0xaf},
+	{value: 0x1012, lo: 0xb0, hi: 0xbf},
+	// Block 0x67, offset 0x2d3
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x88},
+	// Block 0x68, offset 0x2d6
+	{value: 0xa753, lo: 0xb6, hi: 0xb7},
+	{value: 0xaa53, lo: 0xb8, hi: 0xb9},
+	{value: 0xad53, lo: 0xba, hi: 0xbb},
+	{value: 0xaa53, lo: 0xbc, hi: 0xbd},
+	{value: 0xa753, lo: 0xbe, hi: 0xbf},
+	// Block 0x69, offset 0x2db
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6553, lo: 0x90, hi: 0x9f},
+	{value: 0xb053, lo: 0xa0, hi: 0xae},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0x6a, offset 0x2df
+	{value: 0x0117, lo: 0x80, hi: 0xa3},
+	{value: 0x0012, lo: 0xa4, hi: 0xa4},
+	{value: 0x0716, lo: 0xab, hi: 0xac},
+	{value: 0x0316, lo: 0xad, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb3},
+	// Block 0x6b, offset 0x2e5
+	{value: 0x6c52, lo: 0x80, hi: 0x9f},
+	{value: 0x7052, lo: 0xa0, hi: 0xa5},
+	{value: 0x7052, lo: 0xa7, hi: 0xa7},
+	{value: 0x7052, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x6c, offset 0x2ea
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x6d, offset 0x2ed
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0010, lo: 0xb0, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x6e, offset 0x2f2
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9e},
+	{value: 0x0024, lo: 0xa0, hi: 0xbf},
+	// Block 0x6f, offset 0x2f7
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	// Block 0x70, offset 0x2f8
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0xaa, hi: 0xad},
+	{value: 0x0030, lo: 0xae, hi: 0xaf},
+	{value: 0x0004, lo: 0xb1, hi: 0xb5},
+	{value: 0x0014, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	// Block 0x71, offset 0x2fe
+	{value: 0x0034, lo: 0x99, hi: 0x9a},
+	{value: 0x0004, lo: 0x9b, hi: 0x9e},
+	// Block 0x72, offset 0x300
+	{value: 0x0004, lo: 0xbc, hi: 0xbe},
+	// Block 0x73, offset 0x301
+	{value: 0x0010, lo: 0x85, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x74, offset 0x303
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x75, offset 0x305
+	{value: 0x0010, lo: 0x80, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0xbf},
+	// Block 0x76, offset 0x308
+	{value: 0x0010, lo: 0x80, hi: 0x8c},
+	// Block 0x77, offset 0x309
+	{value: 0x0010, lo: 0x90, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x78, offset 0x30b
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x90, hi: 0xab},
+	// Block 0x79, offset 0x30e
+	{value: 0x0117, lo: 0x80, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb2},
+	{value: 0x0024, lo: 0xb4, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x7a, offset 0x314
+	{value: 0x0117, lo: 0x80, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9d},
+	{value: 0x0024, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x7b, offset 0x318
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb1},
+	// Block 0x7c, offset 0x31a
+	{value: 0x0004, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xaf},
+	{value: 0x0012, lo: 0xb0, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xbf},
+	// Block 0x7d, offset 0x31f
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x0015, lo: 0xb0, hi: 0xb0},
+	{value: 0x0012, lo: 0xb1, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x8753, lo: 0xbd, hi: 0xbd},
+	{value: 0x0117, lo: 0xbe, hi: 0xbf},
+	// Block 0x7e, offset 0x326
+	{value: 0x0117, lo: 0x82, hi: 0x83},
+	{value: 0x6553, lo: 0x84, hi: 0x84},
+	{value: 0x908b, lo: 0x85, hi: 0x85},
+	{value: 0x8f53, lo: 0x86, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x0316, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbf},
+	// Block 0x7f, offset 0x331
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x8c, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	// Block 0x80, offset 0x33b
+	{value: 0x0010, lo: 0x80, hi: 0xb3},
+	// Block 0x81, offset 0x33c
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xa0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb7},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x82, offset 0x345
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x83, offset 0x349
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0x92},
+	{value: 0x0030, lo: 0x93, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0x84, offset 0x34e
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x85, offset 0x356
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0004, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x86, offset 0x35c
+	{value: 0x0010, lo: 0x80, hi: 0xa8},
+	{value: 0x0014, lo: 0xa9, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0x87, offset 0x362
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x88, offset 0x36c
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb7, hi: 0xb8},
+	{value: 0x0024, lo: 0xbe, hi: 0xbf},
+	// Block 0x89, offset 0x371
+	{value: 0x0024, lo: 0x81, hi: 0x81},
+	{value: 0x0004, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	// Block 0x8a, offset 0x37a
+	{value: 0x0010, lo: 0x81, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x8e},
+	{value: 0x0010, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8b, offset 0x380
+	{value: 0x0012, lo: 0x80, hi: 0x92},
+	{value: 0xb352, lo: 0x93, hi: 0x93},
+	{value: 0x0012, lo: 0x94, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa8},
+	{value: 0x0014, lo: 0xa9, hi: 0xa9},
+	{value: 0x0004, lo: 0xaa, hi: 0xab},
+	{value: 0x74d2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8c, offset 0x389
+	{value: 0x78d2, lo: 0x80, hi: 0x8f},
+	{value: 0x7cd2, lo: 0x90, hi: 0x9f},
+	{value: 0x80d2, lo: 0xa0, hi: 0xaf},
+	{value: 0x7cd2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8d, offset 0x38d
+	{value: 0x0010, lo: 0x80, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x8e, offset 0x395
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x8f, offset 0x397
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x8b, hi: 0xbb},
+	// Block 0x90, offset 0x399
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0xbf},
+	// Block 0x91, offset 0x39c
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0004, lo: 0xb2, hi: 0xbf},
+	// Block 0x92, offset 0x39e
+	{value: 0x0004, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x93, hi: 0xbf},
+	// Block 0x93, offset 0x3a0
+	{value: 0x0010, lo: 0x80, hi: 0xbd},
+	// Block 0x94, offset 0x3a1
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0x95, offset 0x3a2
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0xbf},
+	// Block 0x96, offset 0x3a4
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0xb0, hi: 0xbb},
+	// Block 0x97, offset 0x3a6
+	{value: 0x0014, lo: 0x80, hi: 0x8f},
+	{value: 0x0054, lo: 0x93, hi: 0x93},
+	{value: 0x0024, lo: 0xa0, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	// Block 0x98, offset 0x3ac
+	{value: 0x0010, lo: 0x8d, hi: 0x8f},
+	{value: 0x0054, lo: 0x92, hi: 0x92},
+	{value: 0x0054, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0xb0, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0x99, offset 0x3b1
+	{value: 0x0010, lo: 0x80, hi: 0xbc},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x9a, offset 0x3b3
+	{value: 0x0054, lo: 0x87, hi: 0x87},
+	{value: 0x0054, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0054, lo: 0x9a, hi: 0x9a},
+	{value: 0x5f53, lo: 0xa1, hi: 0xba},
+	{value: 0x0004, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9b, offset 0x3ba
+	{value: 0x0004, lo: 0x80, hi: 0x80},
+	{value: 0x5f52, lo: 0x81, hi: 0x9a},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	// Block 0x9c, offset 0x3bd
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbe},
+	// Block 0x9d, offset 0x3bf
+	{value: 0x0010, lo: 0x82, hi: 0x87},
+	{value: 0x0010, lo: 0x8a, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0x97},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0004, lo: 0xa3, hi: 0xa3},
+	{value: 0x0014, lo: 0xb9, hi: 0xbb},
+	// Block 0x9e, offset 0x3c5
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0010, lo: 0x8d, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xba},
+	{value: 0x0010, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9f, offset 0x3ca
+	{value: 0x0010, lo: 0x80, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x9d},
+	// Block 0xa0, offset 0x3cc
+	{value: 0x0010, lo: 0x80, hi: 0xba},
+	// Block 0xa1, offset 0x3cd
+	{value: 0x0010, lo: 0x80, hi: 0xb4},
+	// Block 0xa2, offset 0x3ce
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0xa3, offset 0x3cf
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa4, offset 0x3d1
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	// Block 0xa5, offset 0x3d3
+	{value: 0x0010, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xad, hi: 0xbf},
+	// Block 0xa6, offset 0x3d5
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0xb5},
+	{value: 0x0024, lo: 0xb6, hi: 0xba},
+	// Block 0xa7, offset 0x3d8
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa8, offset 0x3da
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x91, hi: 0x95},
+	// Block 0xa9, offset 0x3dd
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x97},
+	{value: 0xb653, lo: 0x98, hi: 0x9f},
+	{value: 0xb953, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbf},
+	// Block 0xaa, offset 0x3e5
+	{value: 0xb652, lo: 0x80, hi: 0x87},
+	{value: 0xb952, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0xab, offset 0x3e8
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0xb953, lo: 0xb0, hi: 0xb7},
+	{value: 0xb653, lo: 0xb8, hi: 0xbf},
+	// Block 0xac, offset 0x3ec
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x93},
+	{value: 0xb952, lo: 0x98, hi: 0x9f},
+	{value: 0xb652, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbb},
+	// Block 0xad, offset 0x3f4
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xae, offset 0x3f6
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	// Block 0xaf, offset 0x3f7
+	{value: 0x0010, lo: 0x80, hi: 0xb6},
+	// Block 0xb0, offset 0x3f8
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	// Block 0xb1, offset 0x3fa
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xb2, offset 0x400
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xb3, offset 0x402
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	// Block 0xb4, offset 0x403
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	// Block 0xb5, offset 0x405
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb9},
+	// Block 0xb6, offset 0x407
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0xb7, offset 0x409
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x8e, hi: 0x8e},
+	{value: 0x0024, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x99, hi: 0xb5},
+	{value: 0x0024, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xb8, offset 0x416
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0xb9, offset 0x417
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	// Block 0xba, offset 0x418
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	// Block 0xbb, offset 0x41c
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	// Block 0xbc, offset 0x41e
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	// Block 0xbd, offset 0x41f
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	// Block 0xbe, offset 0x420
+	{value: 0x5653, lo: 0x80, hi: 0xb2},
+	// Block 0xbf, offset 0x421
+	{value: 0x5652, lo: 0x80, hi: 0xb2},
+	// Block 0xc0, offset 0x422
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xc1, offset 0x425
+	{value: 0x0010, lo: 0x80, hi: 0xa9},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	// Block 0xc2, offset 0x428
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc3, offset 0x42b
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x87},
+	{value: 0x0024, lo: 0x88, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x8b},
+	{value: 0x0024, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	// Block 0xc4, offset 0x431
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc5, offset 0x432
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xc6, offset 0x434
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xc7, offset 0x438
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xc8, offset 0x43c
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	// Block 0xc9, offset 0x442
+	{value: 0x0014, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xca, offset 0x445
+	{value: 0x0024, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0xcb, offset 0x44c
+	{value: 0x0010, lo: 0x84, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	// Block 0xcc, offset 0x450
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xcd, offset 0x454
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x89, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	// Block 0xce, offset 0x45d
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb4},
+	{value: 0x0030, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xb7},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	// Block 0xcf, offset 0x466
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xd0, offset 0x46c
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa2},
+	{value: 0x0014, lo: 0xa3, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xd1, offset 0x472
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0xd2, offset 0x47c
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0030, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9d, hi: 0xa3},
+	{value: 0x0024, lo: 0xa6, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	// Block 0xd3, offset 0x486
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xd4, offset 0x488
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	// Block 0xd5, offset 0x491
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xd6, offset 0x497
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xd7, offset 0x49d
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xd8, offset 0x4a3
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x98, hi: 0x9b},
+	{value: 0x0014, lo: 0x9c, hi: 0x9d},
+	// Block 0xd9, offset 0x4a6
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xda, offset 0x4ac
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xdb, offset 0x4af
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb5},
+	{value: 0x0030, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	// Block 0xdc, offset 0x4b8
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	// Block 0xdd, offset 0x4b9
+	{value: 0x0014, lo: 0x9d, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xde, offset 0x4c0
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	// Block 0xdf, offset 0x4c4
+	{value: 0x5f53, lo: 0xa0, hi: 0xbf},
+	// Block 0xe0, offset 0x4c5
+	{value: 0x5f52, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe1, offset 0x4c8
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8c, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	{value: 0x0030, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe2, offset 0x4d2
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xe3, offset 0x4d5
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xe4, offset 0x4d7
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0014, lo: 0x94, hi: 0x97},
+	{value: 0x0014, lo: 0x9a, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0x9f},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	// Block 0xe5, offset 0x4de
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x8a},
+	{value: 0x0010, lo: 0x8b, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbe},
+	// Block 0xe6, offset 0x4e6
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0014, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x98},
+	{value: 0x0014, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0xbf},
+	// Block 0xe7, offset 0x4ec
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0014, lo: 0x8a, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9d, hi: 0x9d},
+	// Block 0xe8, offset 0x4f2
+	{value: 0x0010, lo: 0x80, hi: 0xb8},
+	// Block 0xe9, offset 0x4f3
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xea, offset 0x4f9
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0xeb, offset 0x4fc
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0014, lo: 0x92, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xa9},
+	{value: 0x0014, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0xec, offset 0x504
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb6},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xed, offset 0x50b
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa5},
+	{value: 0x0010, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xee, offset 0x515
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0014, lo: 0x90, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0x96},
+	{value: 0x0034, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0xef, offset 0x51d
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	// Block 0xf0, offset 0x520
+	{value: 0x0010, lo: 0xb0, hi: 0xb0},
+	// Block 0xf1, offset 0x521
+	{value: 0x0010, lo: 0x80, hi: 0x99},
+	// Block 0xf2, offset 0x522
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	// Block 0xf3, offset 0x523
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	// Block 0xf4, offset 0x524
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	{value: 0x0014, lo: 0xb0, hi: 0xb8},
+	// Block 0xf5, offset 0x526
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	// Block 0xf6, offset 0x527
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0xf7, offset 0x529
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0034, lo: 0xb0, hi: 0xb4},
+	// Block 0xf8, offset 0x52b
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	// Block 0xf9, offset 0x52d
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa3, hi: 0xb7},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0xfa, offset 0x531
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	// Block 0xfb, offset 0x532
+	{value: 0x2013, lo: 0x80, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xbf},
+	// Block 0xfc, offset 0x534
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0xfd, offset 0x537
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x8f, hi: 0x9f},
+	// Block 0xfe, offset 0x539
+	{value: 0x0014, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa3, hi: 0xa4},
+	{value: 0x0030, lo: 0xb0, hi: 0xb1},
+	// Block 0xff, offset 0x53c
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbc},
+	// Block 0x100, offset 0x53e
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0034, lo: 0x9e, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa3},
+	// Block 0x101, offset 0x543
+	{value: 0x0030, lo: 0xa5, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xa9},
+	{value: 0x0030, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbf},
+	// Block 0x102, offset 0x548
+	{value: 0x0034, lo: 0x80, hi: 0x82},
+	{value: 0x0024, lo: 0x85, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8b},
+	{value: 0x0024, lo: 0xaa, hi: 0xad},
+	// Block 0x103, offset 0x54c
+	{value: 0x0024, lo: 0x82, hi: 0x84},
+	// Block 0x104, offset 0x54d
+	{value: 0x0013, lo: 0x80, hi: 0x99},
+	{value: 0x0012, lo: 0x9a, hi: 0xb3},
+	{value: 0x0013, lo: 0xb4, hi: 0xbf},
+	// Block 0x105, offset 0x550
+	{value: 0x0013, lo: 0x80, hi: 0x8d},
+	{value: 0x0012, lo: 0x8e, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0xa7},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x106, offset 0x554
+	{value: 0x0013, lo: 0x80, hi: 0x81},
+	{value: 0x0012, lo: 0x82, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0x9c},
+	{value: 0x0013, lo: 0x9e, hi: 0x9f},
+	{value: 0x0013, lo: 0xa2, hi: 0xa2},
+	{value: 0x0013, lo: 0xa5, hi: 0xa6},
+	{value: 0x0013, lo: 0xa9, hi: 0xac},
+	{value: 0x0013, lo: 0xae, hi: 0xb5},
+	{value: 0x0012, lo: 0xb6, hi: 0xb9},
+	{value: 0x0012, lo: 0xbb, hi: 0xbb},
+	{value: 0x0012, lo: 0xbd, hi: 0xbf},
+	// Block 0x107, offset 0x55f
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0012, lo: 0x85, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x108, offset 0x563
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0013, lo: 0x84, hi: 0x85},
+	{value: 0x0013, lo: 0x87, hi: 0x8a},
+	{value: 0x0013, lo: 0x8d, hi: 0x94},
+	{value: 0x0013, lo: 0x96, hi: 0x9c},
+	{value: 0x0012, lo: 0x9e, hi: 0xb7},
+	{value: 0x0013, lo: 0xb8, hi: 0xb9},
+	{value: 0x0013, lo: 0xbb, hi: 0xbe},
+	// Block 0x109, offset 0x56b
+	{value: 0x0013, lo: 0x80, hi: 0x84},
+	{value: 0x0013, lo: 0x86, hi: 0x86},
+	{value: 0x0013, lo: 0x8a, hi: 0x90},
+	{value: 0x0012, lo: 0x92, hi: 0xab},
+	{value: 0x0013, lo: 0xac, hi: 0xbf},
+	// Block 0x10a, offset 0x570
+	{value: 0x0013, lo: 0x80, hi: 0x85},
+	{value: 0x0012, lo: 0x86, hi: 0x9f},
+	{value: 0x0013, lo: 0xa0, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbf},
+	// Block 0x10b, offset 0x574
+	{value: 0x0012, lo: 0x80, hi: 0x93},
+	{value: 0x0013, lo: 0x94, hi: 0xad},
+	{value: 0x0012, lo: 0xae, hi: 0xbf},
+	// Block 0x10c, offset 0x577
+	{value: 0x0012, lo: 0x80, hi: 0x87},
+	{value: 0x0013, lo: 0x88, hi: 0xa1},
+	{value: 0x0012, lo: 0xa2, hi: 0xbb},
+	{value: 0x0013, lo: 0xbc, hi: 0xbf},
+	// Block 0x10d, offset 0x57b
+	{value: 0x0013, lo: 0x80, hi: 0x95},
+	{value: 0x0012, lo: 0x96, hi: 0xaf},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x10e, offset 0x57e
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0012, lo: 0x8a, hi: 0xa5},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x10f, offset 0x581
+	{value: 0x0013, lo: 0x80, hi: 0x80},
+	{value: 0x0012, lo: 0x82, hi: 0x9a},
+	{value: 0x0012, lo: 0x9c, hi: 0xa1},
+	{value: 0x0013, lo: 0xa2, hi: 0xba},
+	{value: 0x0012, lo: 0xbc, hi: 0xbf},
+	// Block 0x110, offset 0x586
+	{value: 0x0012, lo: 0x80, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0xb4},
+	{value: 0x0012, lo: 0xb6, hi: 0xbf},
+	// Block 0x111, offset 0x58a
+	{value: 0x0012, lo: 0x80, hi: 0x8e},
+	{value: 0x0012, lo: 0x90, hi: 0x95},
+	{value: 0x0013, lo: 0x96, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x112, offset 0x58e
+	{value: 0x0012, lo: 0x80, hi: 0x88},
+	{value: 0x0012, lo: 0x8a, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x113, offset 0x592
+	{value: 0x0012, lo: 0x80, hi: 0x82},
+	{value: 0x0012, lo: 0x84, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8b},
+	{value: 0x0010, lo: 0x8e, hi: 0xbf},
+	// Block 0x114, offset 0x596
+	{value: 0x0014, lo: 0x80, hi: 0xb6},
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x115, offset 0x598
+	{value: 0x0014, lo: 0x80, hi: 0xac},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x116, offset 0x59a
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x9b, hi: 0x9f},
+	{value: 0x0014, lo: 0xa1, hi: 0xaf},
+	// Block 0x117, offset 0x59d
+	{value: 0x0024, lo: 0x80, hi: 0x86},
+	{value: 0x0024, lo: 0x88, hi: 0x98},
+	{value: 0x0024, lo: 0x9b, hi: 0xa1},
+	{value: 0x0024, lo: 0xa3, hi: 0xa4},
+	{value: 0x0024, lo: 0xa6, hi: 0xaa},
+	// Block 0x118, offset 0x5a2
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	// Block 0x119, offset 0x5a5
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	// Block 0x11a, offset 0x5a7
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0024, lo: 0xac, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x11b, offset 0x5aa
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0034, lo: 0x90, hi: 0x96},
+	// Block 0x11c, offset 0x5ac
+	{value: 0xbc52, lo: 0x80, hi: 0x81},
+	{value: 0xbf52, lo: 0x82, hi: 0x83},
+	{value: 0x0024, lo: 0x84, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x11d, offset 0x5b2
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x9f},
+	{value: 0x0010, lo: 0xa1, hi: 0xa2},
+	{value: 0x0010, lo: 0xa4, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb7},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	// Block 0x11e, offset 0x5bb
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x9b},
+	{value: 0x0010, lo: 0xa1, hi: 0xa3},
+	{value: 0x0010, lo: 0xa5, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xbb},
+	// Block 0x11f, offset 0x5c0
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x120, offset 0x5c1
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x121, offset 0x5c4
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	// Block 0x122, offset 0x5c5
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x123, offset 0x5c6
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x124, offset 0x5c7
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0014, lo: 0xa0, hi: 0xbf},
+	// Block 0x125, offset 0x5c9
+	{value: 0x0014, lo: 0x80, hi: 0xbf},
+	// Block 0x126, offset 0x5ca
+	{value: 0x0014, lo: 0x80, hi: 0xaf},
+}
+
+// Total table size 15212 bytes (14KiB); checksum: 1EB13752
diff --git a/vendor/golang.org/x/text/cases/tables13.0.0_test.go b/vendor/golang.org/x/text/cases/tables13.0.0_test.go
new file mode 100644
index 0000000000..37333e43d9
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/tables13.0.0_test.go
@@ -0,0 +1,1208 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+//go:build go1.16 && !go1.21
+// +build go1.16,!go1.21
+
+package cases
+
+var (
+	caseIgnorable = map[rune]bool{
+		0x0027: true,
+		0x002e: true,
+		0x003a: true,
+		0x00b7: true,
+		0x0387: true,
+		0x055f: true,
+		0x05f4: true,
+		0x2018: true,
+		0x2019: true,
+		0x2024: true,
+		0x2027: true,
+		0xfe13: true,
+		0xfe52: true,
+		0xfe55: true,
+		0xff07: true,
+		0xff0e: true,
+		0xff1a: true,
+	}
+
+	special = map[rune]struct{ toLower, toTitle, toUpper string }{
+		0x00df: {"ß", "Ss", "SS"},
+		0x0130: {"i̇", "İ", "İ"},
+		0xfb00: {"ff", "Ff", "FF"},
+		0xfb01: {"fi", "Fi", "FI"},
+		0xfb02: {"fl", "Fl", "FL"},
+		0xfb03: {"ffi", "Ffi", "FFI"},
+		0xfb04: {"ffl", "Ffl", "FFL"},
+		0xfb05: {"ſt", "St", "ST"},
+		0xfb06: {"st", "St", "ST"},
+		0x0587: {"և", "Եւ", "ԵՒ"},
+		0xfb13: {"ﬓ", "Մն", "ՄՆ"},
+		0xfb14: {"ﬔ", "Մե", "ՄԵ"},
+		0xfb15: {"ﬕ", "Մի", "ՄԻ"},
+		0xfb16: {"ﬖ", "Վն", "ՎՆ"},
+		0xfb17: {"ﬗ", "Մխ", "ՄԽ"},
+		0x0149: {"ʼn", "ʼN", "ʼN"},
+		0x0390: {"ΐ", "Ϊ́", "Ϊ́"},
+		0x03b0: {"ΰ", "Ϋ́", "Ϋ́"},
+		0x01f0: {"ǰ", "J̌", "J̌"},
+		0x1e96: {"ẖ", "H̱", "H̱"},
+		0x1e97: {"ẗ", "T̈", "T̈"},
+		0x1e98: {"ẘ", "W̊", "W̊"},
+		0x1e99: {"ẙ", "Y̊", "Y̊"},
+		0x1e9a: {"ẚ", "Aʾ", "Aʾ"},
+		0x1f50: {"ὐ", "Υ̓", "Υ̓"},
+		0x1f52: {"ὒ", "Υ̓̀", "Υ̓̀"},
+		0x1f54: {"ὔ", "Υ̓́", "Υ̓́"},
+		0x1f56: {"ὖ", "Υ̓͂", "Υ̓͂"},
+		0x1fb6: {"ᾶ", "Α͂", "Α͂"},
+		0x1fc6: {"ῆ", "Η͂", "Η͂"},
+		0x1fd2: {"ῒ", "Ϊ̀", "Ϊ̀"},
+		0x1fd3: {"ΐ", "Ϊ́", "Ϊ́"},
+		0x1fd6: {"ῖ", "Ι͂", "Ι͂"},
+		0x1fd7: {"ῗ", "Ϊ͂", "Ϊ͂"},
+		0x1fe2: {"ῢ", "Ϋ̀", "Ϋ̀"},
+		0x1fe3: {"ΰ", "Ϋ́", "Ϋ́"},
+		0x1fe4: {"ῤ", "Ρ̓", "Ρ̓"},
+		0x1fe6: {"ῦ", "Υ͂", "Υ͂"},
+		0x1fe7: {"ῧ", "Ϋ͂", "Ϋ͂"},
+		0x1ff6: {"ῶ", "Ω͂", "Ω͂"},
+		0x1f80: {"ᾀ", "ᾈ", "ἈΙ"},
+		0x1f81: {"ᾁ", "ᾉ", "ἉΙ"},
+		0x1f82: {"ᾂ", "ᾊ", "ἊΙ"},
+		0x1f83: {"ᾃ", "ᾋ", "ἋΙ"},
+		0x1f84: {"ᾄ", "ᾌ", "ἌΙ"},
+		0x1f85: {"ᾅ", "ᾍ", "ἍΙ"},
+		0x1f86: {"ᾆ", "ᾎ", "ἎΙ"},
+		0x1f87: {"ᾇ", "ᾏ", "ἏΙ"},
+		0x1f88: {"ᾀ", "ᾈ", "ἈΙ"},
+		0x1f89: {"ᾁ", "ᾉ", "ἉΙ"},
+		0x1f8a: {"ᾂ", "ᾊ", "ἊΙ"},
+		0x1f8b: {"ᾃ", "ᾋ", "ἋΙ"},
+		0x1f8c: {"ᾄ", "ᾌ", "ἌΙ"},
+		0x1f8d: {"ᾅ", "ᾍ", "ἍΙ"},
+		0x1f8e: {"ᾆ", "ᾎ", "ἎΙ"},
+		0x1f8f: {"ᾇ", "ᾏ", "ἏΙ"},
+		0x1f90: {"ᾐ", "ᾘ", "ἨΙ"},
+		0x1f91: {"ᾑ", "ᾙ", "ἩΙ"},
+		0x1f92: {"ᾒ", "ᾚ", "ἪΙ"},
+		0x1f93: {"ᾓ", "ᾛ", "ἫΙ"},
+		0x1f94: {"ᾔ", "ᾜ", "ἬΙ"},
+		0x1f95: {"ᾕ", "ᾝ", "ἭΙ"},
+		0x1f96: {"ᾖ", "ᾞ", "ἮΙ"},
+		0x1f97: {"ᾗ", "ᾟ", "ἯΙ"},
+		0x1f98: {"ᾐ", "ᾘ", "ἨΙ"},
+		0x1f99: {"ᾑ", "ᾙ", "ἩΙ"},
+		0x1f9a: {"ᾒ", "ᾚ", "ἪΙ"},
+		0x1f9b: {"ᾓ", "ᾛ", "ἫΙ"},
+		0x1f9c: {"ᾔ", "ᾜ", "ἬΙ"},
+		0x1f9d: {"ᾕ", "ᾝ", "ἭΙ"},
+		0x1f9e: {"ᾖ", "ᾞ", "ἮΙ"},
+		0x1f9f: {"ᾗ", "ᾟ", "ἯΙ"},
+		0x1fa0: {"ᾠ", "ᾨ", "ὨΙ"},
+		0x1fa1: {"ᾡ", "ᾩ", "ὩΙ"},
+		0x1fa2: {"ᾢ", "ᾪ", "ὪΙ"},
+		0x1fa3: {"ᾣ", "ᾫ", "ὫΙ"},
+		0x1fa4: {"ᾤ", "ᾬ", "ὬΙ"},
+		0x1fa5: {"ᾥ", "ᾭ", "ὭΙ"},
+		0x1fa6: {"ᾦ", "ᾮ", "ὮΙ"},
+		0x1fa7: {"ᾧ", "ᾯ", "ὯΙ"},
+		0x1fa8: {"ᾠ", "ᾨ", "ὨΙ"},
+		0x1fa9: {"ᾡ", "ᾩ", "ὩΙ"},
+		0x1faa: {"ᾢ", "ᾪ", "ὪΙ"},
+		0x1fab: {"ᾣ", "ᾫ", "ὫΙ"},
+		0x1fac: {"ᾤ", "ᾬ", "ὬΙ"},
+		0x1fad: {"ᾥ", "ᾭ", "ὭΙ"},
+		0x1fae: {"ᾦ", "ᾮ", "ὮΙ"},
+		0x1faf: {"ᾧ", "ᾯ", "ὯΙ"},
+		0x1fb3: {"ᾳ", "ᾼ", "ΑΙ"},
+		0x1fbc: {"ᾳ", "ᾼ", "ΑΙ"},
+		0x1fc3: {"ῃ", "ῌ", "ΗΙ"},
+		0x1fcc: {"ῃ", "ῌ", "ΗΙ"},
+		0x1ff3: {"ῳ", "ῼ", "ΩΙ"},
+		0x1ffc: {"ῳ", "ῼ", "ΩΙ"},
+		0x1fb2: {"ᾲ", "Ὰͅ", "ᾺΙ"},
+		0x1fb4: {"ᾴ", "Άͅ", "ΆΙ"},
+		0x1fc2: {"ῂ", "Ὴͅ", "ῊΙ"},
+		0x1fc4: {"ῄ", "Ήͅ", "ΉΙ"},
+		0x1ff2: {"ῲ", "Ὼͅ", "ῺΙ"},
+		0x1ff4: {"ῴ", "Ώͅ", "ΏΙ"},
+		0x1fb7: {"ᾷ", "ᾼ͂", "Α͂Ι"},
+		0x1fc7: {"ῇ", "ῌ͂", "Η͂Ι"},
+		0x1ff7: {"ῷ", "ῼ͂", "Ω͂Ι"},
+	}
+
+	foldMap = map[rune]struct{ simple, full, special string }{
+		0x0049: {"", "", "ı"},
+		0x00b5: {"μ", "μ", ""},
+		0x00df: {"", "ss", ""},
+		0x0130: {"", "i̇", "i"},
+		0x0149: {"", "ʼn", ""},
+		0x017f: {"s", "s", ""},
+		0x01f0: {"", "ǰ", ""},
+		0x0345: {"ι", "ι", ""},
+		0x0390: {"", "ΐ", ""},
+		0x03b0: {"", "ΰ", ""},
+		0x03c2: {"σ", "σ", ""},
+		0x03d0: {"β", "β", ""},
+		0x03d1: {"θ", "θ", ""},
+		0x03d5: {"φ", "φ", ""},
+		0x03d6: {"π", "π", ""},
+		0x03f0: {"κ", "κ", ""},
+		0x03f1: {"ρ", "ρ", ""},
+		0x03f5: {"ε", "ε", ""},
+		0x0587: {"", "եւ", ""},
+		0x13f8: {"Ᏸ", "Ᏸ", ""},
+		0x13f9: {"Ᏹ", "Ᏹ", ""},
+		0x13fa: {"Ᏺ", "Ᏺ", ""},
+		0x13fb: {"Ᏻ", "Ᏻ", ""},
+		0x13fc: {"Ᏼ", "Ᏼ", ""},
+		0x13fd: {"Ᏽ", "Ᏽ", ""},
+		0x1c80: {"в", "в", ""},
+		0x1c81: {"д", "д", ""},
+		0x1c82: {"о", "о", ""},
+		0x1c83: {"с", "с", ""},
+		0x1c84: {"т", "т", ""},
+		0x1c85: {"т", "т", ""},
+		0x1c86: {"ъ", "ъ", ""},
+		0x1c87: {"ѣ", "ѣ", ""},
+		0x1c88: {"ꙋ", "ꙋ", ""},
+		0x1e96: {"", "ẖ", ""},
+		0x1e97: {"", "ẗ", ""},
+		0x1e98: {"", "ẘ", ""},
+		0x1e99: {"", "ẙ", ""},
+		0x1e9a: {"", "aʾ", ""},
+		0x1e9b: {"ṡ", "ṡ", ""},
+		0x1e9e: {"", "ss", ""},
+		0x1f50: {"", "ὐ", ""},
+		0x1f52: {"", "ὒ", ""},
+		0x1f54: {"", "ὔ", ""},
+		0x1f56: {"", "ὖ", ""},
+		0x1f80: {"", "ἀι", ""},
+		0x1f81: {"", "ἁι", ""},
+		0x1f82: {"", "ἂι", ""},
+		0x1f83: {"", "ἃι", ""},
+		0x1f84: {"", "ἄι", ""},
+		0x1f85: {"", "ἅι", ""},
+		0x1f86: {"", "ἆι", ""},
+		0x1f87: {"", "ἇι", ""},
+		0x1f88: {"", "ἀι", ""},
+		0x1f89: {"", "ἁι", ""},
+		0x1f8a: {"", "ἂι", ""},
+		0x1f8b: {"", "ἃι", ""},
+		0x1f8c: {"", "ἄι", ""},
+		0x1f8d: {"", "ἅι", ""},
+		0x1f8e: {"", "ἆι", ""},
+		0x1f8f: {"", "ἇι", ""},
+		0x1f90: {"", "ἠι", ""},
+		0x1f91: {"", "ἡι", ""},
+		0x1f92: {"", "ἢι", ""},
+		0x1f93: {"", "ἣι", ""},
+		0x1f94: {"", "ἤι", ""},
+		0x1f95: {"", "ἥι", ""},
+		0x1f96: {"", "ἦι", ""},
+		0x1f97: {"", "ἧι", ""},
+		0x1f98: {"", "ἠι", ""},
+		0x1f99: {"", "ἡι", ""},
+		0x1f9a: {"", "ἢι", ""},
+		0x1f9b: {"", "ἣι", ""},
+		0x1f9c: {"", "ἤι", ""},
+		0x1f9d: {"", "ἥι", ""},
+		0x1f9e: {"", "ἦι", ""},
+		0x1f9f: {"", "ἧι", ""},
+		0x1fa0: {"", "ὠι", ""},
+		0x1fa1: {"", "ὡι", ""},
+		0x1fa2: {"", "ὢι", ""},
+		0x1fa3: {"", "ὣι", ""},
+		0x1fa4: {"", "ὤι", ""},
+		0x1fa5: {"", "ὥι", ""},
+		0x1fa6: {"", "ὦι", ""},
+		0x1fa7: {"", "ὧι", ""},
+		0x1fa8: {"", "ὠι", ""},
+		0x1fa9: {"", "ὡι", ""},
+		0x1faa: {"", "ὢι", ""},
+		0x1fab: {"", "ὣι", ""},
+		0x1fac: {"", "ὤι", ""},
+		0x1fad: {"", "ὥι", ""},
+		0x1fae: {"", "ὦι", ""},
+		0x1faf: {"", "ὧι", ""},
+		0x1fb2: {"", "ὰι", ""},
+		0x1fb3: {"", "αι", ""},
+		0x1fb4: {"", "άι", ""},
+		0x1fb6: {"", "ᾶ", ""},
+		0x1fb7: {"", "ᾶι", ""},
+		0x1fbc: {"", "αι", ""},
+		0x1fbe: {"ι", "ι", ""},
+		0x1fc2: {"", "ὴι", ""},
+		0x1fc3: {"", "ηι", ""},
+		0x1fc4: {"", "ήι", ""},
+		0x1fc6: {"", "ῆ", ""},
+		0x1fc7: {"", "ῆι", ""},
+		0x1fcc: {"", "ηι", ""},
+		0x1fd2: {"", "ῒ", ""},
+		0x1fd3: {"", "ΐ", ""},
+		0x1fd6: {"", "ῖ", ""},
+		0x1fd7: {"", "ῗ", ""},
+		0x1fe2: {"", "ῢ", ""},
+		0x1fe3: {"", "ΰ", ""},
+		0x1fe4: {"", "ῤ", ""},
+		0x1fe6: {"", "ῦ", ""},
+		0x1fe7: {"", "ῧ", ""},
+		0x1ff2: {"", "ὼι", ""},
+		0x1ff3: {"", "ωι", ""},
+		0x1ff4: {"", "ώι", ""},
+		0x1ff6: {"", "ῶ", ""},
+		0x1ff7: {"", "ῶι", ""},
+		0x1ffc: {"", "ωι", ""},
+		0xab70: {"Ꭰ", "Ꭰ", ""},
+		0xab71: {"Ꭱ", "Ꭱ", ""},
+		0xab72: {"Ꭲ", "Ꭲ", ""},
+		0xab73: {"Ꭳ", "Ꭳ", ""},
+		0xab74: {"Ꭴ", "Ꭴ", ""},
+		0xab75: {"Ꭵ", "Ꭵ", ""},
+		0xab76: {"Ꭶ", "Ꭶ", ""},
+		0xab77: {"Ꭷ", "Ꭷ", ""},
+		0xab78: {"Ꭸ", "Ꭸ", ""},
+		0xab79: {"Ꭹ", "Ꭹ", ""},
+		0xab7a: {"Ꭺ", "Ꭺ", ""},
+		0xab7b: {"Ꭻ", "Ꭻ", ""},
+		0xab7c: {"Ꭼ", "Ꭼ", ""},
+		0xab7d: {"Ꭽ", "Ꭽ", ""},
+		0xab7e: {"Ꭾ", "Ꭾ", ""},
+		0xab7f: {"Ꭿ", "Ꭿ", ""},
+		0xab80: {"Ꮀ", "Ꮀ", ""},
+		0xab81: {"Ꮁ", "Ꮁ", ""},
+		0xab82: {"Ꮂ", "Ꮂ", ""},
+		0xab83: {"Ꮃ", "Ꮃ", ""},
+		0xab84: {"Ꮄ", "Ꮄ", ""},
+		0xab85: {"Ꮅ", "Ꮅ", ""},
+		0xab86: {"Ꮆ", "Ꮆ", ""},
+		0xab87: {"Ꮇ", "Ꮇ", ""},
+		0xab88: {"Ꮈ", "Ꮈ", ""},
+		0xab89: {"Ꮉ", "Ꮉ", ""},
+		0xab8a: {"Ꮊ", "Ꮊ", ""},
+		0xab8b: {"Ꮋ", "Ꮋ", ""},
+		0xab8c: {"Ꮌ", "Ꮌ", ""},
+		0xab8d: {"Ꮍ", "Ꮍ", ""},
+		0xab8e: {"Ꮎ", "Ꮎ", ""},
+		0xab8f: {"Ꮏ", "Ꮏ", ""},
+		0xab90: {"Ꮐ", "Ꮐ", ""},
+		0xab91: {"Ꮑ", "Ꮑ", ""},
+		0xab92: {"Ꮒ", "Ꮒ", ""},
+		0xab93: {"Ꮓ", "Ꮓ", ""},
+		0xab94: {"Ꮔ", "Ꮔ", ""},
+		0xab95: {"Ꮕ", "Ꮕ", ""},
+		0xab96: {"Ꮖ", "Ꮖ", ""},
+		0xab97: {"Ꮗ", "Ꮗ", ""},
+		0xab98: {"Ꮘ", "Ꮘ", ""},
+		0xab99: {"Ꮙ", "Ꮙ", ""},
+		0xab9a: {"Ꮚ", "Ꮚ", ""},
+		0xab9b: {"Ꮛ", "Ꮛ", ""},
+		0xab9c: {"Ꮜ", "Ꮜ", ""},
+		0xab9d: {"Ꮝ", "Ꮝ", ""},
+		0xab9e: {"Ꮞ", "Ꮞ", ""},
+		0xab9f: {"Ꮟ", "Ꮟ", ""},
+		0xaba0: {"Ꮠ", "Ꮠ", ""},
+		0xaba1: {"Ꮡ", "Ꮡ", ""},
+		0xaba2: {"Ꮢ", "Ꮢ", ""},
+		0xaba3: {"Ꮣ", "Ꮣ", ""},
+		0xaba4: {"Ꮤ", "Ꮤ", ""},
+		0xaba5: {"Ꮥ", "Ꮥ", ""},
+		0xaba6: {"Ꮦ", "Ꮦ", ""},
+		0xaba7: {"Ꮧ", "Ꮧ", ""},
+		0xaba8: {"Ꮨ", "Ꮨ", ""},
+		0xaba9: {"Ꮩ", "Ꮩ", ""},
+		0xabaa: {"Ꮪ", "Ꮪ", ""},
+		0xabab: {"Ꮫ", "Ꮫ", ""},
+		0xabac: {"Ꮬ", "Ꮬ", ""},
+		0xabad: {"Ꮭ", "Ꮭ", ""},
+		0xabae: {"Ꮮ", "Ꮮ", ""},
+		0xabaf: {"Ꮯ", "Ꮯ", ""},
+		0xabb0: {"Ꮰ", "Ꮰ", ""},
+		0xabb1: {"Ꮱ", "Ꮱ", ""},
+		0xabb2: {"Ꮲ", "Ꮲ", ""},
+		0xabb3: {"Ꮳ", "Ꮳ", ""},
+		0xabb4: {"Ꮴ", "Ꮴ", ""},
+		0xabb5: {"Ꮵ", "Ꮵ", ""},
+		0xabb6: {"Ꮶ", "Ꮶ", ""},
+		0xabb7: {"Ꮷ", "Ꮷ", ""},
+		0xabb8: {"Ꮸ", "Ꮸ", ""},
+		0xabb9: {"Ꮹ", "Ꮹ", ""},
+		0xabba: {"Ꮺ", "Ꮺ", ""},
+		0xabbb: {"Ꮻ", "Ꮻ", ""},
+		0xabbc: {"Ꮼ", "Ꮼ", ""},
+		0xabbd: {"Ꮽ", "Ꮽ", ""},
+		0xabbe: {"Ꮾ", "Ꮾ", ""},
+		0xabbf: {"Ꮿ", "Ꮿ", ""},
+		0xfb00: {"", "ff", ""},
+		0xfb01: {"", "fi", ""},
+		0xfb02: {"", "fl", ""},
+		0xfb03: {"", "ffi", ""},
+		0xfb04: {"", "ffl", ""},
+		0xfb05: {"", "st", ""},
+		0xfb06: {"", "st", ""},
+		0xfb13: {"", "մն", ""},
+		0xfb14: {"", "մե", ""},
+		0xfb15: {"", "մի", ""},
+		0xfb16: {"", "վն", ""},
+		0xfb17: {"", "մխ", ""},
+	}
+
+	breakProp = []struct{ lo, hi rune }{
+		{0x0, 0x26},
+		{0x28, 0x2d},
+		{0x2f, 0x2f},
+		{0x3b, 0x40},
+		{0x5b, 0x5e},
+		{0x60, 0x60},
+		{0x7b, 0xa9},
+		{0xab, 0xac},
+		{0xae, 0xb4},
+		{0xb6, 0xb6},
+		{0xb8, 0xb9},
+		{0xbb, 0xbf},
+		{0xd7, 0xd7},
+		{0xf7, 0xf7},
+		{0x2d8, 0x2dd},
+		{0x375, 0x375},
+		{0x378, 0x379},
+		{0x37e, 0x37e},
+		{0x380, 0x385},
+		{0x38b, 0x38b},
+		{0x38d, 0x38d},
+		{0x3a2, 0x3a2},
+		{0x3f6, 0x3f6},
+		{0x482, 0x482},
+		{0x530, 0x530},
+		{0x557, 0x558},
+		{0x55d, 0x55d},
+		{0x589, 0x589},
+		{0x58b, 0x590},
+		{0x5be, 0x5be},
+		{0x5c0, 0x5c0},
+		{0x5c3, 0x5c3},
+		{0x5c6, 0x5c6},
+		{0x5c8, 0x5cf},
+		{0x5eb, 0x5ee},
+		{0x5f5, 0x5ff},
+		{0x606, 0x60f},
+		{0x61b, 0x61b},
+		{0x61d, 0x61f},
+		{0x66a, 0x66a},
+		{0x66c, 0x66d},
+		{0x6d4, 0x6d4},
+		{0x6de, 0x6de},
+		{0x6e9, 0x6e9},
+		{0x6fd, 0x6fe},
+		{0x700, 0x70e},
+		{0x74b, 0x74c},
+		{0x7b2, 0x7bf},
+		{0x7f6, 0x7f9},
+		{0x7fb, 0x7fc},
+		{0x7fe, 0x7ff},
+		{0x82e, 0x83f},
+		{0x85c, 0x85f},
+		{0x86b, 0x89f},
+		{0x8b5, 0x8b5},
+		{0x8c8, 0x8d2},
+		{0x964, 0x965},
+		{0x970, 0x970},
+		{0x984, 0x984},
+		{0x98d, 0x98e},
+		{0x991, 0x992},
+		{0x9a9, 0x9a9},
+		{0x9b1, 0x9b1},
+		{0x9b3, 0x9b5},
+		{0x9ba, 0x9bb},
+		{0x9c5, 0x9c6},
+		{0x9c9, 0x9ca},
+		{0x9cf, 0x9d6},
+		{0x9d8, 0x9db},
+		{0x9de, 0x9de},
+		{0x9e4, 0x9e5},
+		{0x9f2, 0x9fb},
+		{0x9fd, 0x9fd},
+		{0x9ff, 0xa00},
+		{0xa04, 0xa04},
+		{0xa0b, 0xa0e},
+		{0xa11, 0xa12},
+		{0xa29, 0xa29},
+		{0xa31, 0xa31},
+		{0xa34, 0xa34},
+		{0xa37, 0xa37},
+		{0xa3a, 0xa3b},
+		{0xa3d, 0xa3d},
+		{0xa43, 0xa46},
+		{0xa49, 0xa4a},
+		{0xa4e, 0xa50},
+		{0xa52, 0xa58},
+		{0xa5d, 0xa5d},
+		{0xa5f, 0xa65},
+		{0xa76, 0xa80},
+		{0xa84, 0xa84},
+		{0xa8e, 0xa8e},
+		{0xa92, 0xa92},
+		{0xaa9, 0xaa9},
+		{0xab1, 0xab1},
+		{0xab4, 0xab4},
+		{0xaba, 0xabb},
+		{0xac6, 0xac6},
+		{0xaca, 0xaca},
+		{0xace, 0xacf},
+		{0xad1, 0xadf},
+		{0xae4, 0xae5},
+		{0xaf0, 0xaf8},
+		{0xb00, 0xb00},
+		{0xb04, 0xb04},
+		{0xb0d, 0xb0e},
+		{0xb11, 0xb12},
+		{0xb29, 0xb29},
+		{0xb31, 0xb31},
+		{0xb34, 0xb34},
+		{0xb3a, 0xb3b},
+		{0xb45, 0xb46},
+		{0xb49, 0xb4a},
+		{0xb4e, 0xb54},
+		{0xb58, 0xb5b},
+		{0xb5e, 0xb5e},
+		{0xb64, 0xb65},
+		{0xb70, 0xb70},
+		{0xb72, 0xb81},
+		{0xb84, 0xb84},
+		{0xb8b, 0xb8d},
+		{0xb91, 0xb91},
+		{0xb96, 0xb98},
+		{0xb9b, 0xb9b},
+		{0xb9d, 0xb9d},
+		{0xba0, 0xba2},
+		{0xba5, 0xba7},
+		{0xbab, 0xbad},
+		{0xbba, 0xbbd},
+		{0xbc3, 0xbc5},
+		{0xbc9, 0xbc9},
+		{0xbce, 0xbcf},
+		{0xbd1, 0xbd6},
+		{0xbd8, 0xbe5},
+		{0xbf0, 0xbff},
+		{0xc0d, 0xc0d},
+		{0xc11, 0xc11},
+		{0xc29, 0xc29},
+		{0xc3a, 0xc3c},
+		{0xc45, 0xc45},
+		{0xc49, 0xc49},
+		{0xc4e, 0xc54},
+		{0xc57, 0xc57},
+		{0xc5b, 0xc5f},
+		{0xc64, 0xc65},
+		{0xc70, 0xc7f},
+		{0xc84, 0xc84},
+		{0xc8d, 0xc8d},
+		{0xc91, 0xc91},
+		{0xca9, 0xca9},
+		{0xcb4, 0xcb4},
+		{0xcba, 0xcbb},
+		{0xcc5, 0xcc5},
+		{0xcc9, 0xcc9},
+		{0xcce, 0xcd4},
+		{0xcd7, 0xcdd},
+		{0xcdf, 0xcdf},
+		{0xce4, 0xce5},
+		{0xcf0, 0xcf0},
+		{0xcf3, 0xcff},
+		{0xd0d, 0xd0d},
+		{0xd11, 0xd11},
+		{0xd45, 0xd45},
+		{0xd49, 0xd49},
+		{0xd4f, 0xd53},
+		{0xd58, 0xd5e},
+		{0xd64, 0xd65},
+		{0xd70, 0xd79},
+		{0xd80, 0xd80},
+		{0xd84, 0xd84},
+		{0xd97, 0xd99},
+		{0xdb2, 0xdb2},
+		{0xdbc, 0xdbc},
+		{0xdbe, 0xdbf},
+		{0xdc7, 0xdc9},
+		{0xdcb, 0xdce},
+		{0xdd5, 0xdd5},
+		{0xdd7, 0xdd7},
+		{0xde0, 0xde5},
+		{0xdf0, 0xdf1},
+		{0xdf4, 0xe30},
+		{0xe32, 0xe33},
+		{0xe3b, 0xe46},
+		{0xe4f, 0xe4f},
+		{0xe5a, 0xeb0},
+		{0xeb2, 0xeb3},
+		{0xebd, 0xec7},
+		{0xece, 0xecf},
+		{0xeda, 0xeff},
+		{0xf01, 0xf17},
+		{0xf1a, 0xf1f},
+		{0xf2a, 0xf34},
+		{0xf36, 0xf36},
+		{0xf38, 0xf38},
+		{0xf3a, 0xf3d},
+		{0xf48, 0xf48},
+		{0xf6d, 0xf70},
+		{0xf85, 0xf85},
+		{0xf98, 0xf98},
+		{0xfbd, 0xfc5},
+		{0xfc7, 0x102a},
+		{0x103f, 0x103f},
+		{0x104a, 0x1055},
+		{0x105a, 0x105d},
+		{0x1061, 0x1061},
+		{0x1065, 0x1066},
+		{0x106e, 0x1070},
+		{0x1075, 0x1081},
+		{0x108e, 0x108e},
+		{0x109e, 0x109f},
+		{0x10c6, 0x10c6},
+		{0x10c8, 0x10cc},
+		{0x10ce, 0x10cf},
+		{0x10fb, 0x10fb},
+		{0x1249, 0x1249},
+		{0x124e, 0x124f},
+		{0x1257, 0x1257},
+		{0x1259, 0x1259},
+		{0x125e, 0x125f},
+		{0x1289, 0x1289},
+		{0x128e, 0x128f},
+		{0x12b1, 0x12b1},
+		{0x12b6, 0x12b7},
+		{0x12bf, 0x12bf},
+		{0x12c1, 0x12c1},
+		{0x12c6, 0x12c7},
+		{0x12d7, 0x12d7},
+		{0x1311, 0x1311},
+		{0x1316, 0x1317},
+		{0x135b, 0x135c},
+		{0x1360, 0x137f},
+		{0x1390, 0x139f},
+		{0x13f6, 0x13f7},
+		{0x13fe, 0x1400},
+		{0x166d, 0x166e},
+		{0x1680, 0x1680},
+		{0x169b, 0x169f},
+		{0x16eb, 0x16ed},
+		{0x16f9, 0x16ff},
+		{0x170d, 0x170d},
+		{0x1715, 0x171f},
+		{0x1735, 0x173f},
+		{0x1754, 0x175f},
+		{0x176d, 0x176d},
+		{0x1771, 0x1771},
+		{0x1774, 0x17b3},
+		{0x17d4, 0x17dc},
+		{0x17de, 0x17df},
+		{0x17ea, 0x180a},
+		{0x180f, 0x180f},
+		{0x181a, 0x181f},
+		{0x1879, 0x187f},
+		{0x18ab, 0x18af},
+		{0x18f6, 0x18ff},
+		{0x191f, 0x191f},
+		{0x192c, 0x192f},
+		{0x193c, 0x1945},
+		{0x1950, 0x19cf},
+		{0x19da, 0x19ff},
+		{0x1a1c, 0x1a54},
+		{0x1a5f, 0x1a5f},
+		{0x1a7d, 0x1a7e},
+		{0x1a8a, 0x1a8f},
+		{0x1a9a, 0x1aaf},
+		{0x1ac1, 0x1aff},
+		{0x1b4c, 0x1b4f},
+		{0x1b5a, 0x1b6a},
+		{0x1b74, 0x1b7f},
+		{0x1bf4, 0x1bff},
+		{0x1c38, 0x1c3f},
+		{0x1c4a, 0x1c4c},
+		{0x1c7e, 0x1c7f},
+		{0x1c89, 0x1c8f},
+		{0x1cbb, 0x1cbc},
+		{0x1cc0, 0x1ccf},
+		{0x1cd3, 0x1cd3},
+		{0x1cfb, 0x1cff},
+		{0x1dfa, 0x1dfa},
+		{0x1f16, 0x1f17},
+		{0x1f1e, 0x1f1f},
+		{0x1f46, 0x1f47},
+		{0x1f4e, 0x1f4f},
+		{0x1f58, 0x1f58},
+		{0x1f5a, 0x1f5a},
+		{0x1f5c, 0x1f5c},
+		{0x1f5e, 0x1f5e},
+		{0x1f7e, 0x1f7f},
+		{0x1fb5, 0x1fb5},
+		{0x1fbd, 0x1fbd},
+		{0x1fbf, 0x1fc1},
+		{0x1fc5, 0x1fc5},
+		{0x1fcd, 0x1fcf},
+		{0x1fd4, 0x1fd5},
+		{0x1fdc, 0x1fdf},
+		{0x1fed, 0x1ff1},
+		{0x1ff5, 0x1ff5},
+		{0x1ffd, 0x200b},
+		{0x2010, 0x2017},
+		{0x201a, 0x2023},
+		{0x2025, 0x2026},
+		{0x2028, 0x2029},
+		{0x2030, 0x203e},
+		{0x2041, 0x2053},
+		{0x2055, 0x205f},
+		{0x2065, 0x2065},
+		{0x2070, 0x2070},
+		{0x2072, 0x207e},
+		{0x2080, 0x208f},
+		{0x209d, 0x20cf},
+		{0x20f1, 0x2101},
+		{0x2103, 0x2106},
+		{0x2108, 0x2109},
+		{0x2114, 0x2114},
+		{0x2116, 0x2118},
+		{0x211e, 0x2123},
+		{0x2125, 0x2125},
+		{0x2127, 0x2127},
+		{0x2129, 0x2129},
+		{0x212e, 0x212e},
+		{0x213a, 0x213b},
+		{0x2140, 0x2144},
+		{0x214a, 0x214d},
+		{0x214f, 0x215f},
+		{0x2189, 0x24b5},
+		{0x24ea, 0x2bff},
+		{0x2c2f, 0x2c2f},
+		{0x2c5f, 0x2c5f},
+		{0x2ce5, 0x2cea},
+		{0x2cf4, 0x2cff},
+		{0x2d26, 0x2d26},
+		{0x2d28, 0x2d2c},
+		{0x2d2e, 0x2d2f},
+		{0x2d68, 0x2d6e},
+		{0x2d70, 0x2d7e},
+		{0x2d97, 0x2d9f},
+		{0x2da7, 0x2da7},
+		{0x2daf, 0x2daf},
+		{0x2db7, 0x2db7},
+		{0x2dbf, 0x2dbf},
+		{0x2dc7, 0x2dc7},
+		{0x2dcf, 0x2dcf},
+		{0x2dd7, 0x2dd7},
+		{0x2ddf, 0x2ddf},
+		{0x2e00, 0x2e2e},
+		{0x2e30, 0x3004},
+		{0x3006, 0x3029},
+		{0x3030, 0x303a},
+		{0x303d, 0x3098},
+		{0x309b, 0x3104},
+		{0x3130, 0x3130},
+		{0x318f, 0x319f},
+		{0x31c0, 0x9fff},
+		{0xa48d, 0xa4cf},
+		{0xa4fe, 0xa4ff},
+		{0xa60d, 0xa60f},
+		{0xa62c, 0xa63f},
+		{0xa673, 0xa673},
+		{0xa67e, 0xa67e},
+		{0xa6f2, 0xa707},
+		{0xa7c0, 0xa7c1},
+		{0xa7cb, 0xa7f4},
+		{0xa828, 0xa82b},
+		{0xa82d, 0xa83f},
+		{0xa874, 0xa87f},
+		{0xa8c6, 0xa8cf},
+		{0xa8da, 0xa8df},
+		{0xa8f8, 0xa8fa},
+		{0xa8fc, 0xa8fc},
+		{0xa92e, 0xa92f},
+		{0xa954, 0xa95f},
+		{0xa97d, 0xa97f},
+		{0xa9c1, 0xa9ce},
+		{0xa9da, 0xa9e4},
+		{0xa9e6, 0xa9ef},
+		{0xa9fa, 0xa9ff},
+		{0xaa37, 0xaa3f},
+		{0xaa4e, 0xaa4f},
+		{0xaa5a, 0xaa7a},
+		{0xaa7e, 0xaaaf},
+		{0xaab1, 0xaab1},
+		{0xaab5, 0xaab6},
+		{0xaab9, 0xaabd},
+		{0xaac0, 0xaac0},
+		{0xaac2, 0xaadf},
+		{0xaaf0, 0xaaf1},
+		{0xaaf7, 0xab00},
+		{0xab07, 0xab08},
+		{0xab0f, 0xab10},
+		{0xab17, 0xab1f},
+		{0xab27, 0xab27},
+		{0xab2f, 0xab2f},
+		{0xab6a, 0xab6f},
+		{0xabeb, 0xabeb},
+		{0xabee, 0xabef},
+		{0xabfa, 0xabff},
+		{0xd7a4, 0xd7af},
+		{0xd7c7, 0xd7ca},
+		{0xd7fc, 0xfaff},
+		{0xfb07, 0xfb12},
+		{0xfb18, 0xfb1c},
+		{0xfb29, 0xfb29},
+		{0xfb37, 0xfb37},
+		{0xfb3d, 0xfb3d},
+		{0xfb3f, 0xfb3f},
+		{0xfb42, 0xfb42},
+		{0xfb45, 0xfb45},
+		{0xfbb2, 0xfbd2},
+		{0xfd3e, 0xfd4f},
+		{0xfd90, 0xfd91},
+		{0xfdc8, 0xfdef},
+		{0xfdfc, 0xfdff},
+		{0xfe10, 0xfe12},
+		{0xfe14, 0xfe1f},
+		{0xfe30, 0xfe32},
+		{0xfe35, 0xfe4c},
+		{0xfe50, 0xfe51},
+		{0xfe53, 0xfe54},
+		{0xfe56, 0xfe6f},
+		{0xfe75, 0xfe75},
+		{0xfefd, 0xfefe},
+		{0xff00, 0xff06},
+		{0xff08, 0xff0d},
+		{0xff0f, 0xff0f},
+		{0xff1b, 0xff20},
+		{0xff3b, 0xff3e},
+		{0xff40, 0xff40},
+		{0xff5b, 0xff9d},
+		{0xffbf, 0xffc1},
+		{0xffc8, 0xffc9},
+		{0xffd0, 0xffd1},
+		{0xffd8, 0xffd9},
+		{0xffdd, 0xfff8},
+		{0xfffc, 0xffff},
+		{0x1000c, 0x1000c},
+		{0x10027, 0x10027},
+		{0x1003b, 0x1003b},
+		{0x1003e, 0x1003e},
+		{0x1004e, 0x1004f},
+		{0x1005e, 0x1007f},
+		{0x100fb, 0x1013f},
+		{0x10175, 0x101fc},
+		{0x101fe, 0x1027f},
+		{0x1029d, 0x1029f},
+		{0x102d1, 0x102df},
+		{0x102e1, 0x102ff},
+		{0x10320, 0x1032c},
+		{0x1034b, 0x1034f},
+		{0x1037b, 0x1037f},
+		{0x1039e, 0x1039f},
+		{0x103c4, 0x103c7},
+		{0x103d0, 0x103d0},
+		{0x103d6, 0x103ff},
+		{0x1049e, 0x1049f},
+		{0x104aa, 0x104af},
+		{0x104d4, 0x104d7},
+		{0x104fc, 0x104ff},
+		{0x10528, 0x1052f},
+		{0x10564, 0x105ff},
+		{0x10737, 0x1073f},
+		{0x10756, 0x1075f},
+		{0x10768, 0x107ff},
+		{0x10806, 0x10807},
+		{0x10809, 0x10809},
+		{0x10836, 0x10836},
+		{0x10839, 0x1083b},
+		{0x1083d, 0x1083e},
+		{0x10856, 0x1085f},
+		{0x10877, 0x1087f},
+		{0x1089f, 0x108df},
+		{0x108f3, 0x108f3},
+		{0x108f6, 0x108ff},
+		{0x10916, 0x1091f},
+		{0x1093a, 0x1097f},
+		{0x109b8, 0x109bd},
+		{0x109c0, 0x109ff},
+		{0x10a04, 0x10a04},
+		{0x10a07, 0x10a0b},
+		{0x10a14, 0x10a14},
+		{0x10a18, 0x10a18},
+		{0x10a36, 0x10a37},
+		{0x10a3b, 0x10a3e},
+		{0x10a40, 0x10a5f},
+		{0x10a7d, 0x10a7f},
+		{0x10a9d, 0x10abf},
+		{0x10ac8, 0x10ac8},
+		{0x10ae7, 0x10aff},
+		{0x10b36, 0x10b3f},
+		{0x10b56, 0x10b5f},
+		{0x10b73, 0x10b7f},
+		{0x10b92, 0x10bff},
+		{0x10c49, 0x10c7f},
+		{0x10cb3, 0x10cbf},
+		{0x10cf3, 0x10cff},
+		{0x10d28, 0x10d2f},
+		{0x10d3a, 0x10e7f},
+		{0x10eaa, 0x10eaa},
+		{0x10ead, 0x10eaf},
+		{0x10eb2, 0x10eff},
+		{0x10f1d, 0x10f26},
+		{0x10f28, 0x10f2f},
+		{0x10f51, 0x10faf},
+		{0x10fc5, 0x10fdf},
+		{0x10ff7, 0x10fff},
+		{0x11047, 0x11065},
+		{0x11070, 0x1107e},
+		{0x110bb, 0x110bc},
+		{0x110be, 0x110cc},
+		{0x110ce, 0x110cf},
+		{0x110e9, 0x110ef},
+		{0x110fa, 0x110ff},
+		{0x11135, 0x11135},
+		{0x11140, 0x11143},
+		{0x11148, 0x1114f},
+		{0x11174, 0x11175},
+		{0x11177, 0x1117f},
+		{0x111c5, 0x111c8},
+		{0x111cd, 0x111cd},
+		{0x111db, 0x111db},
+		{0x111dd, 0x111ff},
+		{0x11212, 0x11212},
+		{0x11238, 0x1123d},
+		{0x1123f, 0x1127f},
+		{0x11287, 0x11287},
+		{0x11289, 0x11289},
+		{0x1128e, 0x1128e},
+		{0x1129e, 0x1129e},
+		{0x112a9, 0x112af},
+		{0x112eb, 0x112ef},
+		{0x112fa, 0x112ff},
+		{0x11304, 0x11304},
+		{0x1130d, 0x1130e},
+		{0x11311, 0x11312},
+		{0x11329, 0x11329},
+		{0x11331, 0x11331},
+		{0x11334, 0x11334},
+		{0x1133a, 0x1133a},
+		{0x11345, 0x11346},
+		{0x11349, 0x1134a},
+		{0x1134e, 0x1134f},
+		{0x11351, 0x11356},
+		{0x11358, 0x1135c},
+		{0x11364, 0x11365},
+		{0x1136d, 0x1136f},
+		{0x11375, 0x113ff},
+		{0x1144b, 0x1144f},
+		{0x1145a, 0x1145d},
+		{0x11462, 0x1147f},
+		{0x114c6, 0x114c6},
+		{0x114c8, 0x114cf},
+		{0x114da, 0x1157f},
+		{0x115b6, 0x115b7},
+		{0x115c1, 0x115d7},
+		{0x115de, 0x115ff},
+		{0x11641, 0x11643},
+		{0x11645, 0x1164f},
+		{0x1165a, 0x1167f},
+		{0x116b9, 0x116bf},
+		{0x116ca, 0x1171c},
+		{0x1172c, 0x1172f},
+		{0x1173a, 0x117ff},
+		{0x1183b, 0x1189f},
+		{0x118ea, 0x118fe},
+		{0x11907, 0x11908},
+		{0x1190a, 0x1190b},
+		{0x11914, 0x11914},
+		{0x11917, 0x11917},
+		{0x11936, 0x11936},
+		{0x11939, 0x1193a},
+		{0x11944, 0x1194f},
+		{0x1195a, 0x1199f},
+		{0x119a8, 0x119a9},
+		{0x119d8, 0x119d9},
+		{0x119e2, 0x119e2},
+		{0x119e5, 0x119ff},
+		{0x11a3f, 0x11a46},
+		{0x11a48, 0x11a4f},
+		{0x11a9a, 0x11a9c},
+		{0x11a9e, 0x11abf},
+		{0x11af9, 0x11bff},
+		{0x11c09, 0x11c09},
+		{0x11c37, 0x11c37},
+		{0x11c41, 0x11c4f},
+		{0x11c5a, 0x11c71},
+		{0x11c90, 0x11c91},
+		{0x11ca8, 0x11ca8},
+		{0x11cb7, 0x11cff},
+		{0x11d07, 0x11d07},
+		{0x11d0a, 0x11d0a},
+		{0x11d37, 0x11d39},
+		{0x11d3b, 0x11d3b},
+		{0x11d3e, 0x11d3e},
+		{0x11d48, 0x11d4f},
+		{0x11d5a, 0x11d5f},
+		{0x11d66, 0x11d66},
+		{0x11d69, 0x11d69},
+		{0x11d8f, 0x11d8f},
+		{0x11d92, 0x11d92},
+		{0x11d99, 0x11d9f},
+		{0x11daa, 0x11edf},
+		{0x11ef7, 0x11faf},
+		{0x11fb1, 0x11fff},
+		{0x1239a, 0x123ff},
+		{0x1246f, 0x1247f},
+		{0x12544, 0x12fff},
+		{0x1342f, 0x1342f},
+		{0x13439, 0x143ff},
+		{0x14647, 0x167ff},
+		{0x16a39, 0x16a3f},
+		{0x16a5f, 0x16a5f},
+		{0x16a6a, 0x16acf},
+		{0x16aee, 0x16aef},
+		{0x16af5, 0x16aff},
+		{0x16b37, 0x16b3f},
+		{0x16b44, 0x16b4f},
+		{0x16b5a, 0x16b62},
+		{0x16b78, 0x16b7c},
+		{0x16b90, 0x16e3f},
+		{0x16e80, 0x16eff},
+		{0x16f4b, 0x16f4e},
+		{0x16f88, 0x16f8e},
+		{0x16fa0, 0x16fdf},
+		{0x16fe2, 0x16fe2},
+		{0x16fe5, 0x16fef},
+		{0x16ff2, 0x1bbff},
+		{0x1bc6b, 0x1bc6f},
+		{0x1bc7d, 0x1bc7f},
+		{0x1bc89, 0x1bc8f},
+		{0x1bc9a, 0x1bc9c},
+		{0x1bc9f, 0x1bc9f},
+		{0x1bca4, 0x1d164},
+		{0x1d16a, 0x1d16c},
+		{0x1d183, 0x1d184},
+		{0x1d18c, 0x1d1a9},
+		{0x1d1ae, 0x1d241},
+		{0x1d245, 0x1d3ff},
+		{0x1d455, 0x1d455},
+		{0x1d49d, 0x1d49d},
+		{0x1d4a0, 0x1d4a1},
+		{0x1d4a3, 0x1d4a4},
+		{0x1d4a7, 0x1d4a8},
+		{0x1d4ad, 0x1d4ad},
+		{0x1d4ba, 0x1d4ba},
+		{0x1d4bc, 0x1d4bc},
+		{0x1d4c4, 0x1d4c4},
+		{0x1d506, 0x1d506},
+		{0x1d50b, 0x1d50c},
+		{0x1d515, 0x1d515},
+		{0x1d51d, 0x1d51d},
+		{0x1d53a, 0x1d53a},
+		{0x1d53f, 0x1d53f},
+		{0x1d545, 0x1d545},
+		{0x1d547, 0x1d549},
+		{0x1d551, 0x1d551},
+		{0x1d6a6, 0x1d6a7},
+		{0x1d6c1, 0x1d6c1},
+		{0x1d6db, 0x1d6db},
+		{0x1d6fb, 0x1d6fb},
+		{0x1d715, 0x1d715},
+		{0x1d735, 0x1d735},
+		{0x1d74f, 0x1d74f},
+		{0x1d76f, 0x1d76f},
+		{0x1d789, 0x1d789},
+		{0x1d7a9, 0x1d7a9},
+		{0x1d7c3, 0x1d7c3},
+		{0x1d7cc, 0x1d7cd},
+		{0x1d800, 0x1d9ff},
+		{0x1da37, 0x1da3a},
+		{0x1da6d, 0x1da74},
+		{0x1da76, 0x1da83},
+		{0x1da85, 0x1da9a},
+		{0x1daa0, 0x1daa0},
+		{0x1dab0, 0x1dfff},
+		{0x1e007, 0x1e007},
+		{0x1e019, 0x1e01a},
+		{0x1e022, 0x1e022},
+		{0x1e025, 0x1e025},
+		{0x1e02b, 0x1e0ff},
+		{0x1e12d, 0x1e12f},
+		{0x1e13e, 0x1e13f},
+		{0x1e14a, 0x1e14d},
+		{0x1e14f, 0x1e2bf},
+		{0x1e2fa, 0x1e7ff},
+		{0x1e8c5, 0x1e8cf},
+		{0x1e8d7, 0x1e8ff},
+		{0x1e94c, 0x1e94f},
+		{0x1e95a, 0x1edff},
+		{0x1ee04, 0x1ee04},
+		{0x1ee20, 0x1ee20},
+		{0x1ee23, 0x1ee23},
+		{0x1ee25, 0x1ee26},
+		{0x1ee28, 0x1ee28},
+		{0x1ee33, 0x1ee33},
+		{0x1ee38, 0x1ee38},
+		{0x1ee3a, 0x1ee3a},
+		{0x1ee3c, 0x1ee41},
+		{0x1ee43, 0x1ee46},
+		{0x1ee48, 0x1ee48},
+		{0x1ee4a, 0x1ee4a},
+		{0x1ee4c, 0x1ee4c},
+		{0x1ee50, 0x1ee50},
+		{0x1ee53, 0x1ee53},
+		{0x1ee55, 0x1ee56},
+		{0x1ee58, 0x1ee58},
+		{0x1ee5a, 0x1ee5a},
+		{0x1ee5c, 0x1ee5c},
+		{0x1ee5e, 0x1ee5e},
+		{0x1ee60, 0x1ee60},
+		{0x1ee63, 0x1ee63},
+		{0x1ee65, 0x1ee66},
+		{0x1ee6b, 0x1ee6b},
+		{0x1ee73, 0x1ee73},
+		{0x1ee78, 0x1ee78},
+		{0x1ee7d, 0x1ee7d},
+		{0x1ee7f, 0x1ee7f},
+		{0x1ee8a, 0x1ee8a},
+		{0x1ee9c, 0x1eea0},
+		{0x1eea4, 0x1eea4},
+		{0x1eeaa, 0x1eeaa},
+		{0x1eebc, 0x1f12f},
+		{0x1f14a, 0x1f14f},
+		{0x1f16a, 0x1f16f},
+		{0x1f18a, 0x1f3fa},
+		{0x1f400, 0x1fbef},
+		{0x1fbfa, 0x1ffff},
+	}
+
+	breakTest = []string{
+		"AA",
+		"ÄA",
+		"Aa\u2060",
+		"Äa\u2060",
+		"Aa|:",
+		"Äa|:",
+		"Aa|'",
+		"Äa|'",
+		"Aa|'\u2060",
+		"Äa|'\u2060",
+		"Aa|,",
+		"Äa|,",
+		"a\u2060A",
+		"a\u2060̈A",
+		"a\u2060a\u2060",
+		"a\u2060̈a\u2060",
+		"a\u2060a|:",
+		"a\u2060̈a|:",
+		"a\u2060a|'",
+		"a\u2060̈a|'",
+		"a\u2060a|'\u2060",
+		"a\u2060̈a|'\u2060",
+		"a\u2060a|,",
+		"a\u2060̈a|,",
+		"a:A",
+		"a:̈A",
+		"a:a\u2060",
+		"a:̈a\u2060",
+		"a:a|:",
+		"a:̈a|:",
+		"a:a|'",
+		"a:̈a|'",
+		"a:a|'\u2060",
+		"a:̈a|'\u2060",
+		"a:a|,",
+		"a:̈a|,",
+		"a'A",
+		"a'̈A",
+		"a'a\u2060",
+		"a'̈a\u2060",
+		"a'a|:",
+		"a'̈a|:",
+		"a'a|'",
+		"a'̈a|'",
+		"a'a|'\u2060",
+		"a'̈a|'\u2060",
+		"a'a|,",
+		"a'̈a|,",
+		"a'\u2060A",
+		"a'\u2060̈A",
+		"a'\u2060a\u2060",
+		"a'\u2060̈a\u2060",
+		"a'\u2060a|:",
+		"a'\u2060̈a|:",
+		"a'\u2060a|'",
+		"a'\u2060̈a|'",
+		"a'\u2060a|'\u2060",
+		"a'\u2060̈a|'\u2060",
+		"a'\u2060a|,",
+		"a'\u2060̈a|,",
+		"a|,|A",
+		"a|,̈|A",
+		"a|,|a\u2060",
+		"a|,̈|a\u2060",
+		"a|,|a|:",
+		"a|,̈|a|:",
+		"a|,|a|'",
+		"a|,̈|a|'",
+		"a|,|a|'\u2060",
+		"a|,̈|a|'\u2060",
+		"a|,|a|,",
+		"a|,̈|a|,",
+		"AAA",
+		"A:A",
+		"A|:|:|A",
+		"A00A",
+		"A__A",
+		"a|🇦🇧|🇨|b",
+		"a|🇦🇧\u200d|🇨|b",
+		"a|🇦\u200d🇧|🇨|b",
+		"a|🇦🇧|🇨🇩|b",
+		"ä\u200d̈b",
+		"a|  |b",
+		"1_a|:|:|a",
+		"1_a|:|.|a",
+		"1_a|:|,|a",
+		"1_a|.|:|a",
+		"1_a|.|.|a",
+		"1_a|.|,|a",
+		"1_a|,|:|a",
+		"1_a|,|.|a",
+		"1_a|,|,|a",
+		"a_a|:|:|1",
+		"a|:|:|a",
+		"a_1|:|:|a",
+		"a_a|:|:|a",
+		"a_a|:|.|1",
+		"a|:|.|a",
+		"a_1|:|.|a",
+		"a_a|:|.|a",
+		"a_a|:|,|1",
+		"a|:|,|a",
+		"a_1|:|,|a",
+		"a_a|:|,|a",
+		"a_a|.|:|1",
+		"a|.|:|a",
+		"a_1|.|:|a",
+		"a_a|.|:|a",
+		"a_a|.|.|1",
+		"a|.|.|a",
+		"a_1|.|.|a",
+		"a_a|.|.|a",
+		"a_a|.|,|1",
+		"a|.|,|a",
+		"a_1|.|,|a",
+		"a_a|.|,|a",
+		"a_a|,|:|1",
+		"a|,|:|a",
+		"a_1|,|:|a",
+		"a_a|,|:|a",
+		"a_a|,|.|1",
+		"a|,|.|a",
+		"a_1|,|.|a",
+		"a_a|,|.|a",
+		"a_a|,|,|1",
+		"a|,|,|a",
+		"a_1|,|,|a",
+		"a_a|,|,|a",
+	}
+)
diff --git a/vendor/golang.org/x/text/cases/trieval.go b/vendor/golang.org/x/text/cases/trieval.go
new file mode 100644
index 0000000000..4e4d13fe5d
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/trieval.go
@@ -0,0 +1,217 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package cases
+
+// This file contains definitions for interpreting the trie value of the case
+// trie generated by "go run gen*.go". It is shared by both the generator
+// program and the resultant package. Sharing is achieved by the generator
+// copying gen_trieval.go to trieval.go and changing what's above this comment.
+
+// info holds case information for a single rune. It is the value returned
+// by a trie lookup. Most mapping information can be stored in a single 16-bit
+// value. If not, for example when a rune is mapped to multiple runes, the value
+// stores some basic case data and an index into an array with additional data.
+//
+// The per-rune values have the following format:
+//
+//	if (exception) {
+//	  15..4  unsigned exception index
+//	} else {
+//	  15..8  XOR pattern or index to XOR pattern for case mapping
+//	         Only 13..8 are used for XOR patterns.
+//	      7  inverseFold (fold to upper, not to lower)
+//	      6  index: interpret the XOR pattern as an index
+//	         or isMid if case mode is cIgnorableUncased.
+//	   5..4  CCC: zero (normal or break), above or other
+//	}
+//	   3  exception: interpret this value as an exception index
+//	      (TODO: is this bit necessary? Probably implied from case mode.)
+//	2..0  case mode
+//
+// For the non-exceptional cases, a rune must be either uncased, lowercase or
+// uppercase. If the rune is cased, the XOR pattern maps either a lowercase
+// rune to uppercase or an uppercase rune to lowercase (applied to the 10
+// least-significant bits of the rune).
+//
+// See the definitions below for a more detailed description of the various
+// bits.
+type info uint16
+
+const (
+	casedMask      = 0x0003
+	fullCasedMask  = 0x0007
+	ignorableMask  = 0x0006
+	ignorableValue = 0x0004
+
+	inverseFoldBit = 1 << 7
+	isMidBit       = 1 << 6
+
+	exceptionBit     = 1 << 3
+	exceptionShift   = 4
+	numExceptionBits = 12
+
+	xorIndexBit = 1 << 6
+	xorShift    = 8
+
+	// There is no mapping if all xor bits and the exception bit are zero.
+	hasMappingMask = 0xff80 | exceptionBit
+)
+
+// The case mode bits encodes the case type of a rune. This includes uncased,
+// title, upper and lower case and case ignorable. (For a definition of these
+// terms see Chapter 3 of The Unicode Standard Core Specification.) In some rare
+// cases, a rune can be both cased and case-ignorable. This is encoded by
+// cIgnorableCased. A rune of this type is always lower case. Some runes are
+// cased while not having a mapping.
+//
+// A common pattern for scripts in the Unicode standard is for upper and lower
+// case runes to alternate for increasing rune values (e.g. the accented Latin
+// ranges starting from U+0100 and U+1E00 among others and some Cyrillic
+// characters). We use this property by defining a cXORCase mode, where the case
+// mode (always upper or lower case) is derived from the rune value. As the XOR
+// pattern for case mappings is often identical for successive runes, using
+// cXORCase can result in large series of identical trie values. This, in turn,
+// allows us to better compress the trie blocks.
+const (
+	cUncased          info = iota // 000
+	cTitle                        // 001
+	cLower                        // 010
+	cUpper                        // 011
+	cIgnorableUncased             // 100
+	cIgnorableCased               // 101 // lower case if mappings exist
+	cXORCase                      // 11x // case is cLower | ((rune&1) ^ x)
+
+	maxCaseMode = cUpper
+)
+
+func (c info) isCased() bool {
+	return c&casedMask != 0
+}
+
+func (c info) isCaseIgnorable() bool {
+	return c&ignorableMask == ignorableValue
+}
+
+func (c info) isNotCasedAndNotCaseIgnorable() bool {
+	return c&fullCasedMask == 0
+}
+
+func (c info) isCaseIgnorableAndNotCased() bool {
+	return c&fullCasedMask == cIgnorableUncased
+}
+
+func (c info) isMid() bool {
+	return c&(fullCasedMask|isMidBit) == isMidBit|cIgnorableUncased
+}
+
+// The case mapping implementation will need to know about various Canonical
+// Combining Class (CCC) values. We encode two of these in the trie value:
+// cccZero (0) and cccAbove (230). If the value is cccOther, it means that
+// CCC(r) > 0, but not 230. A value of cccBreak means that CCC(r) == 0 and that
+// the rune also has the break category Break (see below).
+const (
+	cccBreak info = iota << 4
+	cccZero
+	cccAbove
+	cccOther
+
+	cccMask = cccBreak | cccZero | cccAbove | cccOther
+)
+
+const (
+	starter       = 0
+	above         = 230
+	iotaSubscript = 240
+)
+
+// The exceptions slice holds data that does not fit in a normal info entry.
+// The entry is pointed to by the exception index in an entry. It has the
+// following format:
+//
+// Header:
+//
+//	byte 0:
+//	 7..6  unused
+//	 5..4  CCC type (same bits as entry)
+//	    3  unused
+//	 2..0  length of fold
+//
+//	byte 1:
+//	  7..6  unused
+//	  5..3  length of 1st mapping of case type
+//	  2..0  length of 2nd mapping of case type
+//
+//	  case     1st    2nd
+//	  lower -> upper, title
+//	  upper -> lower, title
+//	  title -> lower, upper
+//
+// Lengths with the value 0x7 indicate no value and implies no change.
+// A length of 0 indicates a mapping to zero-length string.
+//
+// Body bytes:
+//
+//	case folding bytes
+//	lowercase mapping bytes
+//	uppercase mapping bytes
+//	titlecase mapping bytes
+//	closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+// Fallbacks:
+//
+//	missing fold  -> lower
+//	missing title -> upper
+//	all missing   -> original rune
+//
+// exceptions starts with a dummy byte to enforce that there is no zero index
+// value.
+const (
+	lengthMask = 0x07
+	lengthBits = 3
+	noChange   = 0
+)
+
+// References to generated trie.
+
+var trie = newCaseTrie(0)
+
+var sparse = sparseBlocks{
+	values:  sparseValues[:],
+	offsets: sparseOffsets[:],
+}
+
+// Sparse block lookup code.
+
+// valueRange is an entry in a sparse block.
+type valueRange struct {
+	value  uint16
+	lo, hi byte
+}
+
+type sparseBlocks struct {
+	values  []valueRange
+	offsets []uint16
+}
+
+// lookup returns the value from values block n for byte b using binary search.
+func (s *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	lo := s.offsets[n]
+	hi := s.offsets[n+1]
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := s.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
+
+// lastRuneForTesting is the last rune used for testing. Everything after this
+// is boring.
+const lastRuneForTesting = rune(0x1FFFF)
diff --git a/vendor/golang.org/x/text/cases/ya.make b/vendor/golang.org/x/text/cases/ya.make
new file mode 100644
index 0000000000..ab53cd43bd
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/ya.make
@@ -0,0 +1,26 @@
+GO_LIBRARY()
+
+LICENSE(BSD-3-Clause)
+
+SRCS(
+    cases.go
+    context.go
+    fold.go
+    info.go
+    map.go
+    tables13.0.0.go
+    trieval.go
+)
+
+GO_TEST_SRCS(
+    context_test.go
+    fold_test.go
+    map_test.go
+    tables13.0.0_test.go
+)
+
+GO_XTEST_SRCS(example_test.go)
+
+END()
+
+RECURSE(gotest)