From 54d3d47daf9190275bbdaf8703b84969a4593451 Mon Sep 17 00:00:00 2001 From: Corey Hulen Date: Fri, 24 Mar 2017 23:31:34 -0700 Subject: PLT-6076 Adding viper libs for config file changes (#5871) * Adding viper libs for config file changes * Removing the old fsnotify lib * updating some missing libs --- vendor/golang.org/x/text/currency/common.go | 66 + vendor/golang.org/x/text/currency/currency.go | 185 ++ vendor/golang.org/x/text/currency/currency_test.go | 171 ++ vendor/golang.org/x/text/currency/example_test.go | 27 + vendor/golang.org/x/text/currency/format.go | 215 ++ vendor/golang.org/x/text/currency/format_test.go | 70 + vendor/golang.org/x/text/currency/gen.go | 400 +++ vendor/golang.org/x/text/currency/gen_common.go | 70 + vendor/golang.org/x/text/currency/query.go | 152 ++ vendor/golang.org/x/text/currency/query_test.go | 107 + vendor/golang.org/x/text/currency/tables.go | 2573 ++++++++++++++++++++ vendor/golang.org/x/text/currency/tables_test.go | 93 + 12 files changed, 4129 insertions(+) create mode 100644 vendor/golang.org/x/text/currency/common.go create mode 100644 vendor/golang.org/x/text/currency/currency.go create mode 100644 vendor/golang.org/x/text/currency/currency_test.go create mode 100644 vendor/golang.org/x/text/currency/example_test.go create mode 100644 vendor/golang.org/x/text/currency/format.go create mode 100644 vendor/golang.org/x/text/currency/format_test.go create mode 100644 vendor/golang.org/x/text/currency/gen.go create mode 100644 vendor/golang.org/x/text/currency/gen_common.go create mode 100644 vendor/golang.org/x/text/currency/query.go create mode 100644 vendor/golang.org/x/text/currency/query_test.go create mode 100644 vendor/golang.org/x/text/currency/tables.go create mode 100644 vendor/golang.org/x/text/currency/tables_test.go (limited to 'vendor/golang.org/x/text/currency') diff --git a/vendor/golang.org/x/text/currency/common.go b/vendor/golang.org/x/text/currency/common.go new file mode 100644 index 000000000..250cb8c66 --- /dev/null +++ b/vendor/golang.org/x/text/currency/common.go @@ -0,0 +1,66 @@ +// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. + +package currency + +import ( + "time" + + "golang.org/x/text/language" +) + +// This file contains code common to gen.go and the package code. + +const ( + cashShift = 3 + roundMask = 0x7 + + nonTenderBit = 0x8000 +) + +// currencyInfo contains information about a currency. +// bits 0..2: index into roundings for standard rounding +// bits 3..5: index into roundings for cash rounding +type currencyInfo byte + +// roundingType defines the scale (number of fractional decimals) and increments +// in terms of units of size 10^-scale. For example, for scale == 2 and +// increment == 1, the currency is rounded to units of 0.01. +type roundingType struct { + scale, increment uint8 +} + +// roundings contains rounding data for currencies. This struct is +// created by hand as it is very unlikely to change much. +var roundings = [...]roundingType{ + {2, 1}, // default + {0, 1}, + {1, 1}, + {3, 1}, + {4, 1}, + {2, 5}, // cash rounding alternative +} + +// regionToCode returns a 16-bit region code. Only two-letter codes are +// supported. (Three-letter codes are not needed.) +func regionToCode(r language.Region) uint16 { + if s := r.String(); len(s) == 2 { + return uint16(s[0])<<8 | uint16(s[1]) + } + return 0 +} + +func toDate(t time.Time) uint32 { + y := t.Year() + if y == 1 { + return 0 + } + date := uint32(y) << 4 + date |= uint32(t.Month()) + date <<= 5 + date |= uint32(t.Day()) + return date +} + +func fromDate(date uint32) time.Time { + return time.Date(int(date>>9), time.Month((date>>5)&0xf), int(date&0x1f), 0, 0, 0, 0, time.UTC) +} diff --git a/vendor/golang.org/x/text/currency/currency.go b/vendor/golang.org/x/text/currency/currency.go new file mode 100644 index 000000000..598ddeff4 --- /dev/null +++ b/vendor/golang.org/x/text/currency/currency.go @@ -0,0 +1,185 @@ +// 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. + +//go:generate go run gen.go gen_common.go -output tables.go + +// Package currency contains currency-related functionality. +// +// NOTE: the formatting functionality is currently under development and may +// change without notice. +package currency // import "golang.org/x/text/currency" + +import ( + "errors" + "sort" + + "golang.org/x/text/internal/tag" + "golang.org/x/text/language" +) + +// TODO: +// - language-specific currency names. +// - currency formatting. +// - currency information per region +// - register currency code (there are no private use area) + +// TODO: remove Currency type from package language. + +// Kind determines the rounding and rendering properties of a currency value. +type Kind struct { + rounding rounding + // TODO: formatting type: standard, accounting. See CLDR. +} + +type rounding byte + +const ( + standard rounding = iota + cash +) + +var ( + // Standard defines standard rounding and formatting for currencies. + Standard Kind = Kind{rounding: standard} + + // Cash defines rounding and formatting standards for cash transactions. + Cash Kind = Kind{rounding: cash} + + // Accounting defines rounding and formatting standards for accounting. + Accounting Kind = Kind{rounding: standard} +) + +// Rounding reports the rounding characteristics for the given currency, where +// scale is the number of fractional decimals and increment is the number of +// units in terms of 10^(-scale) to which to round to. +func (k Kind) Rounding(cur Unit) (scale, increment int) { + info := currency.Elem(int(cur.index))[3] + switch k.rounding { + case standard: + info &= roundMask + case cash: + info >>= cashShift + } + return int(roundings[info].scale), int(roundings[info].increment) +} + +// Unit is an ISO 4217 currency designator. +type Unit struct { + index uint16 +} + +// String returns the ISO code of u. +func (u Unit) String() string { + if u.index == 0 { + return "XXX" + } + return currency.Elem(int(u.index))[:3] +} + +// Amount creates an Amount for the given currency unit and amount. +func (u Unit) Amount(amount interface{}) Amount { + // TODO: verify amount is a supported number type + return Amount{amount: amount, currency: u} +} + +var ( + errSyntax = errors.New("currency: tag is not well-formed") + errValue = errors.New("currency: tag is not a recognized currency") +) + +// ParseISO parses a 3-letter ISO 4217 currency code. It returns an error if s +// is not well-formed or not a recognized currency code. +func ParseISO(s string) (Unit, error) { + var buf [4]byte // Take one byte more to detect oversize keys. + key := buf[:copy(buf[:], s)] + if !tag.FixCase("XXX", key) { + return Unit{}, errSyntax + } + if i := currency.Index(key); i >= 0 { + if i == xxx { + return Unit{}, nil + } + return Unit{uint16(i)}, nil + } + return Unit{}, errValue +} + +// MustParseISO is like ParseISO, but panics if the given currency unit +// cannot be parsed. It simplifies safe initialization of Unit values. +func MustParseISO(s string) Unit { + c, err := ParseISO(s) + if err != nil { + panic(err) + } + return c +} + +// FromRegion reports the currency unit that is currently legal tender in the +// given region according to CLDR. It will return false if region currently does +// not have a legal tender. +func FromRegion(r language.Region) (currency Unit, ok bool) { + x := regionToCode(r) + i := sort.Search(len(regionToCurrency), func(i int) bool { + return regionToCurrency[i].region >= x + }) + if i < len(regionToCurrency) && regionToCurrency[i].region == x { + return Unit{regionToCurrency[i].code}, true + } + return Unit{}, false +} + +// FromTag reports the most likely currency for the given tag. It considers the +// currency defined in the -u extension and infers the region if necessary. +func FromTag(t language.Tag) (Unit, language.Confidence) { + if cur := t.TypeForKey("cu"); len(cur) == 3 { + c, _ := ParseISO(cur) + return c, language.Exact + } + r, conf := t.Region() + if cur, ok := FromRegion(r); ok { + return cur, conf + } + return Unit{}, language.No +} + +var ( + // Undefined and testing. + XXX Unit = Unit{} + XTS Unit = Unit{xts} + + // G10 currencies https://en.wikipedia.org/wiki/G10_currencies. + USD Unit = Unit{usd} + EUR Unit = Unit{eur} + JPY Unit = Unit{jpy} + GBP Unit = Unit{gbp} + CHF Unit = Unit{chf} + AUD Unit = Unit{aud} + NZD Unit = Unit{nzd} + CAD Unit = Unit{cad} + SEK Unit = Unit{sek} + NOK Unit = Unit{nok} + + // Additional common currencies as defined by CLDR. + BRL Unit = Unit{brl} + CNY Unit = Unit{cny} + DKK Unit = Unit{dkk} + INR Unit = Unit{inr} + RUB Unit = Unit{rub} + HKD Unit = Unit{hkd} + IDR Unit = Unit{idr} + KRW Unit = Unit{krw} + MXN Unit = Unit{mxn} + PLN Unit = Unit{pln} + SAR Unit = Unit{sar} + THB Unit = Unit{thb} + TRY Unit = Unit{try} + TWD Unit = Unit{twd} + ZAR Unit = Unit{zar} + + // Precious metals. + XAG Unit = Unit{xag} + XAU Unit = Unit{xau} + XPT Unit = Unit{xpt} + XPD Unit = Unit{xpd} +) diff --git a/vendor/golang.org/x/text/currency/currency_test.go b/vendor/golang.org/x/text/currency/currency_test.go new file mode 100644 index 000000000..566a1678a --- /dev/null +++ b/vendor/golang.org/x/text/currency/currency_test.go @@ -0,0 +1,171 @@ +// 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 currency + +import ( + "fmt" + "testing" + + "golang.org/x/text/internal/testtext" + "golang.org/x/text/language" +) + +var ( + cup = MustParseISO("CUP") + czk = MustParseISO("CZK") + xcd = MustParseISO("XCD") + zwr = MustParseISO("ZWR") +) + +func TestParseISO(t *testing.T) { + testCases := []struct { + in string + out Unit + ok bool + }{ + {"USD", USD, true}, + {"xxx", XXX, true}, + {"xts", XTS, true}, + {"XX", XXX, false}, + {"XXXX", XXX, false}, + {"", XXX, false}, // not well-formed + {"UUU", XXX, false}, // unknown + {"\u22A9", XXX, false}, // non-ASCII, printable + + {"aaa", XXX, false}, + {"zzz", XXX, false}, + {"000", XXX, false}, + {"999", XXX, false}, + {"---", XXX, false}, + {"\x00\x00\x00", XXX, false}, + {"\xff\xff\xff", XXX, false}, + } + for i, tc := range testCases { + if x, err := ParseISO(tc.in); x != tc.out || err == nil != tc.ok { + t.Errorf("%d:%s: was %s, %v; want %s, %v", i, tc.in, x, err == nil, tc.out, tc.ok) + } + } +} + +func TestFromRegion(t *testing.T) { + testCases := []struct { + region string + currency Unit + ok bool + }{ + {"NL", EUR, true}, + {"BE", EUR, true}, + {"AG", xcd, true}, + {"CH", CHF, true}, + {"CU", cup, true}, // first of multiple + {"DG", USD, true}, // does not have M49 code + {"150", XXX, false}, // implicit false + {"CP", XXX, false}, // explicit false in CLDR + {"CS", XXX, false}, // all expired + {"ZZ", XXX, false}, // none match + } + for _, tc := range testCases { + cur, ok := FromRegion(language.MustParseRegion(tc.region)) + if cur != tc.currency || ok != tc.ok { + t.Errorf("%s: got %v, %v; want %v, %v", tc.region, cur, ok, tc.currency, tc.ok) + } + } +} + +func TestFromTag(t *testing.T) { + testCases := []struct { + tag string + currency Unit + conf language.Confidence + }{ + {"nl", EUR, language.Low}, // nl also spoken outside Euro land. + {"nl-BE", EUR, language.Exact}, // region is known + {"pt", BRL, language.Low}, + {"en", USD, language.Low}, + {"en-u-cu-eur", EUR, language.Exact}, + {"tlh", XXX, language.No}, // Klingon has no country. + {"es-419", XXX, language.No}, + {"und", USD, language.Low}, + } + for _, tc := range testCases { + cur, conf := FromTag(language.MustParse(tc.tag)) + if cur != tc.currency || conf != tc.conf { + t.Errorf("%s: got %v, %v; want %v, %v", tc.tag, cur, conf, tc.currency, tc.conf) + } + } +} + +func TestTable(t *testing.T) { + for i := 4; i < len(currency); i += 4 { + if a, b := currency[i-4:i-1], currency[i:i+3]; a >= b { + t.Errorf("currency unordered at element %d: %s >= %s", i, a, b) + } + } + // First currency has index 1, last is numCurrencies. + if c := currency.Elem(1)[:3]; c != "ADP" { + t.Errorf("first was %c; want ADP", c) + } + if c := currency.Elem(numCurrencies)[:3]; c != "ZWR" { + t.Errorf("last was %c; want ZWR", c) + } +} + +func TestKindRounding(t *testing.T) { + testCases := []struct { + kind Kind + cur Unit + scale int + inc int + }{ + {Standard, USD, 2, 1}, + {Standard, CHF, 2, 1}, + {Cash, CHF, 2, 5}, + {Standard, TWD, 2, 1}, + {Cash, TWD, 0, 1}, + {Standard, czk, 2, 1}, + {Cash, czk, 0, 1}, + {Standard, zwr, 2, 1}, + {Cash, zwr, 0, 1}, + {Standard, KRW, 0, 1}, + {Cash, KRW, 0, 1}, // Cash defaults to standard. + } + for i, tc := range testCases { + if scale, inc := tc.kind.Rounding(tc.cur); scale != tc.scale && inc != tc.inc { + t.Errorf("%d: got %d, %d; want %d, %d", i, scale, inc, tc.scale, tc.inc) + } + } +} + +const body = `package main +import ( + "fmt" + "golang.org/x/text/currency" +) +func main() { + %s +} +` + +func TestLinking(t *testing.T) { + base := getSize(t, `fmt.Print(currency.CLDRVersion)`) + symbols := getSize(t, `fmt.Print(currency.Symbol(currency.USD))`) + if d := symbols - base; d < 2*1024 { + t.Errorf("size(symbols)-size(base) was %d; want > 2K", d) + } +} + +func getSize(t *testing.T, main string) int { + size, err := testtext.CodeSize(fmt.Sprintf(body, main)) + if err != nil { + t.Skipf("skipping link size test; binary size could not be determined: %v", err) + } + return size +} + +func BenchmarkString(b *testing.B) { + for i := 0; i < b.N; i++ { + USD.String() + } +} diff --git a/vendor/golang.org/x/text/currency/example_test.go b/vendor/golang.org/x/text/currency/example_test.go new file mode 100644 index 000000000..f7984aa73 --- /dev/null +++ b/vendor/golang.org/x/text/currency/example_test.go @@ -0,0 +1,27 @@ +// 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 currency_test + +import ( + "fmt" + "time" + + "golang.org/x/text/currency" +) + +func ExampleQuery() { + t1799, _ := time.Parse("2006-01-02", "1799-01-01") + for it := currency.Query(currency.Date(t1799)); it.Next(); { + from := "" + if t, ok := it.From(); ok { + from = t.Format("2006-01-01") + } + fmt.Printf("%v is used in %v since: %v\n", it.Unit(), it.Region(), from) + } + // Output: + // GBP is used in GB since: 1694-07-07 + // GIP is used in GI since: 1713-01-01 + // USD is used in US since: 1792-01-01 +} diff --git a/vendor/golang.org/x/text/currency/format.go b/vendor/golang.org/x/text/currency/format.go new file mode 100644 index 000000000..97ce2d944 --- /dev/null +++ b/vendor/golang.org/x/text/currency/format.go @@ -0,0 +1,215 @@ +// 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 currency + +import ( + "fmt" + "io" + "sort" + + "golang.org/x/text/internal" + "golang.org/x/text/internal/format" + "golang.org/x/text/language" +) + +// Amount is an amount-currency unit pair. +type Amount struct { + amount interface{} // Change to decimal(64|128). + currency Unit +} + +// Currency reports the currency unit of this amount. +func (a Amount) Currency() Unit { return a.currency } + +// TODO: based on decimal type, but may make sense to customize a bit. +// func (a Amount) Decimal() +// func (a Amount) Int() (int64, error) +// func (a Amount) Fraction() (int64, error) +// func (a Amount) Rat() *big.Rat +// func (a Amount) Float() (float64, error) +// func (a Amount) Scale() uint +// func (a Amount) Precision() uint +// func (a Amount) Sign() int +// +// Add/Sub/Div/Mul/Round. + +var space = []byte(" ") + +// Format implements fmt.Formatter. It accepts format.State for +// language-specific rendering. +func (a Amount) Format(s fmt.State, verb rune) { + v := formattedValue{ + currency: a.currency, + amount: a.amount, + format: defaultFormat, + } + v.Format(s, verb) +} + +// formattedValue is currency amount or unit that implements language-sensitive +// formatting. +type formattedValue struct { + currency Unit + amount interface{} // Amount, Unit, or number. + format *options +} + +// Format implements fmt.Formatter. It accepts format.State for +// language-specific rendering. +func (v formattedValue) Format(s fmt.State, verb rune) { + var lang int + if state, ok := s.(format.State); ok { + lang, _ = language.CompactIndex(state.Language()) + } + + // Get the options. Use DefaultFormat if not present. + opt := v.format + if opt == nil { + opt = defaultFormat + } + cur := v.currency + if cur.index == 0 { + cur = opt.currency + } + + // TODO: use pattern. + io.WriteString(s, opt.symbol(lang, cur)) + if v.amount != nil { + s.Write(space) + + // TODO: apply currency-specific rounding + scale, _ := opt.kind.Rounding(cur) + if _, ok := s.Precision(); !ok { + fmt.Fprintf(s, "%.*f", scale, v.amount) + } else { + fmt.Fprint(s, v.amount) + } + } +} + +// Formatter decorates a given number, Unit or Amount with formatting options. +type Formatter func(amount interface{}) formattedValue + +// func (f Formatter) Options(opts ...Option) Formatter + +// TODO: call this a Formatter or FormatFunc? + +var dummy = USD.Amount(0) + +// adjust creates a new Formatter based on the adjustments of fn on f. +func (f Formatter) adjust(fn func(*options)) Formatter { + var o options = *(f(dummy).format) + fn(&o) + return o.format +} + +// Default creates a new Formatter that defaults to currency unit c if a numeric +// value is passed that is not associated with a currency. +func (f Formatter) Default(currency Unit) Formatter { + return f.adjust(func(o *options) { o.currency = currency }) +} + +// Kind sets the kind of the underlying currency unit. +func (f Formatter) Kind(k Kind) Formatter { + return f.adjust(func(o *options) { o.kind = k }) +} + +var defaultFormat *options = ISO(dummy).format + +var ( + // Uses Narrow symbols. Overrides Symbol, if present. + NarrowSymbol Formatter = Formatter(formNarrow) + + // Use Symbols instead of ISO codes, when available. + Symbol Formatter = Formatter(formSymbol) + + // Use ISO code as symbol. + ISO Formatter = Formatter(formISO) + + // TODO: + // // Use full name as symbol. + // Name Formatter +) + +// options configures rendering and rounding options for an Amount. +type options struct { + currency Unit + kind Kind + + symbol func(compactIndex int, c Unit) string +} + +func (o *options) format(amount interface{}) formattedValue { + v := formattedValue{format: o} + switch x := amount.(type) { + case Amount: + v.amount = x.amount + v.currency = x.currency + case *Amount: + v.amount = x.amount + v.currency = x.currency + case Unit: + v.currency = x + case *Unit: + v.currency = *x + default: + if o.currency.index == 0 { + panic("cannot format number without a currency being set") + } + // TODO: Must be a number. + v.amount = x + v.currency = o.currency + } + return v +} + +var ( + optISO = options{symbol: lookupISO} + optSymbol = options{symbol: lookupSymbol} + optNarrow = options{symbol: lookupNarrow} +) + +// These need to be functions, rather than curried methods, as curried methods +// are evaluated at init time, causing tables to be included unconditionally. +func formISO(x interface{}) formattedValue { return optISO.format(x) } +func formSymbol(x interface{}) formattedValue { return optSymbol.format(x) } +func formNarrow(x interface{}) formattedValue { return optNarrow.format(x) } + +func lookupISO(x int, c Unit) string { return c.String() } +func lookupSymbol(x int, c Unit) string { return normalSymbol.lookup(x, c) } +func lookupNarrow(x int, c Unit) string { return narrowSymbol.lookup(x, c) } + +type symbolIndex struct { + index []uint16 // position corresponds with compact index of language. + data []curToIndex +} + +var ( + normalSymbol = symbolIndex{normalLangIndex, normalSymIndex} + narrowSymbol = symbolIndex{narrowLangIndex, narrowSymIndex} +) + +func (x *symbolIndex) lookup(lang int, c Unit) string { + for { + index := x.data[x.index[lang]:x.index[lang+1]] + i := sort.Search(len(index), func(i int) bool { + return index[i].cur >= c.index + }) + if i < len(index) && index[i].cur == c.index { + x := index[i].idx + start := x + 1 + end := start + uint16(symbols[x]) + if start == end { + return c.String() + } + return symbols[start:end] + } + if lang == 0 { + break + } + lang = int(internal.Parent[lang]) + } + return c.String() +} diff --git a/vendor/golang.org/x/text/currency/format_test.go b/vendor/golang.org/x/text/currency/format_test.go new file mode 100644 index 000000000..0aa0d58af --- /dev/null +++ b/vendor/golang.org/x/text/currency/format_test.go @@ -0,0 +1,70 @@ +// 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 currency + +import ( + "testing" + + "golang.org/x/text/language" + "golang.org/x/text/message" +) + +var ( + en = language.English + fr = language.French + en_US = language.AmericanEnglish + en_GB = language.BritishEnglish + en_AU = language.MustParse("en-AU") + und = language.Und +) + +func TestFormatting(t *testing.T) { + testCases := []struct { + tag language.Tag + value interface{} + format Formatter + want string + }{ + 0: {en, USD.Amount(0.1), nil, "USD 0.10"}, + 1: {en, XPT.Amount(1.0), Symbol, "XPT 1.00"}, + + 2: {en, USD.Amount(2.0), ISO, "USD 2.00"}, + 3: {und, USD.Amount(3.0), Symbol, "US$ 3.00"}, + 4: {en, USD.Amount(4.0), Symbol, "$ 4.00"}, + + 5: {en, USD.Amount(5.20), NarrowSymbol, "$ 5.20"}, + 6: {en, AUD.Amount(6.20), Symbol, "A$ 6.20"}, + + 7: {en_AU, AUD.Amount(7.20), Symbol, "$ 7.20"}, + 8: {en_GB, USD.Amount(8.20), Symbol, "US$ 8.20"}, + + 9: {en, 9.0, Symbol.Default(EUR), "€ 9.00"}, + 10: {en, 10.123, Symbol.Default(KRW), "₩ 10"}, + 11: {fr, 11.52, Symbol.Default(TWD), "TWD 11.52"}, + 12: {en, 12.123, Symbol.Default(czk), "CZK 12.12"}, + 13: {en, 13.123, Symbol.Default(czk).Kind(Cash), "CZK 13"}, + 14: {en, 14.12345, ISO.Default(MustParseISO("CLF")), "CLF 14.1235"}, + 15: {en, USD.Amount(15.00), ISO.Default(TWD), "USD 15.00"}, + 16: {en, KRW.Amount(16.00), ISO.Kind(Cash), "KRW 16"}, + + // TODO: support integers as well. + + 17: {en, USD, nil, "USD"}, + 18: {en, USD, ISO, "USD"}, + 19: {en, USD, Symbol, "$"}, + 20: {en_GB, USD, Symbol, "US$"}, + 21: {en_AU, USD, NarrowSymbol, "$"}, + } + for i, tc := range testCases { + p := message.NewPrinter(tc.tag) + v := tc.value + if tc.format != nil { + v = tc.format(v) + } + if got := p.Sprint(v); got != tc.want { + t.Errorf("%d: got %q; want %q", i, got, tc.want) + } + } +} diff --git a/vendor/golang.org/x/text/currency/gen.go b/vendor/golang.org/x/text/currency/gen.go new file mode 100644 index 000000000..0952d4140 --- /dev/null +++ b/vendor/golang.org/x/text/currency/gen.go @@ -0,0 +1,400 @@ +// 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. + +// +build ignore + +// Generator for currency-related data. + +package main + +import ( + "flag" + "fmt" + "log" + "os" + "sort" + "strconv" + "strings" + "time" + + "golang.org/x/text/internal" + "golang.org/x/text/internal/gen" + "golang.org/x/text/internal/tag" + "golang.org/x/text/language" + "golang.org/x/text/unicode/cldr" +) + +var ( + test = flag.Bool("test", false, + "test existing tables; can be used to compare web data with package data.") + outputFile = flag.String("output", "tables.go", "output file") + + draft = flag.String("draft", + "contributed", + `Minimal draft requirements (approved, contributed, provisional, unconfirmed).`) +) + +func main() { + gen.Init() + + gen.Repackage("gen_common.go", "common.go", "currency") + + // Read the CLDR zip file. + r := gen.OpenCLDRCoreZip() + defer r.Close() + + d := &cldr.Decoder{} + d.SetDirFilter("supplemental", "main") + d.SetSectionFilter("numbers") + data, err := d.DecodeZip(r) + if err != nil { + log.Fatalf("DecodeZip: %v", err) + } + + w := gen.NewCodeWriter() + defer w.WriteGoFile(*outputFile, "currency") + + fmt.Fprintln(w, `import "golang.org/x/text/internal/tag"`) + + gen.WriteCLDRVersion(w) + b := &builder{} + b.genCurrencies(w, data.Supplemental()) + b.genSymbols(w, data) +} + +var constants = []string{ + // Undefined and testing. + "XXX", "XTS", + // G11 currencies https://en.wikipedia.org/wiki/G10_currencies. + "USD", "EUR", "JPY", "GBP", "CHF", "AUD", "NZD", "CAD", "SEK", "NOK", "DKK", + // Precious metals. + "XAG", "XAU", "XPT", "XPD", + + // Additional common currencies as defined by CLDR. + "BRL", "CNY", "INR", "RUB", "HKD", "IDR", "KRW", "MXN", "PLN", "SAR", + "THB", "TRY", "TWD", "ZAR", +} + +type builder struct { + currencies tag.Index + numCurrencies int +} + +func (b *builder) genCurrencies(w *gen.CodeWriter, data *cldr.SupplementalData) { + // 3-letter ISO currency codes + // Start with dummy to let index start at 1. + currencies := []string{"\x00\x00\x00\x00"} + + // currency codes + for _, reg := range data.CurrencyData.Region { + for _, cur := range reg.Currency { + currencies = append(currencies, cur.Iso4217) + } + } + // Not included in the list for some reasons: + currencies = append(currencies, "MVP") + + sort.Strings(currencies) + // Unique the elements. + k := 0 + for i := 1; i < len(currencies); i++ { + if currencies[k] != currencies[i] { + currencies[k+1] = currencies[i] + k++ + } + } + currencies = currencies[:k+1] + + // Close with dummy for simpler and faster searching. + currencies = append(currencies, "\xff\xff\xff\xff") + + // Write currency values. + fmt.Fprintln(w, "const (") + for _, c := range constants { + index := sort.SearchStrings(currencies, c) + fmt.Fprintf(w, "\t%s = %d\n", strings.ToLower(c), index) + } + fmt.Fprint(w, ")") + + // Compute currency-related data that we merge into the table. + for _, info := range data.CurrencyData.Fractions[0].Info { + if info.Iso4217 == "DEFAULT" { + continue + } + standard := getRoundingIndex(info.Digits, info.Rounding, 0) + cash := getRoundingIndex(info.CashDigits, info.CashRounding, standard) + + index := sort.SearchStrings(currencies, info.Iso4217) + currencies[index] += mkCurrencyInfo(standard, cash) + } + + // Set default values for entries that weren't touched. + for i, c := range currencies { + if len(c) == 3 { + currencies[i] += mkCurrencyInfo(0, 0) + } + } + + b.currencies = tag.Index(strings.Join(currencies, "")) + w.WriteComment(` + currency holds an alphabetically sorted list of canonical 3-letter currency + identifiers. Each identifier is followed by a byte of type currencyInfo, + defined in gen_common.go.`) + w.WriteConst("currency", b.currencies) + + // Hack alert: gofmt indents a trailing comment after an indented string. + // Ensure that the next thing written is not a comment. + b.numCurrencies = (len(b.currencies) / 4) - 2 + w.WriteConst("numCurrencies", b.numCurrencies) + + // Create a table that maps regions to currencies. + regionToCurrency := []toCurrency{} + + for _, reg := range data.CurrencyData.Region { + if len(reg.Iso3166) != 2 { + log.Fatalf("Unexpected group %q in region data", reg.Iso3166) + } + if len(reg.Currency) == 0 { + continue + } + cur := reg.Currency[0] + if cur.To != "" || cur.Tender == "false" { + continue + } + regionToCurrency = append(regionToCurrency, toCurrency{ + region: regionToCode(language.MustParseRegion(reg.Iso3166)), + code: uint16(b.currencies.Index([]byte(cur.Iso4217))), + }) + } + sort.Sort(byRegion(regionToCurrency)) + + w.WriteType(toCurrency{}) + w.WriteVar("regionToCurrency", regionToCurrency) + + // Create a table that maps regions to currencies. + regionData := []regionInfo{} + + for _, reg := range data.CurrencyData.Region { + if len(reg.Iso3166) != 2 { + log.Fatalf("Unexpected group %q in region data", reg.Iso3166) + } + for _, cur := range reg.Currency { + from, _ := time.Parse("2006-01-02", cur.From) + to, _ := time.Parse("2006-01-02", cur.To) + code := uint16(b.currencies.Index([]byte(cur.Iso4217))) + if cur.Tender == "false" { + code |= nonTenderBit + } + regionData = append(regionData, regionInfo{ + region: regionToCode(language.MustParseRegion(reg.Iso3166)), + code: code, + from: toDate(from), + to: toDate(to), + }) + } + } + sort.Stable(byRegionCode(regionData)) + + w.WriteType(regionInfo{}) + w.WriteVar("regionData", regionData) +} + +type regionInfo struct { + region uint16 + code uint16 // 0x8000 not legal tender + from uint32 + to uint32 +} + +type byRegionCode []regionInfo + +func (a byRegionCode) Len() int { return len(a) } +func (a byRegionCode) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a byRegionCode) Less(i, j int) bool { return a[i].region < a[j].region } + +type toCurrency struct { + region uint16 + code uint16 +} + +type byRegion []toCurrency + +func (a byRegion) Len() int { return len(a) } +func (a byRegion) Swap(i, j int) { a[i], a[j] = a[j], a[i] } +func (a byRegion) Less(i, j int) bool { return a[i].region < a[j].region } + +func mkCurrencyInfo(standard, cash int) string { + return string([]byte{byte(cash< currency -> type -> symbol + var symbols [language.NumCompactTags][][numTypes]*string + + // Collect symbol information per language. + for _, lang := range data.Locales() { + ldml := data.RawLDML(lang) + if ldml.Numbers == nil || ldml.Numbers.Currencies == nil { + continue + } + + langIndex, ok := language.CompactIndex(language.MustParse(lang)) + if !ok { + log.Fatalf("No compact index for language %s", lang) + } + + symbols[langIndex] = make([][numTypes]*string, b.numCurrencies+1) + + for _, c := range ldml.Numbers.Currencies.Currency { + syms := cldr.MakeSlice(&c.Symbol) + syms.SelectDraft(d) + + for _, sym := range c.Symbol { + v := sym.Data() + if v == c.Type { + // We define "" to mean the ISO symbol. + v = "" + } + cur := b.currencies.Index([]byte(c.Type)) + // XXX gets reassigned to 0 in the package's code. + if c.Type == "XXX" { + cur = 0 + } + if cur == -1 { + fmt.Println("Unsupported:", c.Type) + continue + } + + switch sym.Alt { + case "": + symbols[langIndex][cur][normal] = &v + case "narrow": + symbols[langIndex][cur][narrow] = &v + } + } + } + } + + // Remove values identical to the parent. + for langIndex, data := range symbols { + for curIndex, curs := range data { + for typ, sym := range curs { + if sym == nil { + continue + } + for p := uint16(langIndex); p != 0; { + p = internal.Parent[p] + x := symbols[p] + if x == nil { + continue + } + if v := x[curIndex][typ]; v != nil || p == 0 { + // Value is equal to the default value root value is undefined. + parentSym := "" + if v != nil { + parentSym = *v + } + if parentSym == *sym { + // Value is the same as parent. + data[curIndex][typ] = nil + } + break + } + } + } + } + } + + // Create symbol index. + symbolData := []byte{0} + symbolLookup := map[string]uint16{"": 0} // 0 means default, so block that value. + for _, data := range symbols { + for _, curs := range data { + for _, sym := range curs { + if sym == nil { + continue + } + if _, ok := symbolLookup[*sym]; !ok { + symbolLookup[*sym] = uint16(len(symbolData)) + symbolData = append(symbolData, byte(len(*sym))) + symbolData = append(symbolData, *sym...) + } + } + } + } + w.WriteComment(` + symbols holds symbol data of the form , where n is the length of + the symbol string str.`) + w.WriteConst("symbols", string(symbolData)) + + // Create index from language to currency lookup to symbol. + type curToIndex struct{ cur, idx uint16 } + w.WriteType(curToIndex{}) + + prefix := []string{"normal", "narrow"} + // Create data for regular and narrow symbol data. + for typ := normal; typ <= narrow; typ++ { + + indexes := []curToIndex{} // maps currency to symbol index + languages := []uint16{} + + for _, data := range symbols { + languages = append(languages, uint16(len(indexes))) + for curIndex, curs := range data { + + if sym := curs[typ]; sym != nil { + indexes = append(indexes, curToIndex{uint16(curIndex), symbolLookup[*sym]}) + } + } + } + languages = append(languages, uint16(len(indexes))) + + w.WriteVar(prefix[typ]+"LangIndex", languages) + w.WriteVar(prefix[typ]+"SymIndex", indexes) + } +} +func parseUint8(str string) uint8 { + x, err := strconv.ParseUint(str, 10, 8) + if err != nil { + // Show line number of where this function was called. + log.New(os.Stderr, "", log.Lshortfile).Output(2, err.Error()) + os.Exit(1) + } + return uint8(x) +} diff --git a/vendor/golang.org/x/text/currency/gen_common.go b/vendor/golang.org/x/text/currency/gen_common.go new file mode 100644 index 000000000..e6748da37 --- /dev/null +++ b/vendor/golang.org/x/text/currency/gen_common.go @@ -0,0 +1,70 @@ +// 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. + +// +build ignore + +package main + +import ( + "time" + + "golang.org/x/text/language" +) + +// This file contains code common to gen.go and the package code. + +const ( + cashShift = 3 + roundMask = 0x7 + + nonTenderBit = 0x8000 +) + +// currencyInfo contains information about a currency. +// bits 0..2: index into roundings for standard rounding +// bits 3..5: index into roundings for cash rounding +type currencyInfo byte + +// roundingType defines the scale (number of fractional decimals) and increments +// in terms of units of size 10^-scale. For example, for scale == 2 and +// increment == 1, the currency is rounded to units of 0.01. +type roundingType struct { + scale, increment uint8 +} + +// roundings contains rounding data for currencies. This struct is +// created by hand as it is very unlikely to change much. +var roundings = [...]roundingType{ + {2, 1}, // default + {0, 1}, + {1, 1}, + {3, 1}, + {4, 1}, + {2, 5}, // cash rounding alternative +} + +// regionToCode returns a 16-bit region code. Only two-letter codes are +// supported. (Three-letter codes are not needed.) +func regionToCode(r language.Region) uint16 { + if s := r.String(); len(s) == 2 { + return uint16(s[0])<<8 | uint16(s[1]) + } + return 0 +} + +func toDate(t time.Time) uint32 { + y := t.Year() + if y == 1 { + return 0 + } + date := uint32(y) << 4 + date |= uint32(t.Month()) + date <<= 5 + date |= uint32(t.Day()) + return date +} + +func fromDate(date uint32) time.Time { + return time.Date(int(date>>9), time.Month((date>>5)&0xf), int(date&0x1f), 0, 0, 0, 0, time.UTC) +} diff --git a/vendor/golang.org/x/text/currency/query.go b/vendor/golang.org/x/text/currency/query.go new file mode 100644 index 000000000..7bf9430a6 --- /dev/null +++ b/vendor/golang.org/x/text/currency/query.go @@ -0,0 +1,152 @@ +// 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 currency + +import ( + "sort" + "time" + + "golang.org/x/text/language" +) + +// QueryIter represents a set of Units. The default set includes all Units that +// are currently in use as legal tender in any Region. +type QueryIter interface { + // Next returns true if there is a next element available. + // It must be called before any of the other methods are called. + Next() bool + + // Unit returns the unit of the current iteration. + Unit() Unit + + // Region returns the Region for the current iteration. + Region() language.Region + + // From returns the date from which the unit was used in the region. + // It returns false if this date is unknown. + From() (time.Time, bool) + + // To returns the date up till which the unit was used in the region. + // It returns false if this date is unknown or if the unit is still in use. + To() (time.Time, bool) + + // IsTender reports whether the unit is a legal tender in the region during + // the specified date range. + IsTender() bool +} + +// Query represents a set of Units. The default set includes all Units that are +// currently in use as legal tender in any Region. +func Query(options ...QueryOption) QueryIter { + it := &iter{ + end: len(regionData), + date: 0xFFFFFFFF, + } + for _, fn := range options { + fn(it) + } + return it +} + +// NonTender returns a new query that also includes matching Units that are not +// legal tender. +var NonTender QueryOption = nonTender + +func nonTender(i *iter) { + i.nonTender = true +} + +// Historical selects the units for all dates. +var Historical QueryOption = historical + +func historical(i *iter) { + i.date = hist +} + +// A QueryOption can be used to change the set of unit information returned by +// a query. +type QueryOption func(*iter) + +// Date queries the units that were in use at the given point in history. +func Date(t time.Time) QueryOption { + d := toDate(t) + return func(i *iter) { + i.date = d + } +} + +// Region limits the query to only return entries for the given region. +func Region(r language.Region) QueryOption { + p, end := len(regionData), len(regionData) + x := regionToCode(r) + i := sort.Search(len(regionData), func(i int) bool { + return regionData[i].region >= x + }) + if i < len(regionData) && regionData[i].region == x { + p = i + for i++; i < len(regionData) && regionData[i].region == x; i++ { + } + end = i + } + return func(i *iter) { + i.p, i.end = p, end + } +} + +const ( + hist = 0x00 + now = 0xFFFFFFFF +) + +type iter struct { + *regionInfo + p, end int + date uint32 + nonTender bool +} + +func (i *iter) Next() bool { + for ; i.p < i.end; i.p++ { + i.regionInfo = ®ionData[i.p] + if !i.nonTender && !i.IsTender() { + continue + } + if i.date == hist || (i.from <= i.date && (i.to == 0 || i.date <= i.to)) { + i.p++ + return true + } + } + return false +} + +func (r *regionInfo) Region() language.Region { + // TODO: this could be much faster. + var buf [2]byte + buf[0] = uint8(r.region >> 8) + buf[1] = uint8(r.region) + return language.MustParseRegion(string(buf[:])) +} + +func (r *regionInfo) Unit() Unit { + return Unit{r.code &^ nonTenderBit} +} + +func (r *regionInfo) IsTender() bool { + return r.code&nonTenderBit == 0 +} + +func (r *regionInfo) From() (time.Time, bool) { + if r.from == 0 { + return time.Time{}, false + } + return fromDate(r.from), true +} + +func (r *regionInfo) To() (time.Time, bool) { + if r.to == 0 { + return time.Time{}, false + } + return fromDate(r.to), true +} diff --git a/vendor/golang.org/x/text/currency/query_test.go b/vendor/golang.org/x/text/currency/query_test.go new file mode 100644 index 000000000..6caea9dbb --- /dev/null +++ b/vendor/golang.org/x/text/currency/query_test.go @@ -0,0 +1,107 @@ +// 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 currency + +import ( + "testing" + "time" + + "golang.org/x/text/language" +) + +func TestQuery(t *testing.T) { + r := func(region string) language.Region { + return language.MustParseRegion(region) + } + t1800, _ := time.Parse("2006-01-02", "1800-01-01") + type result struct { + region language.Region + unit Unit + isTender bool + from, to string + } + testCases := []struct { + name string + opts []QueryOption + results []result + }{{ + name: "XA", + opts: []QueryOption{Region(r("XA"))}, + results: []result{}, + }, { + name: "AC", + opts: []QueryOption{Region(r("AC"))}, + results: []result{ + {r("AC"), MustParseISO("SHP"), true, "1976-01-01", ""}, + }, + }, { + name: "US", + opts: []QueryOption{Region(r("US"))}, + results: []result{ + {r("US"), MustParseISO("USD"), true, "1792-01-01", ""}, + }, + }, { + name: "US-hist", + opts: []QueryOption{Region(r("US")), Historical}, + results: []result{ + {r("US"), MustParseISO("USD"), true, "1792-01-01", ""}, + }, + }, { + name: "US-non-tender", + opts: []QueryOption{Region(r("US")), NonTender}, + results: []result{ + {r("US"), MustParseISO("USD"), true, "1792-01-01", ""}, + {r("US"), MustParseISO("USN"), false, "", ""}, + }, + }, { + name: "US-historical+non-tender", + opts: []QueryOption{Region(r("US")), Historical, NonTender}, + results: []result{ + {r("US"), MustParseISO("USD"), true, "1792-01-01", ""}, + {r("US"), MustParseISO("USN"), false, "", ""}, + {r("US"), MustParseISO("USS"), false, "", "2014-03-01"}, + }, + }, { + name: "1800", + opts: []QueryOption{Date(t1800)}, + results: []result{ + {r("CH"), MustParseISO("CHF"), true, "1799-03-17", ""}, + {r("GB"), MustParseISO("GBP"), true, "1694-07-27", ""}, + {r("GI"), MustParseISO("GIP"), true, "1713-01-01", ""}, + // The date for IE and PR seem wrong, so these may be updated at + // some point causing the tests to fail. + {r("IE"), MustParseISO("GBP"), true, "1800-01-01", "1922-01-01"}, + {r("PR"), MustParseISO("ESP"), true, "1800-01-01", "1898-12-10"}, + {r("US"), MustParseISO("USD"), true, "1792-01-01", ""}, + }, + }} + for _, tc := range testCases { + n := 0 + for it := Query(tc.opts...); it.Next(); n++ { + if n < len(tc.results) { + got := result{ + it.Region(), + it.Unit(), + it.IsTender(), + getTime(it.From()), + getTime(it.To()), + } + if got != tc.results[n] { + t.Errorf("%s:%d: got %v; want %v", tc.name, n, got, tc.results[n]) + } + } + } + if n != len(tc.results) { + t.Errorf("%s: unexpected number of results: got %d; want %d", tc.name, n, len(tc.results)) + } + } +} + +func getTime(t time.Time, ok bool) string { + if !ok { + return "" + } + return t.Format("2006-01-02") +} diff --git a/vendor/golang.org/x/text/currency/tables.go b/vendor/golang.org/x/text/currency/tables.go new file mode 100644 index 000000000..a34c7cb5f --- /dev/null +++ b/vendor/golang.org/x/text/currency/tables.go @@ -0,0 +1,2573 @@ +// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. + +package currency + +import "golang.org/x/text/internal/tag" + +// CLDRVersion is the CLDR version from which the tables in this package are derived. +const CLDRVersion = "30" + +const ( + xxx = 283 + xts = 281 + usd = 250 + eur = 93 + jpy = 132 + gbp = 98 + chf = 61 + aud = 19 + nzd = 191 + cad = 58 + sek = 218 + nok = 189 + dkk = 81 + xag = 264 + xau = 265 + xpt = 278 + xpd = 276 + brl = 46 + cny = 67 + inr = 124 + rub = 209 + hkd = 113 + idr = 119 + krw = 140 + mxn = 177 + pln = 200 + sar = 212 + thb = 233 + try = 242 + twd = 244 + zar = 291 +) + +// currency holds an alphabetically sorted list of canonical 3-letter currency +// identifiers. Each identifier is followed by a byte of type currencyInfo, +// defined in gen_common.go. +const currency tag.Index = "" + // Size: 1200 bytes + "\x00\x00\x00\x00ADP\x09AED\x00AFA\x00AFN\x09ALK\x00ALL\x09AMD\x09ANG\x00" + + "AOA\x00AOK\x00AON\x00AOR\x00ARA\x00ARL\x00ARM\x00ARP\x00ARS\x00ATS\x00AU" + + "D\x00AWG\x00AZM\x00AZN\x00BAD\x00BAM\x00BAN\x00BBD\x00BDT\x00BEC\x00BEF" + + "\x00BEL\x00BGL\x00BGM\x00BGN\x00BGO\x00BHD\x1bBIF\x09BMD\x00BND\x00BOB" + + "\x00BOL\x00BOP\x00BOV\x00BRB\x00BRC\x00BRE\x00BRL\x00BRN\x00BRR\x00BRZ" + + "\x00BSD\x00BTN\x00BUK\x00BWP\x00BYB\x00BYN\x00BYR\x09BZD\x00CAD(CDF\x00C" + + "HE\x00CHF(CHW\x00CLE\x00CLF$CLP\x09CNX\x00CNY\x00COP\x09COU\x00CRC\x08CS" + + "D\x00CSK\x00CUC\x00CUP\x00CVE\x00CYP\x00CZK\x08DDM\x00DEM\x00DJF\x09DKK" + + "\x00DOP\x00DZD\x00ECS\x00ECV\x00EEK\x00EGP\x00ERN\x00ESA\x00ESB\x00ESP" + + "\x09ETB\x00EUR\x00FIM\x00FJD\x00FKP\x00FRF\x00GBP\x00GEK\x00GEL\x00GHC" + + "\x00GHS\x00GIP\x00GMD\x00GNF\x09GNS\x00GQE\x00GRD\x00GTQ\x00GWE\x00GWP" + + "\x00GYD\x09HKD\x00HNL\x00HRD\x00HRK\x00HTG\x00HUF\x08IDR\x09IEP\x00ILP" + + "\x00ILR\x00ILS\x00INR\x00IQD\x09IRR\x09ISJ\x00ISK\x09ITL\x09JMD\x00JOD" + + "\x1bJPY\x09KES\x00KGS\x00KHR\x00KMF\x09KPW\x09KRH\x00KRO\x00KRW\x09KWD" + + "\x1bKYD\x00KZT\x00LAK\x09LBP\x09LKR\x00LRD\x00LSL\x00LTL\x00LTT\x00LUC" + + "\x00LUF\x09LUL\x00LVL\x00LVR\x00LYD\x1bMAD\x00MAF\x00MCF\x00MDC\x00MDL" + + "\x00MGA\x09MGF\x09MKD\x00MKN\x00MLF\x00MMK\x09MNT\x09MOP\x00MRO\x09MTL" + + "\x00MTP\x00MUR\x09MVP\x00MVR\x00MWK\x00MXN\x00MXP\x00MXV\x00MYR\x00MZE" + + "\x00MZM\x00MZN\x00NAD\x00NGN\x00NIC\x00NIO\x00NLG\x00NOK\x00NPR\x00NZD" + + "\x00OMR\x1bPAB\x00PEI\x00PEN\x00PES\x00PGK\x00PHP\x00PKR\x09PLN\x00PLZ" + + "\x00PTE\x00PYG\x09QAR\x00RHD\x00ROL\x00RON\x00RSD\x09RUB\x00RUR\x00RWF" + + "\x09SAR\x00SBD\x00SCR\x00SDD\x00SDG\x00SDP\x00SEK\x00SGD\x00SHP\x00SIT" + + "\x00SKK\x00SLL\x09SOS\x09SRD\x00SRG\x00SSP\x00STD\x09SUR\x00SVC\x00SYP" + + "\x09SZL\x00THB\x00TJR\x00TJS\x00TMM\x09TMT\x00TND\x1bTOP\x00TPE\x00TRL" + + "\x09TRY\x00TTD\x00TWD\x08TZS\x09UAH\x00UAK\x00UGS\x00UGX\x09USD\x00USN" + + "\x00USS\x00UYI\x09UYP\x00UYU\x00UZS\x09VEB\x00VEF\x00VND\x09VNN\x00VUV" + + "\x09WST\x00XAF\x09XAG\x00XAU\x00XBA\x00XBB\x00XBC\x00XBD\x00XCD\x00XDR" + + "\x00XEU\x00XFO\x00XFU\x00XOF\x09XPD\x00XPF\x09XPT\x00XRE\x00XSU\x00XTS" + + "\x00XUA\x00XXX\x00YDD\x00YER\x09YUD\x00YUM\x00YUN\x00YUR\x00ZAL\x00ZAR" + + "\x00ZMK\x09ZMW\x00ZRN\x00ZRZ\x00ZWD\x09ZWL\x00ZWR\x00\xff\xff\xff\xff" + +const numCurrencies = 298 + +type toCurrency struct { + region uint16 + code uint16 +} + +var regionToCurrency = []toCurrency{ // 255 elements + 0: {region: 0x4143, code: 0xdc}, + 1: {region: 0x4144, code: 0x5d}, + 2: {region: 0x4145, code: 0x2}, + 3: {region: 0x4146, code: 0x4}, + 4: {region: 0x4147, code: 0x10e}, + 5: {region: 0x4149, code: 0x10e}, + 6: {region: 0x414c, code: 0x6}, + 7: {region: 0x414d, code: 0x7}, + 8: {region: 0x414f, code: 0x9}, + 9: {region: 0x4152, code: 0x11}, + 10: {region: 0x4153, code: 0xfa}, + 11: {region: 0x4154, code: 0x5d}, + 12: {region: 0x4155, code: 0x13}, + 13: {region: 0x4157, code: 0x14}, + 14: {region: 0x4158, code: 0x5d}, + 15: {region: 0x415a, code: 0x16}, + 16: {region: 0x4241, code: 0x18}, + 17: {region: 0x4242, code: 0x1a}, + 18: {region: 0x4244, code: 0x1b}, + 19: {region: 0x4245, code: 0x5d}, + 20: {region: 0x4246, code: 0x113}, + 21: {region: 0x4247, code: 0x21}, + 22: {region: 0x4248, code: 0x23}, + 23: {region: 0x4249, code: 0x24}, + 24: {region: 0x424a, code: 0x113}, + 25: {region: 0x424c, code: 0x5d}, + 26: {region: 0x424d, code: 0x25}, + 27: {region: 0x424e, code: 0x26}, + 28: {region: 0x424f, code: 0x27}, + 29: {region: 0x4251, code: 0xfa}, + 30: {region: 0x4252, code: 0x2e}, + 31: {region: 0x4253, code: 0x32}, + 32: {region: 0x4254, code: 0x33}, + 33: {region: 0x4256, code: 0xbd}, + 34: {region: 0x4257, code: 0x35}, + 35: {region: 0x4259, code: 0x37}, + 36: {region: 0x425a, code: 0x39}, + 37: {region: 0x4341, code: 0x3a}, + 38: {region: 0x4343, code: 0x13}, + 39: {region: 0x4344, code: 0x3b}, + 40: {region: 0x4346, code: 0x107}, + 41: {region: 0x4347, code: 0x107}, + 42: {region: 0x4348, code: 0x3d}, + 43: {region: 0x4349, code: 0x113}, + 44: {region: 0x434b, code: 0xbf}, + 45: {region: 0x434c, code: 0x41}, + 46: {region: 0x434d, code: 0x107}, + 47: {region: 0x434e, code: 0x43}, + 48: {region: 0x434f, code: 0x44}, + 49: {region: 0x4352, code: 0x46}, + 50: {region: 0x4355, code: 0x4a}, + 51: {region: 0x4356, code: 0x4b}, + 52: {region: 0x4357, code: 0x8}, + 53: {region: 0x4358, code: 0x13}, + 54: {region: 0x4359, code: 0x5d}, + 55: {region: 0x435a, code: 0x4d}, + 56: {region: 0x4445, code: 0x5d}, + 57: {region: 0x4447, code: 0xfa}, + 58: {region: 0x444a, code: 0x50}, + 59: {region: 0x444b, code: 0x51}, + 60: {region: 0x444d, code: 0x10e}, + 61: {region: 0x444f, code: 0x52}, + 62: {region: 0x445a, code: 0x53}, + 63: {region: 0x4541, code: 0x5d}, + 64: {region: 0x4543, code: 0xfa}, + 65: {region: 0x4545, code: 0x5d}, + 66: {region: 0x4547, code: 0x57}, + 67: {region: 0x4548, code: 0x9d}, + 68: {region: 0x4552, code: 0x58}, + 69: {region: 0x4553, code: 0x5d}, + 70: {region: 0x4554, code: 0x5c}, + 71: {region: 0x4555, code: 0x5d}, + 72: {region: 0x4649, code: 0x5d}, + 73: {region: 0x464a, code: 0x5f}, + 74: {region: 0x464b, code: 0x60}, + 75: {region: 0x464d, code: 0xfa}, + 76: {region: 0x464f, code: 0x51}, + 77: {region: 0x4652, code: 0x5d}, + 78: {region: 0x4741, code: 0x107}, + 79: {region: 0x4742, code: 0x62}, + 80: {region: 0x4744, code: 0x10e}, + 81: {region: 0x4745, code: 0x64}, + 82: {region: 0x4746, code: 0x5d}, + 83: {region: 0x4747, code: 0x62}, + 84: {region: 0x4748, code: 0x66}, + 85: {region: 0x4749, code: 0x67}, + 86: {region: 0x474c, code: 0x51}, + 87: {region: 0x474d, code: 0x68}, + 88: {region: 0x474e, code: 0x69}, + 89: {region: 0x4750, code: 0x5d}, + 90: {region: 0x4751, code: 0x107}, + 91: {region: 0x4752, code: 0x5d}, + 92: {region: 0x4753, code: 0x62}, + 93: {region: 0x4754, code: 0x6d}, + 94: {region: 0x4755, code: 0xfa}, + 95: {region: 0x4757, code: 0x113}, + 96: {region: 0x4759, code: 0x70}, + 97: {region: 0x484b, code: 0x71}, + 98: {region: 0x484d, code: 0x13}, + 99: {region: 0x484e, code: 0x72}, + 100: {region: 0x4852, code: 0x74}, + 101: {region: 0x4854, code: 0x75}, + 102: {region: 0x4855, code: 0x76}, + 103: {region: 0x4943, code: 0x5d}, + 104: {region: 0x4944, code: 0x77}, + 105: {region: 0x4945, code: 0x5d}, + 106: {region: 0x494c, code: 0x7b}, + 107: {region: 0x494d, code: 0x62}, + 108: {region: 0x494e, code: 0x7c}, + 109: {region: 0x494f, code: 0xfa}, + 110: {region: 0x4951, code: 0x7d}, + 111: {region: 0x4952, code: 0x7e}, + 112: {region: 0x4953, code: 0x80}, + 113: {region: 0x4954, code: 0x5d}, + 114: {region: 0x4a45, code: 0x62}, + 115: {region: 0x4a4d, code: 0x82}, + 116: {region: 0x4a4f, code: 0x83}, + 117: {region: 0x4a50, code: 0x84}, + 118: {region: 0x4b45, code: 0x85}, + 119: {region: 0x4b47, code: 0x86}, + 120: {region: 0x4b48, code: 0x87}, + 121: {region: 0x4b49, code: 0x13}, + 122: {region: 0x4b4d, code: 0x88}, + 123: {region: 0x4b4e, code: 0x10e}, + 124: {region: 0x4b50, code: 0x89}, + 125: {region: 0x4b52, code: 0x8c}, + 126: {region: 0x4b57, code: 0x8d}, + 127: {region: 0x4b59, code: 0x8e}, + 128: {region: 0x4b5a, code: 0x8f}, + 129: {region: 0x4c41, code: 0x90}, + 130: {region: 0x4c42, code: 0x91}, + 131: {region: 0x4c43, code: 0x10e}, + 132: {region: 0x4c49, code: 0x3d}, + 133: {region: 0x4c4b, code: 0x92}, + 134: {region: 0x4c52, code: 0x93}, + 135: {region: 0x4c53, code: 0x123}, + 136: {region: 0x4c54, code: 0x5d}, + 137: {region: 0x4c55, code: 0x5d}, + 138: {region: 0x4c56, code: 0x5d}, + 139: {region: 0x4c59, code: 0x9c}, + 140: {region: 0x4d41, code: 0x9d}, + 141: {region: 0x4d43, code: 0x5d}, + 142: {region: 0x4d44, code: 0xa1}, + 143: {region: 0x4d45, code: 0x5d}, + 144: {region: 0x4d46, code: 0x5d}, + 145: {region: 0x4d47, code: 0xa2}, + 146: {region: 0x4d48, code: 0xfa}, + 147: {region: 0x4d4b, code: 0xa4}, + 148: {region: 0x4d4c, code: 0x113}, + 149: {region: 0x4d4d, code: 0xa7}, + 150: {region: 0x4d4e, code: 0xa8}, + 151: {region: 0x4d4f, code: 0xa9}, + 152: {region: 0x4d50, code: 0xfa}, + 153: {region: 0x4d51, code: 0x5d}, + 154: {region: 0x4d52, code: 0xaa}, + 155: {region: 0x4d53, code: 0x10e}, + 156: {region: 0x4d54, code: 0x5d}, + 157: {region: 0x4d55, code: 0xad}, + 158: {region: 0x4d56, code: 0xaf}, + 159: {region: 0x4d57, code: 0xb0}, + 160: {region: 0x4d58, code: 0xb1}, + 161: {region: 0x4d59, code: 0xb4}, + 162: {region: 0x4d5a, code: 0xb7}, + 163: {region: 0x4e41, code: 0xb8}, + 164: {region: 0x4e43, code: 0x115}, + 165: {region: 0x4e45, code: 0x113}, + 166: {region: 0x4e46, code: 0x13}, + 167: {region: 0x4e47, code: 0xb9}, + 168: {region: 0x4e49, code: 0xbb}, + 169: {region: 0x4e4c, code: 0x5d}, + 170: {region: 0x4e4f, code: 0xbd}, + 171: {region: 0x4e50, code: 0xbe}, + 172: {region: 0x4e52, code: 0x13}, + 173: {region: 0x4e55, code: 0xbf}, + 174: {region: 0x4e5a, code: 0xbf}, + 175: {region: 0x4f4d, code: 0xc0}, + 176: {region: 0x5041, code: 0xc1}, + 177: {region: 0x5045, code: 0xc3}, + 178: {region: 0x5046, code: 0x115}, + 179: {region: 0x5047, code: 0xc5}, + 180: {region: 0x5048, code: 0xc6}, + 181: {region: 0x504b, code: 0xc7}, + 182: {region: 0x504c, code: 0xc8}, + 183: {region: 0x504d, code: 0x5d}, + 184: {region: 0x504e, code: 0xbf}, + 185: {region: 0x5052, code: 0xfa}, + 186: {region: 0x5053, code: 0x7b}, + 187: {region: 0x5054, code: 0x5d}, + 188: {region: 0x5057, code: 0xfa}, + 189: {region: 0x5059, code: 0xcb}, + 190: {region: 0x5141, code: 0xcc}, + 191: {region: 0x5245, code: 0x5d}, + 192: {region: 0x524f, code: 0xcf}, + 193: {region: 0x5253, code: 0xd0}, + 194: {region: 0x5255, code: 0xd1}, + 195: {region: 0x5257, code: 0xd3}, + 196: {region: 0x5341, code: 0xd4}, + 197: {region: 0x5342, code: 0xd5}, + 198: {region: 0x5343, code: 0xd6}, + 199: {region: 0x5344, code: 0xd8}, + 200: {region: 0x5345, code: 0xda}, + 201: {region: 0x5347, code: 0xdb}, + 202: {region: 0x5348, code: 0xdc}, + 203: {region: 0x5349, code: 0x5d}, + 204: {region: 0x534a, code: 0xbd}, + 205: {region: 0x534b, code: 0x5d}, + 206: {region: 0x534c, code: 0xdf}, + 207: {region: 0x534d, code: 0x5d}, + 208: {region: 0x534e, code: 0x113}, + 209: {region: 0x534f, code: 0xe0}, + 210: {region: 0x5352, code: 0xe1}, + 211: {region: 0x5353, code: 0xe3}, + 212: {region: 0x5354, code: 0xe4}, + 213: {region: 0x5356, code: 0xfa}, + 214: {region: 0x5358, code: 0x8}, + 215: {region: 0x5359, code: 0xe7}, + 216: {region: 0x535a, code: 0xe8}, + 217: {region: 0x5441, code: 0x62}, + 218: {region: 0x5443, code: 0xfa}, + 219: {region: 0x5444, code: 0x107}, + 220: {region: 0x5446, code: 0x5d}, + 221: {region: 0x5447, code: 0x113}, + 222: {region: 0x5448, code: 0xe9}, + 223: {region: 0x544a, code: 0xeb}, + 224: {region: 0x544b, code: 0xbf}, + 225: {region: 0x544c, code: 0xfa}, + 226: {region: 0x544d, code: 0xed}, + 227: {region: 0x544e, code: 0xee}, + 228: {region: 0x544f, code: 0xef}, + 229: {region: 0x5452, code: 0xf2}, + 230: {region: 0x5454, code: 0xf3}, + 231: {region: 0x5456, code: 0x13}, + 232: {region: 0x5457, code: 0xf4}, + 233: {region: 0x545a, code: 0xf5}, + 234: {region: 0x5541, code: 0xf6}, + 235: {region: 0x5547, code: 0xf9}, + 236: {region: 0x554d, code: 0xfa}, + 237: {region: 0x5553, code: 0xfa}, + 238: {region: 0x5559, code: 0xff}, + 239: {region: 0x555a, code: 0x100}, + 240: {region: 0x5641, code: 0x5d}, + 241: {region: 0x5643, code: 0x10e}, + 242: {region: 0x5645, code: 0x102}, + 243: {region: 0x5647, code: 0xfa}, + 244: {region: 0x5649, code: 0xfa}, + 245: {region: 0x564e, code: 0x103}, + 246: {region: 0x5655, code: 0x105}, + 247: {region: 0x5746, code: 0x115}, + 248: {region: 0x5753, code: 0x106}, + 249: {region: 0x584b, code: 0x5d}, + 250: {region: 0x5945, code: 0x11d}, + 251: {region: 0x5954, code: 0x5d}, + 252: {region: 0x5a41, code: 0x123}, + 253: {region: 0x5a4d, code: 0x125}, + 254: {region: 0x5a57, code: 0xfa}, +} // Size: 1044 bytes + +type regionInfo struct { + region uint16 + code uint16 + from uint32 + to uint32 +} + +var regionData = []regionInfo{ // 493 elements + 0: {region: 0x4143, code: 0xdc, from: 0xf7021, to: 0x0}, + 1: {region: 0x4144, code: 0x5d, from: 0xf9e21, to: 0x0}, + 2: {region: 0x4144, code: 0x5b, from: 0xea221, to: 0xfa45c}, + 3: {region: 0x4144, code: 0x61, from: 0xf5021, to: 0xfa451}, + 4: {region: 0x4144, code: 0x1, from: 0xf2021, to: 0xfa39f}, + 5: {region: 0x4145, code: 0x2, from: 0xf6ab3, to: 0x0}, + 6: {region: 0x4146, code: 0x4, from: 0xfa547, to: 0x0}, + 7: {region: 0x4146, code: 0x3, from: 0xf0e6e, to: 0xfa59f}, + 8: {region: 0x4147, code: 0x10e, from: 0xf5b46, to: 0x0}, + 9: {region: 0x4149, code: 0x10e, from: 0xf5b46, to: 0x0}, + 10: {region: 0x414c, code: 0x6, from: 0xf5b10, to: 0x0}, + 11: {region: 0x414c, code: 0x5, from: 0xf3561, to: 0xf5b10}, + 12: {region: 0x414d, code: 0x7, from: 0xf9376, to: 0x0}, + 13: {region: 0x414d, code: 0xd2, from: 0xf8f99, to: 0xf9376}, + 14: {region: 0x414d, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 15: {region: 0x414f, code: 0x9, from: 0xf9f8d, to: 0x0}, + 16: {region: 0x414f, code: 0xc, from: 0xf96e1, to: 0xfa041}, + 17: {region: 0x414f, code: 0xb, from: 0xf8d39, to: 0xfa041}, + 18: {region: 0x414f, code: 0xa, from: 0xf7228, to: 0xf8e61}, + 19: {region: 0x4151, code: 0x811b, from: 0x0, to: 0x0}, + 20: {region: 0x4152, code: 0x11, from: 0xf9021, to: 0x0}, + 21: {region: 0x4152, code: 0xd, from: 0xf82ce, to: 0xf9021}, + 22: {region: 0x4152, code: 0x10, from: 0xf7ec1, to: 0xf82ce}, + 23: {region: 0x4152, code: 0xe, from: 0xf6421, to: 0xf7ec1}, + 24: {region: 0x4152, code: 0xf, from: 0xeb365, to: 0xf6421}, + 25: {region: 0x4153, code: 0xfa, from: 0xee0f0, to: 0x0}, + 26: {region: 0x4154, code: 0x5d, from: 0xf9e21, to: 0x0}, + 27: {region: 0x4154, code: 0x12, from: 0xf3784, to: 0xfa45c}, + 28: {region: 0x4155, code: 0x13, from: 0xf5c4e, to: 0x0}, + 29: {region: 0x4157, code: 0x14, from: 0xf8421, to: 0x0}, + 30: {region: 0x4157, code: 0x8, from: 0xf28aa, to: 0xf8421}, + 31: {region: 0x4158, code: 0x5d, from: 0xf9e21, to: 0x0}, + 32: {region: 0x415a, code: 0x16, from: 0xfac21, to: 0x0}, + 33: {region: 0x415a, code: 0x15, from: 0xf9376, to: 0xfad9f}, + 34: {region: 0x415a, code: 0xd2, from: 0xf8f99, to: 0xf9421}, + 35: {region: 0x415a, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 36: {region: 0x4241, code: 0x18, from: 0xf9621, to: 0x0}, + 37: {region: 0x4241, code: 0x19, from: 0xf950f, to: 0xf9ae1}, + 38: {region: 0x4241, code: 0x17, from: 0xf90e1, to: 0xf950f}, + 39: {region: 0x4241, code: 0x121, from: 0xf90e1, to: 0xf9341}, + 40: {region: 0x4241, code: 0x120, from: 0xf8c21, to: 0xf90e1}, + 41: {region: 0x4241, code: 0x11e, from: 0xf5c21, to: 0xf8c21}, + 42: {region: 0x4242, code: 0x1a, from: 0xf6b83, to: 0x0}, + 43: {region: 0x4242, code: 0x10e, from: 0xf5b46, to: 0xf6b83}, + 44: {region: 0x4244, code: 0x1b, from: 0xf6821, to: 0x0}, + 45: {region: 0x4244, code: 0xc7, from: 0xf3881, to: 0xf6821}, + 46: {region: 0x4244, code: 0x7c, from: 0xe5711, to: 0xf3881}, + 47: {region: 0x4245, code: 0x5d, from: 0xf9e21, to: 0x0}, + 48: {region: 0x4245, code: 0x1d, from: 0xe4e47, to: 0xfa45c}, + 49: {region: 0x4245, code: 0xbc, from: 0xe318f, to: 0xe4e47}, + 50: {region: 0x4245, code: 0x801e, from: 0xf6421, to: 0xf8c65}, + 51: {region: 0x4245, code: 0x801c, from: 0xf6421, to: 0xf8c65}, + 52: {region: 0x4246, code: 0x113, from: 0xf8104, to: 0x0}, + 53: {region: 0x4247, code: 0x21, from: 0xf9ee5, to: 0x0}, + 54: {region: 0x4247, code: 0x1f, from: 0xf5421, to: 0xf9ee5}, + 55: {region: 0x4247, code: 0x20, from: 0xf40ac, to: 0xf5421}, + 56: {region: 0x4247, code: 0x22, from: 0xeaee8, to: 0xf40ac}, + 57: {region: 0x4248, code: 0x23, from: 0xf5b50, to: 0x0}, + 58: {region: 0x4249, code: 0x24, from: 0xf58b3, to: 0x0}, + 59: {region: 0x424a, code: 0x113, from: 0xf6f7e, to: 0x0}, + 60: {region: 0x424c, code: 0x5d, from: 0xf9e21, to: 0x0}, + 61: {region: 0x424c, code: 0x61, from: 0xf5021, to: 0xfa451}, + 62: {region: 0x424d, code: 0x25, from: 0xf6446, to: 0x0}, + 63: {region: 0x424e, code: 0x26, from: 0xf5ecc, to: 0x0}, + 64: {region: 0x424e, code: 0xb4, from: 0xf5730, to: 0xf5ecc}, + 65: {region: 0x424f, code: 0x27, from: 0xf8621, to: 0x0}, + 66: {region: 0x424f, code: 0x29, from: 0xf5621, to: 0xf859f}, + 67: {region: 0x424f, code: 0x28, from: 0xe8ed7, to: 0xf5621}, + 68: {region: 0x424f, code: 0x802a, from: 0x0, to: 0x0}, + 69: {region: 0x4251, code: 0xfa, from: 0xfb621, to: 0x0}, + 70: {region: 0x4251, code: 0x8, from: 0xfb54a, to: 0xfb621}, + 71: {region: 0x4252, code: 0x2e, from: 0xf94e1, to: 0x0}, + 72: {region: 0x4252, code: 0x30, from: 0xf9301, to: 0xf94e1}, + 73: {region: 0x4252, code: 0x2d, from: 0xf8c70, to: 0xf9301}, + 74: {region: 0x4252, code: 0x2f, from: 0xf8a2f, to: 0xf8c70}, + 75: {region: 0x4252, code: 0x2c, from: 0xf845c, to: 0xf8a2f}, + 76: {region: 0x4252, code: 0x2b, from: 0xf5e4d, to: 0xf845c}, + 77: {region: 0x4252, code: 0x31, from: 0xf2d61, to: 0xf5e4d}, + 78: {region: 0x4253, code: 0x32, from: 0xf5cb9, to: 0x0}, + 79: {region: 0x4254, code: 0x33, from: 0xf6c90, to: 0x0}, + 80: {region: 0x4254, code: 0x7c, from: 0xee621, to: 0x0}, + 81: {region: 0x4255, code: 0x34, from: 0xf40e1, to: 0xf8ad2}, + 82: {region: 0x4256, code: 0xbd, from: 0xee2c7, to: 0x0}, + 83: {region: 0x4257, code: 0x35, from: 0xf7117, to: 0x0}, + 84: {region: 0x4257, code: 0x123, from: 0xf524e, to: 0xf7117}, + 85: {region: 0x4259, code: 0x37, from: 0xfc0e1, to: 0x0}, + 86: {region: 0x4259, code: 0x38, from: 0xfa021, to: 0xfc221}, + 87: {region: 0x4259, code: 0x36, from: 0xf9501, to: 0xfa19f}, + 88: {region: 0x4259, code: 0xd2, from: 0xf8f99, to: 0xf9568}, + 89: {region: 0x4259, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 90: {region: 0x425a, code: 0x39, from: 0xf6c21, to: 0x0}, + 91: {region: 0x4341, code: 0x3a, from: 0xe8421, to: 0x0}, + 92: {region: 0x4343, code: 0x13, from: 0xf5c4e, to: 0x0}, + 93: {region: 0x4344, code: 0x3b, from: 0xf9ce1, to: 0x0}, + 94: {region: 0x4344, code: 0x126, from: 0xf9361, to: 0xf9ce1}, + 95: {region: 0x4344, code: 0x127, from: 0xf675b, to: 0xf9361}, + 96: {region: 0x4346, code: 0x107, from: 0xf9221, to: 0x0}, + 97: {region: 0x4347, code: 0x107, from: 0xf9221, to: 0x0}, + 98: {region: 0x4348, code: 0x3d, from: 0xe0e71, to: 0x0}, + 99: {region: 0x4348, code: 0x803c, from: 0x0, to: 0x0}, + 100: {region: 0x4348, code: 0x803e, from: 0x0, to: 0x0}, + 101: {region: 0x4349, code: 0x113, from: 0xf4d84, to: 0x0}, + 102: {region: 0x434b, code: 0xbf, from: 0xf5eea, to: 0x0}, + 103: {region: 0x434c, code: 0x41, from: 0xf6f3d, to: 0x0}, + 104: {region: 0x434c, code: 0x3f, from: 0xf5021, to: 0xf6f3d}, + 105: {region: 0x434c, code: 0x8040, from: 0x0, to: 0x0}, + 106: {region: 0x434d, code: 0x107, from: 0xf6a81, to: 0x0}, + 107: {region: 0x434e, code: 0x43, from: 0xf4261, to: 0x0}, + 108: {region: 0x434e, code: 0x8042, from: 0xf7621, to: 0xf9d9f}, + 109: {region: 0x434f, code: 0x44, from: 0xee221, to: 0x0}, + 110: {region: 0x434f, code: 0x8045, from: 0x0, to: 0x0}, + 111: {region: 0x4350, code: 0x811b, from: 0x0, to: 0x0}, + 112: {region: 0x4352, code: 0x46, from: 0xed15a, to: 0x0}, + 113: {region: 0x4353, code: 0x47, from: 0xfa4af, to: 0xfacc3}, + 114: {region: 0x4353, code: 0x5d, from: 0xfa644, to: 0xfacc3}, + 115: {region: 0x4353, code: 0x11f, from: 0xf9438, to: 0xfa4af}, + 116: {region: 0x4355, code: 0x4a, from: 0xe8621, to: 0x0}, + 117: {region: 0x4355, code: 0x49, from: 0xf9421, to: 0x0}, + 118: {region: 0x4355, code: 0xfa, from: 0xed621, to: 0xf4e21}, + 119: {region: 0x4356, code: 0x4b, from: 0xef421, to: 0x0}, + 120: {region: 0x4356, code: 0xca, from: 0xeeeb6, to: 0xf6ee5}, + 121: {region: 0x4357, code: 0x8, from: 0xfb54a, to: 0x0}, + 122: {region: 0x4358, code: 0x13, from: 0xf5c4e, to: 0x0}, + 123: {region: 0x4359, code: 0x5d, from: 0xfb021, to: 0x0}, + 124: {region: 0x4359, code: 0x4c, from: 0xef52a, to: 0xfb03f}, + 125: {region: 0x435a, code: 0x4d, from: 0xf9221, to: 0x0}, + 126: {region: 0x435a, code: 0x48, from: 0xf42c1, to: 0xf9261}, + 127: {region: 0x4444, code: 0x4e, from: 0xf38f4, to: 0xf8d42}, + 128: {region: 0x4445, code: 0x5d, from: 0xf9e21, to: 0x0}, + 129: {region: 0x4445, code: 0x4f, from: 0xf38d4, to: 0xfa45c}, + 130: {region: 0x4447, code: 0xfa, from: 0xf5b68, to: 0x0}, + 131: {region: 0x444a, code: 0x50, from: 0xf72db, to: 0x0}, + 132: {region: 0x444b, code: 0x51, from: 0xea2bb, to: 0x0}, + 133: {region: 0x444d, code: 0x10e, from: 0xf5b46, to: 0x0}, + 134: {region: 0x444f, code: 0x52, from: 0xf3741, to: 0x0}, + 135: {region: 0x444f, code: 0xfa, from: 0xee2d5, to: 0xf3741}, + 136: {region: 0x445a, code: 0x53, from: 0xf5881, to: 0x0}, + 137: {region: 0x4541, code: 0x5d, from: 0xf9e21, to: 0x0}, + 138: {region: 0x4543, code: 0xfa, from: 0xfa142, to: 0x0}, + 139: {region: 0x4543, code: 0x54, from: 0xeb881, to: 0xfa142}, + 140: {region: 0x4543, code: 0x8055, from: 0xf92b7, to: 0xfa029}, + 141: {region: 0x4545, code: 0x5d, from: 0xfb621, to: 0x0}, + 142: {region: 0x4545, code: 0x56, from: 0xf90d5, to: 0xfb59f}, + 143: {region: 0x4545, code: 0xe5, from: 0xf5221, to: 0xf90d4}, + 144: {region: 0x4547, code: 0x57, from: 0xebb6e, to: 0x0}, + 145: {region: 0x4548, code: 0x9d, from: 0xf705a, to: 0x0}, + 146: {region: 0x4552, code: 0x58, from: 0xf9b68, to: 0x0}, + 147: {region: 0x4552, code: 0x5c, from: 0xf92b8, to: 0xf9b68}, + 148: {region: 0x4553, code: 0x5d, from: 0xf9e21, to: 0x0}, + 149: {region: 0x4553, code: 0x5b, from: 0xe9953, to: 0xfa45c}, + 150: {region: 0x4553, code: 0x8059, from: 0xf7421, to: 0xf7b9f}, + 151: {region: 0x4553, code: 0x805a, from: 0xf6e21, to: 0xf959f}, + 152: {region: 0x4554, code: 0x5c, from: 0xf712f, to: 0x0}, + 153: {region: 0x4555, code: 0x5d, from: 0xf9e21, to: 0x0}, + 154: {region: 0x4555, code: 0x8110, from: 0xf7621, to: 0xf9d9f}, + 155: {region: 0x4649, code: 0x5d, from: 0xf9e21, to: 0x0}, + 156: {region: 0x4649, code: 0x5e, from: 0xf5621, to: 0xfa45c}, + 157: {region: 0x464a, code: 0x5f, from: 0xf622d, to: 0x0}, + 158: {region: 0x464b, code: 0x60, from: 0xeda21, to: 0x0}, + 159: {region: 0x464d, code: 0xfa, from: 0xf3021, to: 0x0}, + 160: {region: 0x464d, code: 0x84, from: 0xef543, to: 0xf3021}, + 161: {region: 0x464f, code: 0x51, from: 0xf3821, to: 0x0}, + 162: {region: 0x4652, code: 0x5d, from: 0xf9e21, to: 0x0}, + 163: {region: 0x4652, code: 0x61, from: 0xf5021, to: 0xfa451}, + 164: {region: 0x4741, code: 0x107, from: 0xf9221, to: 0x0}, + 165: {region: 0x4742, code: 0x62, from: 0xd3cfb, to: 0x0}, + 166: {region: 0x4744, code: 0x10e, from: 0xf5e5b, to: 0x0}, + 167: {region: 0x4745, code: 0x64, from: 0xf9737, to: 0x0}, + 168: {region: 0x4745, code: 0x63, from: 0xf9285, to: 0xf9739}, + 169: {region: 0x4745, code: 0xd2, from: 0xf8f99, to: 0xf92cb}, + 170: {region: 0x4745, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 171: {region: 0x4746, code: 0x5d, from: 0xf9e21, to: 0x0}, + 172: {region: 0x4746, code: 0x61, from: 0xf5021, to: 0xfa451}, + 173: {region: 0x4747, code: 0x62, from: 0xe4c21, to: 0x0}, + 174: {region: 0x4748, code: 0x66, from: 0xfaee3, to: 0x0}, + 175: {region: 0x4748, code: 0x65, from: 0xf7669, to: 0xfaf9f}, + 176: {region: 0x4749, code: 0x67, from: 0xd6221, to: 0x0}, + 177: {region: 0x474c, code: 0x51, from: 0xea2bb, to: 0x0}, + 178: {region: 0x474d, code: 0x68, from: 0xf66e1, to: 0x0}, + 179: {region: 0x474e, code: 0x69, from: 0xf8426, to: 0x0}, + 180: {region: 0x474e, code: 0x6a, from: 0xf6942, to: 0xf8426}, + 181: {region: 0x4750, code: 0x5d, from: 0xf9e21, to: 0x0}, + 182: {region: 0x4750, code: 0x61, from: 0xf5021, to: 0xfa451}, + 183: {region: 0x4751, code: 0x107, from: 0xf9221, to: 0x0}, + 184: {region: 0x4751, code: 0x6b, from: 0xf6ee7, to: 0xf84c1}, + 185: {region: 0x4752, code: 0x5d, from: 0xfa221, to: 0x0}, + 186: {region: 0x4752, code: 0x6c, from: 0xf44a1, to: 0xfa45c}, + 187: {region: 0x4753, code: 0x62, from: 0xee821, to: 0x0}, + 188: {region: 0x4754, code: 0x6d, from: 0xf0abb, to: 0x0}, + 189: {region: 0x4755, code: 0xfa, from: 0xf3115, to: 0x0}, + 190: {region: 0x4757, code: 0x113, from: 0xf9a7f, to: 0x0}, + 191: {region: 0x4757, code: 0x6f, from: 0xf705c, to: 0xf9a7f}, + 192: {region: 0x4757, code: 0x6e, from: 0xef421, to: 0xf705c}, + 193: {region: 0x4759, code: 0x70, from: 0xf5cba, to: 0x0}, + 194: {region: 0x484b, code: 0x71, from: 0xece42, to: 0x0}, + 195: {region: 0x484d, code: 0x13, from: 0xf5e50, to: 0x0}, + 196: {region: 0x484e, code: 0x72, from: 0xf0c83, to: 0x0}, + 197: {region: 0x4852, code: 0x74, from: 0xf94be, to: 0x0}, + 198: {region: 0x4852, code: 0x73, from: 0xf8f97, to: 0xf9621}, + 199: {region: 0x4852, code: 0x120, from: 0xf8c21, to: 0xf8f97}, + 200: {region: 0x4852, code: 0x11e, from: 0xf5c21, to: 0xf8c21}, + 201: {region: 0x4854, code: 0x75, from: 0xea11a, to: 0x0}, + 202: {region: 0x4854, code: 0xfa, from: 0xef621, to: 0x0}, + 203: {region: 0x4855, code: 0x76, from: 0xf34f7, to: 0x0}, + 204: {region: 0x4943, code: 0x5d, from: 0xf9e21, to: 0x0}, + 205: {region: 0x4944, code: 0x77, from: 0xf5b8d, to: 0x0}, + 206: {region: 0x4945, code: 0x5d, from: 0xf9e21, to: 0x0}, + 207: {region: 0x4945, code: 0x78, from: 0xf0421, to: 0xfa449}, + 208: {region: 0x4945, code: 0x62, from: 0xe1021, to: 0xf0421}, + 209: {region: 0x494c, code: 0x7b, from: 0xf8324, to: 0x0}, + 210: {region: 0x494c, code: 0x7a, from: 0xf7856, to: 0xf8324}, + 211: {region: 0x494c, code: 0x79, from: 0xf3910, to: 0xf7856}, + 212: {region: 0x494d, code: 0x62, from: 0xe6023, to: 0x0}, + 213: {region: 0x494e, code: 0x7c, from: 0xe5711, to: 0x0}, + 214: {region: 0x494f, code: 0xfa, from: 0xf5b68, to: 0x0}, + 215: {region: 0x4951, code: 0x7d, from: 0xf1693, to: 0x0}, + 216: {region: 0x4951, code: 0x57, from: 0xf016b, to: 0xf1693}, + 217: {region: 0x4951, code: 0x7c, from: 0xf016b, to: 0xf1693}, + 218: {region: 0x4952, code: 0x7e, from: 0xf18ad, to: 0x0}, + 219: {region: 0x4953, code: 0x80, from: 0xf7a21, to: 0x0}, + 220: {region: 0x4953, code: 0x7f, from: 0xefd81, to: 0xf7a21}, + 221: {region: 0x4953, code: 0x51, from: 0xea2bb, to: 0xefd81}, + 222: {region: 0x4954, code: 0x5d, from: 0xf9e21, to: 0x0}, + 223: {region: 0x4954, code: 0x81, from: 0xe8d18, to: 0xfa45c}, + 224: {region: 0x4a45, code: 0x62, from: 0xe5a21, to: 0x0}, + 225: {region: 0x4a4d, code: 0x82, from: 0xf6328, to: 0x0}, + 226: {region: 0x4a4f, code: 0x83, from: 0xf3ce1, to: 0x0}, + 227: {region: 0x4a50, code: 0x84, from: 0xe9ec1, to: 0x0}, + 228: {region: 0x4b45, code: 0x85, from: 0xf5d2e, to: 0x0}, + 229: {region: 0x4b47, code: 0x86, from: 0xf92aa, to: 0x0}, + 230: {region: 0x4b47, code: 0xd2, from: 0xf8f99, to: 0xf92aa}, + 231: {region: 0x4b47, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 232: {region: 0x4b48, code: 0x87, from: 0xf7874, to: 0x0}, + 233: {region: 0x4b49, code: 0x13, from: 0xf5c4e, to: 0x0}, + 234: {region: 0x4b4d, code: 0x88, from: 0xf6ee6, to: 0x0}, + 235: {region: 0x4b4e, code: 0x10e, from: 0xf5b46, to: 0x0}, + 236: {region: 0x4b50, code: 0x89, from: 0xf4e91, to: 0x0}, + 237: {region: 0x4b52, code: 0x8c, from: 0xf54ca, to: 0x0}, + 238: {region: 0x4b52, code: 0x8a, from: 0xf424f, to: 0xf54ca}, + 239: {region: 0x4b52, code: 0x8b, from: 0xf330f, to: 0xf424f}, + 240: {region: 0x4b57, code: 0x8d, from: 0xf5281, to: 0x0}, + 241: {region: 0x4b59, code: 0x8e, from: 0xf6621, to: 0x0}, + 242: {region: 0x4b59, code: 0x82, from: 0xf6328, to: 0xf6621}, + 243: {region: 0x4b5a, code: 0x8f, from: 0xf9365, to: 0x0}, + 244: {region: 0x4c41, code: 0x90, from: 0xf778a, to: 0x0}, + 245: {region: 0x4c42, code: 0x91, from: 0xf3842, to: 0x0}, + 246: {region: 0x4c43, code: 0x10e, from: 0xf5b46, to: 0x0}, + 247: {region: 0x4c49, code: 0x3d, from: 0xf0241, to: 0x0}, + 248: {region: 0x4c4b, code: 0x92, from: 0xf74b6, to: 0x0}, + 249: {region: 0x4c52, code: 0x93, from: 0xf3021, to: 0x0}, + 250: {region: 0x4c53, code: 0x123, from: 0xf524e, to: 0x0}, + 251: {region: 0x4c53, code: 0x94, from: 0xf7836, to: 0x0}, + 252: {region: 0x4c54, code: 0x5d, from: 0xfbe21, to: 0x0}, + 253: {region: 0x4c54, code: 0x95, from: 0xf92d9, to: 0xfbd9f}, + 254: {region: 0x4c54, code: 0x96, from: 0xf9141, to: 0xf92d9}, + 255: {region: 0x4c54, code: 0xe5, from: 0xf5221, to: 0xf9141}, + 256: {region: 0x4c55, code: 0x5d, from: 0xf9e21, to: 0x0}, + 257: {region: 0x4c55, code: 0x98, from: 0xf3124, to: 0xfa45c}, + 258: {region: 0x4c55, code: 0x8097, from: 0xf6421, to: 0xf8c65}, + 259: {region: 0x4c55, code: 0x8099, from: 0xf6421, to: 0xf8c65}, + 260: {region: 0x4c56, code: 0x5d, from: 0xfbc21, to: 0x0}, + 261: {region: 0x4c56, code: 0x9a, from: 0xf92dc, to: 0xfbb9f}, + 262: {region: 0x4c56, code: 0x9b, from: 0xf90a7, to: 0xf9351}, + 263: {region: 0x4c56, code: 0xe5, from: 0xf5221, to: 0xf90f4}, + 264: {region: 0x4c59, code: 0x9c, from: 0xf6721, to: 0x0}, + 265: {region: 0x4d41, code: 0x9d, from: 0xf4f51, to: 0x0}, + 266: {region: 0x4d41, code: 0x9e, from: 0xeb221, to: 0xf4f51}, + 267: {region: 0x4d43, code: 0x5d, from: 0xf9e21, to: 0x0}, + 268: {region: 0x4d43, code: 0x61, from: 0xf5021, to: 0xfa451}, + 269: {region: 0x4d43, code: 0x9f, from: 0xf5021, to: 0xfa451}, + 270: {region: 0x4d44, code: 0xa1, from: 0xf937d, to: 0x0}, + 271: {region: 0x4d44, code: 0xa0, from: 0xf90c1, to: 0xf937d}, + 272: {region: 0x4d45, code: 0x5d, from: 0xfa421, to: 0x0}, + 273: {region: 0x4d45, code: 0x4f, from: 0xf9f42, to: 0xfa4af}, + 274: {region: 0x4d45, code: 0x11f, from: 0xf9438, to: 0xfa4af}, + 275: {region: 0x4d46, code: 0x5d, from: 0xf9e21, to: 0x0}, + 276: {region: 0x4d46, code: 0x61, from: 0xf5021, to: 0xfa451}, + 277: {region: 0x4d47, code: 0xa2, from: 0xf7f61, to: 0x0}, + 278: {region: 0x4d47, code: 0xa3, from: 0xf56e1, to: 0xfa99f}, + 279: {region: 0x4d48, code: 0xfa, from: 0xf3021, to: 0x0}, + 280: {region: 0x4d4b, code: 0xa4, from: 0xf92b4, to: 0x0}, + 281: {region: 0x4d4b, code: 0xa5, from: 0xf909a, to: 0xf92b4}, + 282: {region: 0x4d4c, code: 0x113, from: 0xf80c1, to: 0x0}, + 283: {region: 0x4d4c, code: 0xa6, from: 0xf54e2, to: 0xf811f}, + 284: {region: 0x4d4c, code: 0x113, from: 0xf4d78, to: 0xf54e2}, + 285: {region: 0x4d4d, code: 0xa7, from: 0xf8ad2, to: 0x0}, + 286: {region: 0x4d4d, code: 0x34, from: 0xf40e1, to: 0xf8ad2}, + 287: {region: 0x4d4e, code: 0xa8, from: 0xef661, to: 0x0}, + 288: {region: 0x4d4f, code: 0xa9, from: 0xeda21, to: 0x0}, + 289: {region: 0x4d50, code: 0xfa, from: 0xf3021, to: 0x0}, + 290: {region: 0x4d51, code: 0x5d, from: 0xf9e21, to: 0x0}, + 291: {region: 0x4d51, code: 0x61, from: 0xf5021, to: 0xfa451}, + 292: {region: 0x4d52, code: 0xaa, from: 0xf6add, to: 0x0}, + 293: {region: 0x4d52, code: 0x113, from: 0xf4d7c, to: 0xf6add}, + 294: {region: 0x4d53, code: 0x10e, from: 0xf5e5b, to: 0x0}, + 295: {region: 0x4d54, code: 0x5d, from: 0xfb021, to: 0x0}, + 296: {region: 0x4d54, code: 0xab, from: 0xf60c7, to: 0xfb03f}, + 297: {region: 0x4d54, code: 0xac, from: 0xef50d, to: 0xf60c7}, + 298: {region: 0x4d55, code: 0xad, from: 0xf1c81, to: 0x0}, + 299: {region: 0x4d56, code: 0xaf, from: 0xf7ae1, to: 0x0}, + 300: {region: 0x4d57, code: 0xb0, from: 0xf664f, to: 0x0}, + 301: {region: 0x4d58, code: 0xb1, from: 0xf9221, to: 0x0}, + 302: {region: 0x4d58, code: 0xb2, from: 0xe3c21, to: 0xf919f}, + 303: {region: 0x4d58, code: 0x80b3, from: 0x0, to: 0x0}, + 304: {region: 0x4d59, code: 0xb4, from: 0xf5730, to: 0x0}, + 305: {region: 0x4d5a, code: 0xb7, from: 0xface1, to: 0x0}, + 306: {region: 0x4d5a, code: 0xb6, from: 0xf78d0, to: 0xfad9f}, + 307: {region: 0x4d5a, code: 0xb5, from: 0xf6ed9, to: 0xf78d0}, + 308: {region: 0x4e41, code: 0xb8, from: 0xf9221, to: 0x0}, + 309: {region: 0x4e41, code: 0x123, from: 0xf524e, to: 0x0}, + 310: {region: 0x4e43, code: 0x115, from: 0xf8221, to: 0x0}, + 311: {region: 0x4e45, code: 0x113, from: 0xf4d93, to: 0x0}, + 312: {region: 0x4e46, code: 0x13, from: 0xf5c4e, to: 0x0}, + 313: {region: 0x4e47, code: 0xb9, from: 0xf6a21, to: 0x0}, + 314: {region: 0x4e49, code: 0xbb, from: 0xf8e9e, to: 0x0}, + 315: {region: 0x4e49, code: 0xba, from: 0xf884f, to: 0xf8e9e}, + 316: {region: 0x4e4c, code: 0x5d, from: 0xf9e21, to: 0x0}, + 317: {region: 0x4e4c, code: 0xbc, from: 0xe2a21, to: 0xfa45c}, + 318: {region: 0x4e4f, code: 0xbd, from: 0xee2c7, to: 0x0}, + 319: {region: 0x4e4f, code: 0xda, from: 0xea2bb, to: 0xee2c7}, + 320: {region: 0x4e50, code: 0xbe, from: 0xf1a21, to: 0x0}, + 321: {region: 0x4e50, code: 0x7c, from: 0xe9c21, to: 0xf5d51}, + 322: {region: 0x4e52, code: 0x13, from: 0xf5c4e, to: 0x0}, + 323: {region: 0x4e55, code: 0xbf, from: 0xf5eea, to: 0x0}, + 324: {region: 0x4e5a, code: 0xbf, from: 0xf5eea, to: 0x0}, + 325: {region: 0x4f4d, code: 0xc0, from: 0xf696b, to: 0x0}, + 326: {region: 0x5041, code: 0xc1, from: 0xedf64, to: 0x0}, + 327: {region: 0x5041, code: 0xfa, from: 0xedf72, to: 0x0}, + 328: {region: 0x5045, code: 0xc3, from: 0xf8ee1, to: 0x0}, + 329: {region: 0x5045, code: 0xc2, from: 0xf8241, to: 0xf8ee1}, + 330: {region: 0x5045, code: 0xc4, from: 0xe8e4e, to: 0xf8241}, + 331: {region: 0x5046, code: 0x115, from: 0xf339a, to: 0x0}, + 332: {region: 0x5047, code: 0xc5, from: 0xf6f30, to: 0x0}, + 333: {region: 0x5047, code: 0x13, from: 0xf5c4e, to: 0xf6f30}, + 334: {region: 0x5048, code: 0xc6, from: 0xf34e4, to: 0x0}, + 335: {region: 0x504b, code: 0xc7, from: 0xf3881, to: 0x0}, + 336: {region: 0x504b, code: 0x7c, from: 0xe5711, to: 0xf370f}, + 337: {region: 0x504c, code: 0xc8, from: 0xf9621, to: 0x0}, + 338: {region: 0x504c, code: 0xc9, from: 0xf3d5c, to: 0xf959f}, + 339: {region: 0x504d, code: 0x5d, from: 0xf9e21, to: 0x0}, + 340: {region: 0x504d, code: 0x61, from: 0xf6995, to: 0xfa451}, + 341: {region: 0x504e, code: 0xbf, from: 0xf622d, to: 0x0}, + 342: {region: 0x5052, code: 0xfa, from: 0xed58a, to: 0x0}, + 343: {region: 0x5052, code: 0x5b, from: 0xe1021, to: 0xed58a}, + 344: {region: 0x5053, code: 0x7b, from: 0xf8324, to: 0x0}, + 345: {region: 0x5053, code: 0x83, from: 0xf984c, to: 0x0}, + 346: {region: 0x5053, code: 0x79, from: 0xf5ec1, to: 0xf7856}, + 347: {region: 0x5053, code: 0x83, from: 0xf3ce1, to: 0xf5ec1}, + 348: {region: 0x5054, code: 0x5d, from: 0xf9e21, to: 0x0}, + 349: {region: 0x5054, code: 0xca, from: 0xeeeb6, to: 0xfa45c}, + 350: {region: 0x5057, code: 0xfa, from: 0xf3021, to: 0x0}, + 351: {region: 0x5059, code: 0xcb, from: 0xf2f61, to: 0x0}, + 352: {region: 0x5141, code: 0xcc, from: 0xf6ab3, to: 0x0}, + 353: {region: 0x5245, code: 0x5d, from: 0xf9e21, to: 0x0}, + 354: {region: 0x5245, code: 0x61, from: 0xf6e21, to: 0xfa451}, + 355: {region: 0x524f, code: 0xcf, from: 0xfaae1, to: 0x0}, + 356: {region: 0x524f, code: 0xce, from: 0xf403c, to: 0xfad9f}, + 357: {region: 0x5253, code: 0xd0, from: 0xfad59, to: 0x0}, + 358: {region: 0x5253, code: 0x47, from: 0xfa4af, to: 0xfad59}, + 359: {region: 0x5253, code: 0x11f, from: 0xf9438, to: 0xfa4af}, + 360: {region: 0x5255, code: 0xd1, from: 0xf9e21, to: 0x0}, + 361: {region: 0x5255, code: 0xd2, from: 0xf8f99, to: 0xf9d9f}, + 362: {region: 0x5257, code: 0xd3, from: 0xf58b3, to: 0x0}, + 363: {region: 0x5341, code: 0xd4, from: 0xf4156, to: 0x0}, + 364: {region: 0x5342, code: 0xd5, from: 0xf7358, to: 0x0}, + 365: {region: 0x5342, code: 0x13, from: 0xf5c4e, to: 0xf74de}, + 366: {region: 0x5343, code: 0xd6, from: 0xedf61, to: 0x0}, + 367: {region: 0x5344, code: 0xd8, from: 0xfae2a, to: 0x0}, + 368: {region: 0x5344, code: 0xd7, from: 0xf90c8, to: 0xfaede}, + 369: {region: 0x5344, code: 0xd9, from: 0xf4a88, to: 0xf9cc1}, + 370: {region: 0x5344, code: 0x57, from: 0xec233, to: 0xf4c21}, + 371: {region: 0x5344, code: 0x62, from: 0xec233, to: 0xf4c21}, + 372: {region: 0x5345, code: 0xda, from: 0xea2bb, to: 0x0}, + 373: {region: 0x5347, code: 0xdb, from: 0xf5ecc, to: 0x0}, + 374: {region: 0x5347, code: 0xb4, from: 0xf5730, to: 0xf5ecc}, + 375: {region: 0x5348, code: 0xdc, from: 0xefa4f, to: 0x0}, + 376: {region: 0x5349, code: 0x5d, from: 0xfae21, to: 0x0}, + 377: {region: 0x5349, code: 0xdd, from: 0xf9147, to: 0xfae2e}, + 378: {region: 0x534a, code: 0xbd, from: 0xee2c7, to: 0x0}, + 379: {region: 0x534b, code: 0x5d, from: 0xfb221, to: 0x0}, + 380: {region: 0x534b, code: 0xde, from: 0xf919f, to: 0xfb221}, + 381: {region: 0x534b, code: 0x48, from: 0xf42c1, to: 0xf919f}, + 382: {region: 0x534c, code: 0xdf, from: 0xf5904, to: 0x0}, + 383: {region: 0x534c, code: 0x62, from: 0xe217e, to: 0xf5c44}, + 384: {region: 0x534d, code: 0x5d, from: 0xf9e21, to: 0x0}, + 385: {region: 0x534d, code: 0x81, from: 0xe9397, to: 0xfa25c}, + 386: {region: 0x534e, code: 0x113, from: 0xf4e84, to: 0x0}, + 387: {region: 0x534f, code: 0xe0, from: 0xf50e1, to: 0x0}, + 388: {region: 0x5352, code: 0xe1, from: 0xfa821, to: 0x0}, + 389: {region: 0x5352, code: 0xe2, from: 0xf28aa, to: 0xfa79f}, + 390: {region: 0x5352, code: 0xbc, from: 0xe2f74, to: 0xf28aa}, + 391: {region: 0x5353, code: 0xe3, from: 0xfb6f2, to: 0x0}, + 392: {region: 0x5353, code: 0xd8, from: 0xfae2a, to: 0xfb721}, + 393: {region: 0x5354, code: 0xe4, from: 0xf7328, to: 0x0}, + 394: {region: 0x5355, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 395: {region: 0x5356, code: 0xfa, from: 0xfa221, to: 0x0}, + 396: {region: 0x5356, code: 0xe6, from: 0xeff6b, to: 0xfa221}, + 397: {region: 0x5358, code: 0x8, from: 0xfb54a, to: 0x0}, + 398: {region: 0x5359, code: 0xe7, from: 0xf3821, to: 0x0}, + 399: {region: 0x535a, code: 0xe8, from: 0xf6d26, to: 0x0}, + 400: {region: 0x5441, code: 0x62, from: 0xf242c, to: 0x0}, + 401: {region: 0x5443, code: 0xfa, from: 0xf6328, to: 0x0}, + 402: {region: 0x5444, code: 0x107, from: 0xf9221, to: 0x0}, + 403: {region: 0x5446, code: 0x5d, from: 0xf9e21, to: 0x0}, + 404: {region: 0x5446, code: 0x61, from: 0xf4e21, to: 0xfa451}, + 405: {region: 0x5447, code: 0x113, from: 0xf4d7c, to: 0x0}, + 406: {region: 0x5448, code: 0xe9, from: 0xf108f, to: 0x0}, + 407: {region: 0x544a, code: 0xeb, from: 0xfa15a, to: 0x0}, + 408: {region: 0x544a, code: 0xea, from: 0xf96aa, to: 0xfa159}, + 409: {region: 0x544a, code: 0xd2, from: 0xf8f99, to: 0xf96aa}, + 410: {region: 0x544b, code: 0xbf, from: 0xf5eea, to: 0x0}, + 411: {region: 0x544c, code: 0xfa, from: 0xf9f54, to: 0x0}, + 412: {region: 0x544c, code: 0xf0, from: 0xf4e22, to: 0xfa4b4}, + 413: {region: 0x544c, code: 0x77, from: 0xf6f87, to: 0xfa4b4}, + 414: {region: 0x544d, code: 0xed, from: 0xfb221, to: 0x0}, + 415: {region: 0x544d, code: 0xec, from: 0xf9361, to: 0xfb221}, + 416: {region: 0x544d, code: 0xd2, from: 0xf8f99, to: 0xf9361}, + 417: {region: 0x544d, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 418: {region: 0x544e, code: 0xee, from: 0xf4d61, to: 0x0}, + 419: {region: 0x544f, code: 0xef, from: 0xf5c4e, to: 0x0}, + 420: {region: 0x5450, code: 0xf0, from: 0xf4e22, to: 0xfa4b4}, + 421: {region: 0x5450, code: 0x77, from: 0xf6f87, to: 0xfa4b4}, + 422: {region: 0x5452, code: 0xf2, from: 0xfaa21, to: 0x0}, + 423: {region: 0x5452, code: 0xf1, from: 0xf0561, to: 0xfab9f}, + 424: {region: 0x5454, code: 0xf3, from: 0xf5821, to: 0x0}, + 425: {region: 0x5456, code: 0x13, from: 0xf5c4e, to: 0x0}, + 426: {region: 0x5457, code: 0xf4, from: 0xf3acf, to: 0x0}, + 427: {region: 0x545a, code: 0xf5, from: 0xf5cce, to: 0x0}, + 428: {region: 0x5541, code: 0xf6, from: 0xf9922, to: 0x0}, + 429: {region: 0x5541, code: 0xf7, from: 0xf916d, to: 0xf9351}, + 430: {region: 0x5541, code: 0xd2, from: 0xf8f99, to: 0xf916d}, + 431: {region: 0x5541, code: 0xe5, from: 0xf5221, to: 0xf8f99}, + 432: {region: 0x5547, code: 0xf9, from: 0xf86af, to: 0x0}, + 433: {region: 0x5547, code: 0xf8, from: 0xf5d0f, to: 0xf86af}, + 434: {region: 0x554d, code: 0xfa, from: 0xf3021, to: 0x0}, + 435: {region: 0x5553, code: 0xfa, from: 0xe0021, to: 0x0}, + 436: {region: 0x5553, code: 0x80fb, from: 0x0, to: 0x0}, + 437: {region: 0x5553, code: 0x80fc, from: 0x0, to: 0xfbc61}, + 438: {region: 0x5559, code: 0xff, from: 0xf9261, to: 0x0}, + 439: {region: 0x5559, code: 0xfe, from: 0xf6ee1, to: 0xf9261}, + 440: {region: 0x5559, code: 0x80fd, from: 0x0, to: 0x0}, + 441: {region: 0x555a, code: 0x100, from: 0xf94e1, to: 0x0}, + 442: {region: 0x5641, code: 0x5d, from: 0xf9e21, to: 0x0}, + 443: {region: 0x5641, code: 0x81, from: 0xe9d53, to: 0xfa45c}, + 444: {region: 0x5643, code: 0x10e, from: 0xf5b46, to: 0x0}, + 445: {region: 0x5645, code: 0x102, from: 0xfb021, to: 0x0}, + 446: {region: 0x5645, code: 0x101, from: 0xe9eab, to: 0xfb0de}, + 447: {region: 0x5647, code: 0xfa, from: 0xe5221, to: 0x0}, + 448: {region: 0x5647, code: 0x62, from: 0xe5221, to: 0xf4e21}, + 449: {region: 0x5649, code: 0xfa, from: 0xe5a21, to: 0x0}, + 450: {region: 0x564e, code: 0x103, from: 0xf832e, to: 0x0}, + 451: {region: 0x564e, code: 0x104, from: 0xf74a3, to: 0xf832e}, + 452: {region: 0x5655, code: 0x105, from: 0xf7a21, to: 0x0}, + 453: {region: 0x5746, code: 0x115, from: 0xf52fe, to: 0x0}, + 454: {region: 0x5753, code: 0x106, from: 0xf5eea, to: 0x0}, + 455: {region: 0x584b, code: 0x5d, from: 0xfa421, to: 0x0}, + 456: {region: 0x584b, code: 0x4f, from: 0xf9f21, to: 0xfa469}, + 457: {region: 0x584b, code: 0x11f, from: 0xf9438, to: 0xf9f3e}, + 458: {region: 0x5944, code: 0x11c, from: 0xf5a81, to: 0xf9821}, + 459: {region: 0x5945, code: 0x11d, from: 0xf8cb6, to: 0x0}, + 460: {region: 0x5954, code: 0x5d, from: 0xf9e21, to: 0x0}, + 461: {region: 0x5954, code: 0x61, from: 0xf7057, to: 0xfa451}, + 462: {region: 0x5954, code: 0x88, from: 0xf6e21, to: 0xf7057}, + 463: {region: 0x5955, code: 0x11f, from: 0xf9438, to: 0xfa4af}, + 464: {region: 0x5955, code: 0x120, from: 0xf8c21, to: 0xf90f8}, + 465: {region: 0x5955, code: 0x11e, from: 0xf5c21, to: 0xf8c21}, + 466: {region: 0x5a41, code: 0x123, from: 0xf524e, to: 0x0}, + 467: {region: 0x5a41, code: 0x8122, from: 0xf8321, to: 0xf966d}, + 468: {region: 0x5a4d, code: 0x125, from: 0xfba21, to: 0x0}, + 469: {region: 0x5a4d, code: 0x124, from: 0xf6030, to: 0xfba21}, + 470: {region: 0x5a52, code: 0x126, from: 0xf9361, to: 0xf9cff}, + 471: {region: 0x5a52, code: 0x127, from: 0xf675b, to: 0xf9361}, + 472: {region: 0x5a57, code: 0xfa, from: 0xfb28c, to: 0x0}, + 473: {region: 0x5a57, code: 0x129, from: 0xfb242, to: 0xfb28c}, + 474: {region: 0x5a57, code: 0x12a, from: 0xfb101, to: 0xfb242}, + 475: {region: 0x5a57, code: 0x128, from: 0xf7892, to: 0xfb101}, + 476: {region: 0x5a57, code: 0xcd, from: 0xf6451, to: 0xf7892}, + 477: {region: 0x5a5a, code: 0x8108, from: 0x0, to: 0x0}, + 478: {region: 0x5a5a, code: 0x8109, from: 0x0, to: 0x0}, + 479: {region: 0x5a5a, code: 0x810a, from: 0x0, to: 0x0}, + 480: {region: 0x5a5a, code: 0x810b, from: 0x0, to: 0x0}, + 481: {region: 0x5a5a, code: 0x810c, from: 0x0, to: 0x0}, + 482: {region: 0x5a5a, code: 0x810d, from: 0x0, to: 0x0}, + 483: {region: 0x5a5a, code: 0x810f, from: 0x0, to: 0x0}, + 484: {region: 0x5a5a, code: 0x8111, from: 0xf1421, to: 0xfa681}, + 485: {region: 0x5a5a, code: 0x8112, from: 0x0, to: 0xfbb7e}, + 486: {region: 0x5a5a, code: 0x8114, from: 0x0, to: 0x0}, + 487: {region: 0x5a5a, code: 0x8116, from: 0x0, to: 0x0}, + 488: {region: 0x5a5a, code: 0x8117, from: 0x0, to: 0xf9f7e}, + 489: {region: 0x5a5a, code: 0x8118, from: 0x0, to: 0x0}, + 490: {region: 0x5a5a, code: 0x8119, from: 0x0, to: 0x0}, + 491: {region: 0x5a5a, code: 0x811a, from: 0x0, to: 0x0}, + 492: {region: 0x5a5a, code: 0x811b, from: 0x0, to: 0x0}, +} // Size: 5940 bytes + +// symbols holds symbol data of the form , where n is the length of +// the symbol string str. +const symbols string = "" + // Size: 1396 bytes + "\x00\x02Kz\x01$\x02A$\x02KM\x03৳\x02Bs\x02R$\x01P\x03р.\x03CA$\x04CN¥" + + "\x02¥\x03₡\x03Kč\x02kr\x03E£\x03₧\x03€\x02£\x03₾\x02FG\x01Q\x03HK$\x01L" + + "\x02kn\x02Ft\x02Rp\x03₪\x03₹\x04JP¥\x03៛\x02CF\x03₩\x03₸\x03₭\x03L£\x02R" + + "s\x02Lt\x02Ls\x02Ar\x01K\x03₮\x03MX$\x02RM\x03₦\x02C$\x03NZ$\x03₱\x03zł" + + "\x03₲\x03lei\x03₽\x02RF\x02Db\x03฿\x02T$\x03₺\x03NT$\x03₴\x03US$\x03₫" + + "\x04FCFA\x03EC$\x03CFA\x04CFPF\x01R\x02ZK\x05GH₵\x03AU$\x06ብር\x03***\x09" + + "د.إ.\u200f\x03AR$\x03BB$\x09د.ب.\u200f\x03BM$\x03BN$\x03BS$\x03BZ$\x03C" + + "L$\x03CO$\x03CU$\x03DO$\x09د.ج.\u200f\x09ج.م.\u200f\x03FJ$\x04UK£\x03GY$" + + "\x09د.ع.\u200f\x06ر.إ.\x03JM$\x09د.أ.\u200f\x0cف.ج.ق.\u200f\x09د.ك." + + "\u200f\x03KY$\x09ل.ل.\u200f\x09د.ل.\u200f\x09د.م.\u200f\x09أ.م.\u200f" + + "\x09ر.ع.\u200f\x09ر.ق.\u200f\x09ر.س.\u200f\x03SB$\x09د.س.\u200f\x06ج.س." + + "\x03SR$\x09ل.س.\u200f\x09د.ت.\u200f\x03TT$\x03UY$\x09ر.ي.\u200f\x03Fdj" + + "\x03Nfk\x01S\x04GB£\x03TSh\x03₼\x03ley\x03S£\x04Bds$\x03BD$\x02B$\x02Br" + + "\x04CUC$\x03$MN\x03RD$\x04FK£\x02G$\x04Íkr\x02J$\x03CI$\x02L$\x02N$\x07р" + + "уб.\x03SI$\x02S$\x02$U\x05лв.\x06щ.д.\x02$A\x03$CA\x04£ E\x05£ RU\x04$ " + + "HK\x03£L\x04$ ZN\x03$ T\x04$ SU\x04din.\x04КМ\x04Кч\x04зл\x07дин.\x04Тл" + + "\x01F\x03USh\x04Kčs\x03ECU\x02TK\x03kr.\x03Ksh\x03öS\x03BGK\x03BGJ\x04Cu" + + "b$\x02DM\x04Fl£\x04F.G.\x02FC\x04F.Rw\x03Nu.\x05KR₩\x05TH฿\x06Δρχ\x02Tk" + + "\x02$b\x02Kr\x02Gs\x03CFP\x03FBu\x01D\x04MOP$\x02MK\x02SR\x02Le\x04NAf." + + "\x01E\x02VT\x03WS$\x03BsF\x02Af\x03Naf\x02$a\x04Afl.\x02TL\x03B/.\x02S/" + + "\x03Gs.\x03Bs.\x02؋\x04¥CN\x03$HK\x08ریال\x03$MX\x03$NZ\x03$EC\x02UM\x02" + + "mk\x03$AR\x03$AU\x02FB\x03$BM\x03$BN\x03$BS\x03$BZ\x03$CL\x03$CO\x04£CY" + + "\x03£E\x03$FJ\x04£FK\x04£GB\x04£GI\x04£IE\x04£IL\x05₤IT\x04£LB\x04£MT" + + "\x03$NA\x02$C\x03$RH\x02FR\x03$SB\x03$SG\x03$SR\x03$TT\x03$US\x03$UY\x04" + + "FCFP\x02Kw\x05$\u00a0AU\x05$\u00a0HK\x05$\u00a0NZ\x05$\u00a0SG\x05$" + + "\u00a0US\x02DA\x01G\x02LS\x02DT\x02$R\x06руб\x07રૂ.\x0a\u200eCN¥\u200e" + + "\x06ל״י\x02֏\x03NKr\x03元\x03￥\x03\u200b\x02LE\x02Kn\x06сом\x02zl\x02rb" + + "\x03MTn\x06ден\x04кр\x03NAf\x03Afl\x0cनेरू\x06रू\x02ر\x04Esc.\x06\u200bP" + + "TE\x04XXXX\x03ლ\x06ТМТ\x03Dkr\x03Skr\x03Nkr\x07රු.\x0fසිෆ්එ\x03NIS\x05Le" + + "kë\x03den\x02r.\x03BR$\x03Ekr\x04EG£\x04IE£\x03Ikr\x03Rs.\x04AUD$\x04NZD" + + "$\x07крб.\x05soʻm\x06сўм\x03￦\x03ILS\x02P.\x03Zł" + +type curToIndex struct { + cur uint16 + idx uint16 +} + +var normalLangIndex = []uint16{ // 753 elements + // Entry 0 - 3F + 0x0000, 0x0014, 0x0014, 0x0014, 0x0017, 0x0018, 0x0018, 0x0018, + 0x0018, 0x0019, 0x0019, 0x001c, 0x001c, 0x0034, 0x0034, 0x0034, + 0x0034, 0x0035, 0x0035, 0x0035, 0x0035, 0x0036, 0x0036, 0x0036, + 0x0036, 0x0036, 0x0036, 0x0037, 0x0037, 0x0037, 0x0037, 0x0037, + 0x0037, 0x0037, 0x0037, 0x0037, 0x0038, 0x003a, 0x003a, 0x003a, + 0x003a, 0x003a, 0x003a, 0x003a, 0x003a, 0x003b, 0x003b, 0x003e, + 0x003e, 0x0040, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, 0x0041, + 0x0048, 0x0048, 0x0049, 0x0049, 0x004a, 0x004a, 0x005b, 0x005b, + // Entry 40 - 7F + 0x005b, 0x005b, 0x005b, 0x005d, 0x005d, 0x005d, 0x005e, 0x005e, + 0x005f, 0x006d, 0x006d, 0x006d, 0x006d, 0x007e, 0x0084, 0x0084, + 0x0084, 0x0084, 0x008d, 0x008d, 0x008d, 0x008e, 0x008e, 0x008f, + 0x008f, 0x0090, 0x0090, 0x0091, 0x0091, 0x0091, 0x0091, 0x0091, + 0x0098, 0x0098, 0x0099, 0x0099, 0x009b, 0x009b, 0x009f, 0x009f, + 0x009f, 0x00a0, 0x00a0, 0x00a8, 0x00a8, 0x00a8, 0x00a8, 0x00a8, + 0x00a8, 0x00a9, 0x00aa, 0x00aa, 0x00aa, 0x00af, 0x00af, 0x00af, + 0x00af, 0x00af, 0x00af, 0x00af, 0x00b5, 0x00b5, 0x00b6, 0x00b6, + // Entry 80 - BF + 0x00b9, 0x00b9, 0x00b9, 0x00bc, 0x00bc, 0x00bc, 0x00be, 0x00c0, + 0x00c0, 0x00c1, 0x00c2, 0x00c2, 0x00c2, 0x00d7, 0x00d8, 0x00d8, + 0x00d9, 0x00da, 0x00db, 0x00dc, 0x00dd, 0x00de, 0x00df, 0x00df, + 0x00e0, 0x00e0, 0x00e1, 0x00e1, 0x00e1, 0x00e1, 0x00e2, 0x00e3, + 0x00e4, 0x00e4, 0x00e5, 0x00e7, 0x00e7, 0x00e7, 0x00e8, 0x00e8, + 0x00e9, 0x00eb, 0x00ec, 0x00ec, 0x00ed, 0x00ed, 0x00ed, 0x00ed, + 0x00ed, 0x00ed, 0x00ed, 0x00ed, 0x00ee, 0x00ef, 0x00f0, 0x00f1, + 0x00f2, 0x00f3, 0x00f4, 0x00f5, 0x00f6, 0x00f6, 0x00f7, 0x00f7, + // Entry C0 - FF + 0x00f8, 0x00f9, 0x00fa, 0x00fb, 0x00fc, 0x00fd, 0x00fe, 0x00ff, + 0x00ff, 0x0100, 0x0101, 0x0102, 0x0103, 0x0104, 0x0105, 0x0106, + 0x0106, 0x0106, 0x0107, 0x0108, 0x0109, 0x0109, 0x010a, 0x010b, + 0x010d, 0x010d, 0x010e, 0x0110, 0x0111, 0x0112, 0x0112, 0x0113, + 0x0114, 0x0115, 0x0116, 0x0117, 0x0118, 0x0118, 0x0118, 0x0119, + 0x0119, 0x0119, 0x011a, 0x011b, 0x011c, 0x011d, 0x011d, 0x011d, + 0x011d, 0x012f, 0x0134, 0x0136, 0x0137, 0x0138, 0x013a, 0x013c, + 0x013d, 0x013f, 0x0141, 0x0141, 0x0142, 0x0142, 0x0143, 0x0144, + // Entry 100 - 13F + 0x0145, 0x0145, 0x014e, 0x014f, 0x0150, 0x0151, 0x0152, 0x0153, + 0x0154, 0x0155, 0x0157, 0x0159, 0x015a, 0x015f, 0x015f, 0x0161, + 0x0161, 0x0161, 0x0161, 0x016c, 0x016c, 0x016c, 0x016c, 0x016c, + 0x016d, 0x016e, 0x016e, 0x017f, 0x017f, 0x0183, 0x0183, 0x0184, + 0x0185, 0x0185, 0x01ab, 0x01ab, 0x01ab, 0x01ac, 0x01ac, 0x01ac, + 0x01cd, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01cf, + 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d1, 0x01d1, 0x01d1, 0x01d2, + 0x01d3, 0x01d5, 0x01d5, 0x01d5, 0x01d5, 0x01d6, 0x01d6, 0x01d6, + // Entry 140 - 17F + 0x01d7, 0x01d8, 0x01d8, 0x01d8, 0x01d8, 0x01d8, 0x01d8, 0x01d9, + 0x01da, 0x01da, 0x01db, 0x01db, 0x01db, 0x01dc, 0x01dd, 0x01dd, + 0x01dd, 0x01dd, 0x01dd, 0x01e3, 0x01e3, 0x01e6, 0x01e6, 0x01e8, + 0x01e8, 0x01ef, 0x01ef, 0x01f2, 0x01f2, 0x01f2, 0x01f2, 0x01f3, + 0x01f3, 0x01f3, 0x01f4, 0x01f4, 0x01f4, 0x01f4, 0x01f5, 0x01f6, + 0x01f6, 0x01f6, 0x01f7, 0x01f7, 0x01fc, 0x01fc, 0x01fe, 0x01fe, + 0x0210, 0x0211, 0x0211, 0x0216, 0x0216, 0x0228, 0x0228, 0x022b, + 0x022b, 0x022f, 0x022f, 0x0230, 0x0230, 0x0231, 0x0231, 0x023d, + // Entry 180 - 1BF + 0x023d, 0x0244, 0x0244, 0x0244, 0x0244, 0x0244, 0x0247, 0x0247, + 0x0247, 0x0247, 0x0247, 0x0248, 0x0248, 0x0248, 0x0252, 0x0252, + 0x0253, 0x0253, 0x0253, 0x0254, 0x0254, 0x0254, 0x0255, 0x0255, + 0x0258, 0x0258, 0x0258, 0x0258, 0x0259, 0x0259, 0x025d, 0x025d, + 0x025d, 0x025d, 0x025e, 0x025e, 0x025f, 0x025f, 0x0262, 0x0262, + 0x0264, 0x0264, 0x0265, 0x0265, 0x0265, 0x0265, 0x0265, 0x0265, + 0x0265, 0x0266, 0x0266, 0x0266, 0x0266, 0x0266, 0x0266, 0x0266, + 0x0266, 0x0266, 0x0275, 0x0275, 0x0276, 0x0276, 0x027b, 0x027b, + // Entry 1C0 - 1FF + 0x027c, 0x027c, 0x027d, 0x027d, 0x027e, 0x027f, 0x027f, 0x027f, + 0x027f, 0x0281, 0x0281, 0x0281, 0x0281, 0x0281, 0x0294, 0x0294, + 0x0295, 0x0295, 0x0296, 0x0296, 0x0297, 0x0297, 0x029c, 0x029c, + 0x029d, 0x029d, 0x029e, 0x029f, 0x029f, 0x02a0, 0x02a0, 0x02a1, + 0x02a1, 0x02a2, 0x02a2, 0x02a2, 0x02a2, 0x02ae, 0x02ae, 0x02b1, + 0x02b1, 0x02b4, 0x02b4, 0x02b6, 0x02b6, 0x02ba, 0x02bb, 0x02bb, + 0x02bc, 0x02bc, 0x02bc, 0x02bc, 0x02bc, 0x02c3, 0x02c3, 0x02c4, + 0x02c4, 0x02c4, 0x02c5, 0x02c5, 0x02d7, 0x02d7, 0x02d7, 0x02d7, + // Entry 200 - 23F + 0x02d7, 0x02d7, 0x02d7, 0x02d7, 0x02d9, 0x02d9, 0x02d9, 0x02df, + 0x02e0, 0x02e0, 0x02e1, 0x02e2, 0x02e2, 0x02e3, 0x02e4, 0x02e4, + 0x02e4, 0x02e5, 0x02e5, 0x02e5, 0x02e5, 0x02e5, 0x02e5, 0x02e5, + 0x02e5, 0x02e7, 0x02e7, 0x02e7, 0x02e8, 0x02e8, 0x02e9, 0x02e9, + 0x02ea, 0x02ea, 0x02ea, 0x02ec, 0x02ec, 0x02ee, 0x02ef, 0x02f0, + 0x02f0, 0x02f0, 0x02f0, 0x02f0, 0x02ff, 0x02ff, 0x02ff, 0x02ff, + 0x0300, 0x0300, 0x0303, 0x0304, 0x0304, 0x0304, 0x0306, 0x0306, + 0x0306, 0x0307, 0x0308, 0x0309, 0x030a, 0x030b, 0x030b, 0x030c, + // Entry 240 - 27F + 0x030e, 0x0310, 0x0310, 0x0310, 0x0310, 0x0311, 0x0311, 0x0322, + 0x0323, 0x0323, 0x0324, 0x0324, 0x032c, 0x032e, 0x032f, 0x0330, + 0x0331, 0x0331, 0x0331, 0x0332, 0x0332, 0x0333, 0x0333, 0x0334, + 0x0334, 0x0335, 0x0335, 0x0336, 0x0336, 0x0336, 0x033a, 0x033a, + 0x033a, 0x033c, 0x033d, 0x033d, 0x033d, 0x033d, 0x033d, 0x033d, + 0x033d, 0x033d, 0x033d, 0x033d, 0x033d, 0x0340, 0x0340, 0x034e, + 0x034e, 0x0352, 0x0352, 0x0352, 0x0352, 0x0352, 0x0352, 0x0352, + 0x0352, 0x0352, 0x0352, 0x0353, 0x0354, 0x0355, 0x0356, 0x0356, + // Entry 280 - 2BF + 0x0358, 0x0358, 0x0359, 0x0359, 0x035f, 0x035f, 0x035f, 0x035f, + 0x035f, 0x035f, 0x0365, 0x0365, 0x0365, 0x0365, 0x0365, 0x0365, + 0x0365, 0x0365, 0x037d, 0x037d, 0x037d, 0x037d, 0x0380, 0x0381, + 0x0381, 0x0381, 0x0382, 0x0382, 0x0385, 0x0385, 0x0386, 0x0388, + 0x038b, 0x038d, 0x038d, 0x038e, 0x038f, 0x038f, 0x0391, 0x0391, + 0x0392, 0x0393, 0x0393, 0x0393, 0x0395, 0x0395, 0x0395, 0x0398, + 0x0398, 0x039d, 0x039d, 0x039d, 0x039d, 0x039d, 0x039d, 0x039d, + 0x039d, 0x039f, 0x039f, 0x03b2, 0x03b2, 0x03b5, 0x03b6, 0x03b6, + // Entry 2C0 - 2FF + 0x03b7, 0x03b8, 0x03b8, 0x03ba, 0x03ba, 0x03ba, 0x03ba, 0x03bb, + 0x03bc, 0x03bc, 0x03bc, 0x03bc, 0x03bc, 0x03be, 0x03be, 0x03be, + 0x03be, 0x03bf, 0x03bf, 0x03bf, 0x03c1, 0x03c1, 0x03c1, 0x03c1, + 0x03c2, 0x03c2, 0x03c2, 0x03c2, 0x03c2, 0x03c2, 0x03c3, 0x03c3, + 0x03c3, 0x03c6, 0x03c6, 0x03c6, 0x03c6, 0x03ca, 0x03ca, 0x03ca, + 0x03cb, 0x03cd, 0x03cf, 0x03d3, 0x03d5, 0x03d6, 0x03d6, 0x03d8, + 0x03d8, +} // Size: 1530 bytes + +var normalSymIndex = []curToIndex{ // 984 elements + 0: {cur: 0x13, idx: 0x6}, + 1: {cur: 0x2e, idx: 0x13}, + 2: {cur: 0x3a, idx: 0x1c}, + 3: {cur: 0x43, idx: 0x20}, + 4: {cur: 0x5d, idx: 0x3b}, + 5: {cur: 0x62, idx: 0x3f}, + 6: {cur: 0x71, idx: 0x4b}, + 7: {cur: 0x7b, idx: 0x5a}, + 8: {cur: 0x7c, idx: 0x5e}, + 9: {cur: 0x84, idx: 0x62}, + 10: {cur: 0x8c, idx: 0x6e}, + 11: {cur: 0xb1, idx: 0x90}, + 12: {cur: 0xbf, idx: 0x9e}, + 13: {cur: 0xf4, idx: 0xc7}, + 14: {cur: 0xfa, idx: 0xcf}, + 15: {cur: 0x103, idx: 0xd3}, + 16: {cur: 0x107, idx: 0xd7}, + 17: {cur: 0x10e, idx: 0xdc}, + 18: {cur: 0x113, idx: 0xe0}, + 19: {cur: 0x115, idx: 0xe4}, + 20: {cur: 0xb1, idx: 0x0}, + 21: {cur: 0xe9, idx: 0xbc}, + 22: {cur: 0x123, idx: 0xe9}, + 23: {cur: 0xb8, idx: 0x4}, + 24: {cur: 0x66, idx: 0xee}, + 25: {cur: 0x13, idx: 0xf4}, + 26: {cur: 0x5c, idx: 0xf8}, + 27: {cur: 0xe9, idx: 0xbc}, + 28: {cur: 0x0, idx: 0xff}, + 29: {cur: 0x2, idx: 0x103}, + 30: {cur: 0x13, idx: 0xf4}, + 31: {cur: 0x23, idx: 0x115}, + 32: {cur: 0x53, idx: 0x13f}, + 33: {cur: 0x57, idx: 0x149}, + 34: {cur: 0x7d, idx: 0x160}, + 35: {cur: 0x7e, idx: 0x16a}, + 36: {cur: 0x83, idx: 0x175}, + 37: {cur: 0x88, idx: 0x17f}, + 38: {cur: 0x8d, idx: 0x18c}, + 39: {cur: 0x91, idx: 0x19a}, + 40: {cur: 0x9c, idx: 0x1a4}, + 41: {cur: 0x9d, idx: 0x1ae}, + 42: {cur: 0xaa, idx: 0x1b8}, + 43: {cur: 0xc0, idx: 0x1c2}, + 44: {cur: 0xcc, idx: 0x1cc}, + 45: {cur: 0xd4, idx: 0x1d6}, + 46: {cur: 0xd7, idx: 0x1e4}, + 47: {cur: 0xd8, idx: 0x1ee}, + 48: {cur: 0xe7, idx: 0x1f9}, + 49: {cur: 0xe9, idx: 0xbc}, + 50: {cur: 0xee, idx: 0x203}, + 51: {cur: 0x11d, idx: 0x215}, + 52: {cur: 0x50, idx: 0x21f}, + 53: {cur: 0x58, idx: 0x223}, + 54: {cur: 0xd8, idx: 0x0}, + 55: {cur: 0xe0, idx: 0x227}, + 56: {cur: 0x62, idx: 0x229}, + 57: {cur: 0xe3, idx: 0x3f}, + 58: {cur: 0xf5, idx: 0x22e}, + 59: {cur: 0x84, idx: 0x25}, + 60: {cur: 0xe9, idx: 0xbc}, + 61: {cur: 0xfa, idx: 0x4}, + 62: {cur: 0x16, idx: 0x232}, + 63: {cur: 0xe9, idx: 0xbc}, + 64: {cur: 0x16, idx: 0x232}, + 65: {cur: 0x2e, idx: 0x0}, + 66: {cur: 0x37, idx: 0x24a}, + 67: {cur: 0x3a, idx: 0x0}, + 68: {cur: 0x84, idx: 0x25}, + 69: {cur: 0xbf, idx: 0x0}, + 70: {cur: 0xd1, idx: 0xb2}, + 71: {cur: 0xfa, idx: 0x4}, + 72: {cur: 0x125, idx: 0x8a}, + 73: {cur: 0xf5, idx: 0x22e}, + 74: {cur: 0x13, idx: 0x0}, + 75: {cur: 0x21, idx: 0x286}, + 76: {cur: 0x2e, idx: 0x0}, + 77: {cur: 0x3a, idx: 0x0}, + 78: {cur: 0x43, idx: 0x0}, + 79: {cur: 0x62, idx: 0x0}, + 80: {cur: 0x71, idx: 0x0}, + 81: {cur: 0x7b, idx: 0x0}, + 82: {cur: 0x7c, idx: 0x0}, + 83: {cur: 0x84, idx: 0x0}, + 84: {cur: 0x8c, idx: 0x0}, + 85: {cur: 0xb1, idx: 0x0}, + 86: {cur: 0xbf, idx: 0x0}, + 87: {cur: 0xf4, idx: 0x0}, + 88: {cur: 0xfa, idx: 0x28c}, + 89: {cur: 0x103, idx: 0x0}, + 90: {cur: 0x10e, idx: 0x0}, + 91: {cur: 0x1b, idx: 0xc}, + 92: {cur: 0xe9, idx: 0xbc}, + 93: {cur: 0x43, idx: 0x25}, + 94: {cur: 0x43, idx: 0x20}, + 95: {cur: 0x13, idx: 0x293}, + 96: {cur: 0x2e, idx: 0x0}, + 97: {cur: 0x3a, idx: 0x296}, + 98: {cur: 0x43, idx: 0x0}, + 99: {cur: 0x62, idx: 0x29f}, + 100: {cur: 0x71, idx: 0x2a5}, + 101: {cur: 0x7b, idx: 0x0}, + 102: {cur: 0x84, idx: 0x0}, + 103: {cur: 0x8c, idx: 0x0}, + 104: {cur: 0xbf, idx: 0x2ae}, + 105: {cur: 0xf4, idx: 0x0}, + 106: {cur: 0xfa, idx: 0x2b7}, + 107: {cur: 0x103, idx: 0x0}, + 108: {cur: 0x10e, idx: 0x0}, + 109: {cur: 0x13, idx: 0x0}, + 110: {cur: 0x18, idx: 0x9}, + 111: {cur: 0x2e, idx: 0x0}, + 112: {cur: 0x3a, idx: 0x0}, + 113: {cur: 0x43, idx: 0x0}, + 114: {cur: 0x62, idx: 0x0}, + 115: {cur: 0x71, idx: 0x0}, + 116: {cur: 0x74, idx: 0x51}, + 117: {cur: 0x7b, idx: 0x0}, + 118: {cur: 0x84, idx: 0x25}, + 119: {cur: 0xb1, idx: 0x0}, + 120: {cur: 0xbf, idx: 0x0}, + 121: {cur: 0xd0, idx: 0x2bc}, + 122: {cur: 0xe9, idx: 0xbc}, + 123: {cur: 0xfa, idx: 0x0}, + 124: {cur: 0x10e, idx: 0x0}, + 125: {cur: 0x115, idx: 0x0}, + 126: {cur: 0x18, idx: 0x2c1}, + 127: {cur: 0x4d, idx: 0x2c6}, + 128: {cur: 0x84, idx: 0x25}, + 129: {cur: 0xc8, idx: 0x2cb}, + 130: {cur: 0xd0, idx: 0x2d0}, + 131: {cur: 0xf2, idx: 0x2d8}, + 132: {cur: 0x13, idx: 0xf4}, + 133: {cur: 0x2e, idx: 0x0}, + 134: {cur: 0x3a, idx: 0x0}, + 135: {cur: 0x43, idx: 0x25}, + 136: {cur: 0x5b, idx: 0x37}, + 137: {cur: 0xb1, idx: 0x0}, + 138: {cur: 0xe9, idx: 0xbc}, + 139: {cur: 0xfa, idx: 0x0}, + 140: {cur: 0x10e, idx: 0x0}, + 141: {cur: 0x61, idx: 0x2dd}, + 142: {cur: 0xd1, idx: 0xb2}, + 143: {cur: 0xf9, idx: 0x2df}, + 144: {cur: 0xfa, idx: 0x4}, + 145: {cur: 0x13, idx: 0xf4}, + 146: {cur: 0x48, idx: 0x2e3}, + 147: {cur: 0x4d, idx: 0x2c}, + 148: {cur: 0x7b, idx: 0x0}, + 149: {cur: 0x7c, idx: 0x0}, + 150: {cur: 0x103, idx: 0x0}, + 151: {cur: 0x110, idx: 0x2e8}, + 152: {cur: 0xd1, idx: 0xb2}, + 153: {cur: 0x8c, idx: 0x0}, + 154: {cur: 0xe9, idx: 0xbc}, + 155: {cur: 0x13, idx: 0xf4}, + 156: {cur: 0x51, idx: 0x2ef}, + 157: {cur: 0xe9, idx: 0xbc}, + 158: {cur: 0xfa, idx: 0x4}, + 159: {cur: 0x85, idx: 0x2f3}, + 160: {cur: 0x12, idx: 0x2f7}, + 161: {cur: 0x13, idx: 0xf4}, + 162: {cur: 0x20, idx: 0x2fb}, + 163: {cur: 0x22, idx: 0x2ff}, + 164: {cur: 0x4f, idx: 0x308}, + 165: {cur: 0x84, idx: 0x25}, + 166: {cur: 0xe9, idx: 0xbc}, + 167: {cur: 0xfa, idx: 0x4}, + 168: {cur: 0x5d, idx: 0x0}, + 169: {cur: 0x98, idx: 0x2dd}, + 170: {cur: 0x13, idx: 0x0}, + 171: {cur: 0x84, idx: 0x25}, + 172: {cur: 0xc8, idx: 0xa6}, + 173: {cur: 0xe9, idx: 0xbc}, + 174: {cur: 0xfa, idx: 0x4}, + 175: {cur: 0x13, idx: 0xf4}, + 176: {cur: 0x33, idx: 0x31d}, + 177: {cur: 0x7b, idx: 0x0}, + 178: {cur: 0x8c, idx: 0x321}, + 179: {cur: 0xe9, idx: 0x327}, + 180: {cur: 0x107, idx: 0x0}, + 181: {cur: 0x85, idx: 0x2f3}, + 182: {cur: 0x13, idx: 0xf4}, + 183: {cur: 0x66, idx: 0xee}, + 184: {cur: 0xe9, idx: 0xbc}, + 185: {cur: 0x6c, idx: 0x32d}, + 186: {cur: 0xe9, idx: 0xbc}, + 187: {cur: 0xfa, idx: 0x4}, + 188: {cur: 0x84, idx: 0x25}, + 189: {cur: 0xfa, idx: 0x4}, + 190: {cur: 0x84, idx: 0x62}, + 191: {cur: 0xfa, idx: 0xcf}, + 192: {cur: 0x10e, idx: 0x4}, + 193: {cur: 0x10e, idx: 0x4}, + 194: {cur: 0x13, idx: 0x4}, + 195: {cur: 0x2e, idx: 0x0}, + 196: {cur: 0x3a, idx: 0x0}, + 197: {cur: 0x43, idx: 0x0}, + 198: {cur: 0x5d, idx: 0x0}, + 199: {cur: 0x62, idx: 0x0}, + 200: {cur: 0x71, idx: 0x0}, + 201: {cur: 0x7b, idx: 0x0}, + 202: {cur: 0x7c, idx: 0x0}, + 203: {cur: 0x84, idx: 0x0}, + 204: {cur: 0x8c, idx: 0x0}, + 205: {cur: 0xb1, idx: 0x0}, + 206: {cur: 0xbf, idx: 0x0}, + 207: {cur: 0xd6, idx: 0x7e}, + 208: {cur: 0xf4, idx: 0x0}, + 209: {cur: 0xfa, idx: 0x0}, + 210: {cur: 0x103, idx: 0x0}, + 211: {cur: 0x107, idx: 0x0}, + 212: {cur: 0x10e, idx: 0x0}, + 213: {cur: 0x113, idx: 0x0}, + 214: {cur: 0x115, idx: 0x340}, + 215: {cur: 0x1a, idx: 0x4}, + 216: {cur: 0x24, idx: 0x344}, + 217: {cur: 0x25, idx: 0x4}, + 218: {cur: 0x32, idx: 0x4}, + 219: {cur: 0x35, idx: 0x16}, + 220: {cur: 0x39, idx: 0x4}, + 221: {cur: 0x3a, idx: 0x4}, + 222: {cur: 0x13, idx: 0x4}, + 223: {cur: 0xbf, idx: 0x4}, + 224: {cur: 0x13, idx: 0x4}, + 225: {cur: 0x51, idx: 0x2ef}, + 226: {cur: 0x10e, idx: 0x4}, + 227: {cur: 0x58, idx: 0x223}, + 228: {cur: 0x5f, idx: 0x4}, + 229: {cur: 0x60, idx: 0x3f}, + 230: {cur: 0x62, idx: 0x229}, + 231: {cur: 0x10e, idx: 0x4}, + 232: {cur: 0x66, idx: 0xee}, + 233: {cur: 0x62, idx: 0x229}, + 234: {cur: 0x67, idx: 0x3f}, + 235: {cur: 0x68, idx: 0x348}, + 236: {cur: 0x70, idx: 0x4}, + 237: {cur: 0x82, idx: 0x4}, + 238: {cur: 0x85, idx: 0x2f3}, + 239: {cur: 0x13, idx: 0x4}, + 240: {cur: 0x10e, idx: 0x4}, + 241: {cur: 0x8e, idx: 0x4}, + 242: {cur: 0x10e, idx: 0x4}, + 243: {cur: 0x93, idx: 0x4}, + 244: {cur: 0x123, idx: 0xe9}, + 245: {cur: 0xa2, idx: 0x87}, + 246: {cur: 0xa9, idx: 0x34a}, + 247: {cur: 0x10e, idx: 0x4}, + 248: {cur: 0x62, idx: 0x229}, + 249: {cur: 0xad, idx: 0x7e}, + 250: {cur: 0xb0, idx: 0x34f}, + 251: {cur: 0xb4, idx: 0x94}, + 252: {cur: 0xb8, idx: 0x4}, + 253: {cur: 0x13, idx: 0x4}, + 254: {cur: 0xb9, idx: 0x97}, + 255: {cur: 0x13, idx: 0x4}, + 256: {cur: 0xbf, idx: 0x4}, + 257: {cur: 0xbf, idx: 0x4}, + 258: {cur: 0xc5, idx: 0x8a}, + 259: {cur: 0xc6, idx: 0xa2}, + 260: {cur: 0xc7, idx: 0x7e}, + 261: {cur: 0xbf, idx: 0x4}, + 262: {cur: 0xd3, idx: 0xb6}, + 263: {cur: 0xd5, idx: 0x4}, + 264: {cur: 0xd6, idx: 0x352}, + 265: {cur: 0xda, idx: 0x30}, + 266: {cur: 0xdb, idx: 0x4}, + 267: {cur: 0x62, idx: 0x229}, + 268: {cur: 0xdc, idx: 0x3f}, + 269: {cur: 0xdf, idx: 0x355}, + 270: {cur: 0x62, idx: 0x229}, + 271: {cur: 0xe3, idx: 0x3f}, + 272: {cur: 0x8, idx: 0x358}, + 273: {cur: 0xe8, idx: 0x35d}, + 274: {cur: 0xbf, idx: 0x4}, + 275: {cur: 0xef, idx: 0xc0}, + 276: {cur: 0xf3, idx: 0x4}, + 277: {cur: 0x13, idx: 0x4}, + 278: {cur: 0xf5, idx: 0x22e}, + 279: {cur: 0xf9, idx: 0x2df}, + 280: {cur: 0x10e, idx: 0x4}, + 281: {cur: 0x105, idx: 0x35f}, + 282: {cur: 0x106, idx: 0x362}, + 283: {cur: 0x123, idx: 0xe9}, + 284: {cur: 0x125, idx: 0x8a}, + 285: {cur: 0x13, idx: 0x0}, + 286: {cur: 0x2e, idx: 0x0}, + 287: {cur: 0x43, idx: 0x0}, + 288: {cur: 0x5b, idx: 0x37}, + 289: {cur: 0x62, idx: 0x0}, + 290: {cur: 0x71, idx: 0x0}, + 291: {cur: 0x7b, idx: 0x0}, + 292: {cur: 0x7c, idx: 0x0}, + 293: {cur: 0x84, idx: 0x0}, + 294: {cur: 0x8c, idx: 0x0}, + 295: {cur: 0xb1, idx: 0x0}, + 296: {cur: 0xbf, idx: 0x0}, + 297: {cur: 0xe9, idx: 0xbc}, + 298: {cur: 0xf4, idx: 0x0}, + 299: {cur: 0xfa, idx: 0x4}, + 300: {cur: 0x107, idx: 0x0}, + 301: {cur: 0x10e, idx: 0x0}, + 302: {cur: 0x113, idx: 0x0}, + 303: {cur: 0x3a, idx: 0x0}, + 304: {cur: 0x5d, idx: 0x0}, + 305: {cur: 0xe9, idx: 0x0}, + 306: {cur: 0xfa, idx: 0x0}, + 307: {cur: 0x103, idx: 0x0}, + 308: {cur: 0x11, idx: 0x4}, + 309: {cur: 0xfa, idx: 0xcf}, + 310: {cur: 0x27, idx: 0x10}, + 311: {cur: 0x2e, idx: 0x13}, + 312: {cur: 0x41, idx: 0x4}, + 313: {cur: 0xfa, idx: 0xcf}, + 314: {cur: 0x44, idx: 0x4}, + 315: {cur: 0xfa, idx: 0xcf}, + 316: {cur: 0x46, idx: 0x28}, + 317: {cur: 0x4a, idx: 0x4}, + 318: {cur: 0xfa, idx: 0xcf}, + 319: {cur: 0x52, idx: 0x256}, + 320: {cur: 0xfa, idx: 0xcf}, + 321: {cur: 0xfa, idx: 0x4}, + 322: {cur: 0x107, idx: 0xd7}, + 323: {cur: 0x6d, idx: 0x49}, + 324: {cur: 0x72, idx: 0x4f}, + 325: {cur: 0x4, idx: 0x36a}, + 326: {cur: 0x8, idx: 0x36d}, + 327: {cur: 0x9, idx: 0x1}, + 328: {cur: 0x11, idx: 0x371}, + 329: {cur: 0x13, idx: 0xf4}, + 330: {cur: 0x14, idx: 0x374}, + 331: {cur: 0x43, idx: 0x20}, + 332: {cur: 0xb1, idx: 0x4}, + 333: {cur: 0x115, idx: 0x0}, + 334: {cur: 0xbb, idx: 0x9b}, + 335: {cur: 0xc1, idx: 0x37c}, + 336: {cur: 0xc3, idx: 0x380}, + 337: {cur: 0xc6, idx: 0xa2}, + 338: {cur: 0xfa, idx: 0x4}, + 339: {cur: 0xcb, idx: 0x383}, + 340: {cur: 0xfa, idx: 0x4}, + 341: {cur: 0x84, idx: 0x25}, + 342: {cur: 0xfa, idx: 0x4}, + 343: {cur: 0xfa, idx: 0xcf}, + 344: {cur: 0xff, idx: 0x4}, + 345: {cur: 0x102, idx: 0x387}, + 346: {cur: 0x13, idx: 0xf4}, + 347: {cur: 0x56, idx: 0x30}, + 348: {cur: 0x84, idx: 0x25}, + 349: {cur: 0xe9, idx: 0xbc}, + 350: {cur: 0xfa, idx: 0x4}, + 351: {cur: 0x5b, idx: 0x37}, + 352: {cur: 0xe9, idx: 0xbc}, + 353: {cur: 0x4, idx: 0x38b}, + 354: {cur: 0x3a, idx: 0x296}, + 355: {cur: 0x43, idx: 0x38e}, + 356: {cur: 0x71, idx: 0x393}, + 357: {cur: 0x7e, idx: 0x397}, + 358: {cur: 0x84, idx: 0x25}, + 359: {cur: 0xb1, idx: 0x3a0}, + 360: {cur: 0xbf, idx: 0x3a4}, + 361: {cur: 0xe9, idx: 0xbc}, + 362: {cur: 0xfa, idx: 0x4}, + 363: {cur: 0x10e, idx: 0x3a8}, + 364: {cur: 0x69, idx: 0x46}, + 365: {cur: 0xaa, idx: 0x3ac}, + 366: {cur: 0x13, idx: 0x0}, + 367: {cur: 0x2e, idx: 0x0}, + 368: {cur: 0x3a, idx: 0x0}, + 369: {cur: 0x43, idx: 0x0}, + 370: {cur: 0x5e, idx: 0x3af}, + 371: {cur: 0x71, idx: 0x0}, + 372: {cur: 0x7b, idx: 0x0}, + 373: {cur: 0x7c, idx: 0x0}, + 374: {cur: 0x84, idx: 0x25}, + 375: {cur: 0x8c, idx: 0x0}, + 376: {cur: 0xb1, idx: 0x0}, + 377: {cur: 0xbf, idx: 0x0}, + 378: {cur: 0xf4, idx: 0x0}, + 379: {cur: 0xfa, idx: 0x4}, + 380: {cur: 0x103, idx: 0x0}, + 381: {cur: 0x10e, idx: 0x0}, + 382: {cur: 0x115, idx: 0x0}, + 383: {cur: 0x84, idx: 0x25}, + 384: {cur: 0xc6, idx: 0xa2}, + 385: {cur: 0xe9, idx: 0xbc}, + 386: {cur: 0xfa, idx: 0x4}, + 387: {cur: 0x51, idx: 0x30}, + 388: {cur: 0x51, idx: 0x2ef}, + 389: {cur: 0x11, idx: 0x3b2}, + 390: {cur: 0x13, idx: 0x3b6}, + 391: {cur: 0x1d, idx: 0x3ba}, + 392: {cur: 0x25, idx: 0x3bd}, + 393: {cur: 0x26, idx: 0x3c1}, + 394: {cur: 0x32, idx: 0x3c5}, + 395: {cur: 0x39, idx: 0x3c9}, + 396: {cur: 0x3a, idx: 0x296}, + 397: {cur: 0x41, idx: 0x3cd}, + 398: {cur: 0x43, idx: 0x0}, + 399: {cur: 0x44, idx: 0x3d1}, + 400: {cur: 0x4c, idx: 0x3d5}, + 401: {cur: 0x5f, idx: 0x3de}, + 402: {cur: 0x60, idx: 0x3e2}, + 403: {cur: 0x61, idx: 0x2dd}, + 404: {cur: 0x62, idx: 0x3e7}, + 405: {cur: 0x67, idx: 0x3ec}, + 406: {cur: 0x71, idx: 0x0}, + 407: {cur: 0x78, idx: 0x3f1}, + 408: {cur: 0x79, idx: 0x3f6}, + 409: {cur: 0x81, idx: 0x3fb}, + 410: {cur: 0x84, idx: 0x0}, + 411: {cur: 0x91, idx: 0x401}, + 412: {cur: 0xac, idx: 0x406}, + 413: {cur: 0xb1, idx: 0x3a0}, + 414: {cur: 0xb8, idx: 0x40b}, + 415: {cur: 0xbf, idx: 0x3a4}, + 416: {cur: 0xcd, idx: 0x412}, + 417: {cur: 0xd5, idx: 0x419}, + 418: {cur: 0xdb, idx: 0x41d}, + 419: {cur: 0xe1, idx: 0x421}, + 420: {cur: 0xf3, idx: 0x425}, + 421: {cur: 0xf4, idx: 0x0}, + 422: {cur: 0xfa, idx: 0x429}, + 423: {cur: 0xff, idx: 0x42d}, + 424: {cur: 0x106, idx: 0x362}, + 425: {cur: 0x10e, idx: 0x0}, + 426: {cur: 0x115, idx: 0x431}, + 427: {cur: 0x24, idx: 0x344}, + 428: {cur: 0x11, idx: 0x0}, + 429: {cur: 0x13, idx: 0x439}, + 430: {cur: 0x25, idx: 0x0}, + 431: {cur: 0x26, idx: 0x0}, + 432: {cur: 0x32, idx: 0x0}, + 433: {cur: 0x39, idx: 0x0}, + 434: {cur: 0x3a, idx: 0x4}, + 435: {cur: 0x41, idx: 0x0}, + 436: {cur: 0x43, idx: 0x20}, + 437: {cur: 0x44, idx: 0x0}, + 438: {cur: 0x5f, idx: 0x0}, + 439: {cur: 0x60, idx: 0x0}, + 440: {cur: 0x62, idx: 0x3f}, + 441: {cur: 0x67, idx: 0x0}, + 442: {cur: 0x71, idx: 0x43f}, + 443: {cur: 0x7b, idx: 0x0}, + 444: {cur: 0x7c, idx: 0x0}, + 445: {cur: 0x84, idx: 0x25}, + 446: {cur: 0x8c, idx: 0x0}, + 447: {cur: 0x91, idx: 0x0}, + 448: {cur: 0xb1, idx: 0x0}, + 449: {cur: 0xb8, idx: 0x0}, + 450: {cur: 0xbf, idx: 0x445}, + 451: {cur: 0xd5, idx: 0x0}, + 452: {cur: 0xdb, idx: 0x44b}, + 453: {cur: 0xe1, idx: 0x0}, + 454: {cur: 0xf3, idx: 0x0}, + 455: {cur: 0xfa, idx: 0x451}, + 456: {cur: 0xff, idx: 0x0}, + 457: {cur: 0x103, idx: 0x0}, + 458: {cur: 0x107, idx: 0x0}, + 459: {cur: 0x113, idx: 0x0}, + 460: {cur: 0x115, idx: 0x0}, + 461: {cur: 0x3b, idx: 0x315}, + 462: {cur: 0x50, idx: 0x21f}, + 463: {cur: 0x53, idx: 0x457}, + 464: {cur: 0x69, idx: 0x46}, + 465: {cur: 0x75, idx: 0x45a}, + 466: {cur: 0x88, idx: 0x6b}, + 467: {cur: 0x61, idx: 0x0}, + 468: {cur: 0x98, idx: 0x2dd}, + 469: {cur: 0xa2, idx: 0x87}, + 470: {cur: 0xaa, idx: 0x3ac}, + 471: {cur: 0xad, idx: 0x7e}, + 472: {cur: 0xd3, idx: 0xb6}, + 473: {cur: 0xd6, idx: 0x352}, + 474: {cur: 0xe7, idx: 0x45c}, + 475: {cur: 0xee, idx: 0x45f}, + 476: {cur: 0x105, idx: 0x35f}, + 477: {cur: 0x13, idx: 0xf4}, + 478: {cur: 0x3a, idx: 0x9b}, + 479: {cur: 0x5f, idx: 0x153}, + 480: {cur: 0xd5, idx: 0x27c}, + 481: {cur: 0xe9, idx: 0xbc}, + 482: {cur: 0x115, idx: 0x0}, + 483: {cur: 0x84, idx: 0x25}, + 484: {cur: 0xe9, idx: 0xbc}, + 485: {cur: 0xfa, idx: 0x4}, + 486: {cur: 0xe9, idx: 0xbc}, + 487: {cur: 0xfa, idx: 0x4}, + 488: {cur: 0x13, idx: 0x293}, + 489: {cur: 0x2e, idx: 0x462}, + 490: {cur: 0x3a, idx: 0x296}, + 491: {cur: 0x5b, idx: 0x37}, + 492: {cur: 0xb1, idx: 0x3a0}, + 493: {cur: 0xe9, idx: 0xbc}, + 494: {cur: 0xfa, idx: 0x4}, + 495: {cur: 0x12, idx: 0x2f7}, + 496: {cur: 0x84, idx: 0x25}, + 497: {cur: 0xfa, idx: 0x4}, + 498: {cur: 0xe9, idx: 0xbc}, + 499: {cur: 0x85, idx: 0x2f3}, + 500: {cur: 0xb9, idx: 0x97}, + 501: {cur: 0x66, idx: 0xee}, + 502: {cur: 0xfa, idx: 0x4}, + 503: {cur: 0x43, idx: 0x474}, + 504: {cur: 0x79, idx: 0x47f}, + 505: {cur: 0x84, idx: 0x25}, + 506: {cur: 0xe9, idx: 0xbc}, + 507: {cur: 0xfa, idx: 0x4}, + 508: {cur: 0xe9, idx: 0xbc}, + 509: {cur: 0xfa, idx: 0x4}, + 510: {cur: 0x13, idx: 0x0}, + 511: {cur: 0x2e, idx: 0x0}, + 512: {cur: 0x3a, idx: 0x0}, + 513: {cur: 0x43, idx: 0x0}, + 514: {cur: 0x5d, idx: 0x0}, + 515: {cur: 0x62, idx: 0x0}, + 516: {cur: 0x71, idx: 0x0}, + 517: {cur: 0x7b, idx: 0x0}, + 518: {cur: 0x7c, idx: 0x0}, + 519: {cur: 0x84, idx: 0x0}, + 520: {cur: 0x8c, idx: 0x0}, + 521: {cur: 0xb1, idx: 0x0}, + 522: {cur: 0xbf, idx: 0x0}, + 523: {cur: 0xf4, idx: 0x0}, + 524: {cur: 0xfa, idx: 0x0}, + 525: {cur: 0x103, idx: 0x0}, + 526: {cur: 0x10e, idx: 0x0}, + 527: {cur: 0x115, idx: 0x0}, + 528: {cur: 0x18, idx: 0x9}, + 529: {cur: 0x13, idx: 0x0}, + 530: {cur: 0x84, idx: 0x25}, + 531: {cur: 0xc8, idx: 0xa6}, + 532: {cur: 0xe9, idx: 0xbc}, + 533: {cur: 0xfa, idx: 0x4}, + 534: {cur: 0x13, idx: 0x0}, + 535: {cur: 0x2e, idx: 0x0}, + 536: {cur: 0x3a, idx: 0x0}, + 537: {cur: 0x43, idx: 0x0}, + 538: {cur: 0x5d, idx: 0x0}, + 539: {cur: 0x62, idx: 0x0}, + 540: {cur: 0x71, idx: 0x0}, + 541: {cur: 0x76, idx: 0x54}, + 542: {cur: 0x7b, idx: 0x0}, + 543: {cur: 0x7c, idx: 0x0}, + 544: {cur: 0x84, idx: 0x25}, + 545: {cur: 0x8c, idx: 0x0}, + 546: {cur: 0xb1, idx: 0x0}, + 547: {cur: 0xbf, idx: 0x0}, + 548: {cur: 0xf4, idx: 0x0}, + 549: {cur: 0xfa, idx: 0x0}, + 550: {cur: 0x103, idx: 0x0}, + 551: {cur: 0x10e, idx: 0x0}, + 552: {cur: 0x7, idx: 0x486}, + 553: {cur: 0xe9, idx: 0xbc}, + 554: {cur: 0xfa, idx: 0x4}, + 555: {cur: 0x13, idx: 0xf4}, + 556: {cur: 0x77, idx: 0x57}, + 557: {cur: 0x7c, idx: 0x7e}, + 558: {cur: 0xe9, idx: 0xbc}, + 559: {cur: 0xb9, idx: 0x97}, + 560: {cur: 0x43, idx: 0x25}, + 561: {cur: 0x13, idx: 0x0}, + 562: {cur: 0x2e, idx: 0x0}, + 563: {cur: 0x3a, idx: 0x0}, + 564: {cur: 0x5d, idx: 0x0}, + 565: {cur: 0x62, idx: 0x0}, + 566: {cur: 0x7c, idx: 0x0}, + 567: {cur: 0x8c, idx: 0x0}, + 568: {cur: 0xb1, idx: 0x0}, + 569: {cur: 0xbf, idx: 0x0}, + 570: {cur: 0xf4, idx: 0x0}, + 571: {cur: 0xfa, idx: 0x0}, + 572: {cur: 0x103, idx: 0x0}, + 573: {cur: 0x2e, idx: 0x0}, + 574: {cur: 0x71, idx: 0x0}, + 575: {cur: 0x84, idx: 0x0}, + 576: {cur: 0x8c, idx: 0x0}, + 577: {cur: 0xb1, idx: 0x0}, + 578: {cur: 0xe9, idx: 0xbc}, + 579: {cur: 0xf4, idx: 0x0}, + 580: {cur: 0x43, idx: 0x48d}, + 581: {cur: 0x84, idx: 0x491}, + 582: {cur: 0xfa, idx: 0x4}, + 583: {cur: 0xf5, idx: 0x22e}, + 584: {cur: 0x13, idx: 0x0}, + 585: {cur: 0x43, idx: 0x0}, + 586: {cur: 0x64, idx: 0x42}, + 587: {cur: 0x71, idx: 0x0}, + 588: {cur: 0x7b, idx: 0x0}, + 589: {cur: 0x7c, idx: 0x0}, + 590: {cur: 0x84, idx: 0x0}, + 591: {cur: 0x8c, idx: 0x0}, + 592: {cur: 0xbf, idx: 0x0}, + 593: {cur: 0x103, idx: 0x0}, + 594: {cur: 0x53, idx: 0x457}, + 595: {cur: 0x85, idx: 0x2f3}, + 596: {cur: 0xf5, idx: 0x22e}, + 597: {cur: 0x13, idx: 0xf4}, + 598: {cur: 0x4b, idx: 0x495}, + 599: {cur: 0xe9, idx: 0xbc}, + 600: {cur: 0x85, idx: 0x2f3}, + 601: {cur: 0x8f, idx: 0x72}, + 602: {cur: 0xd1, idx: 0xb2}, + 603: {cur: 0xe9, idx: 0xbc}, + 604: {cur: 0xfa, idx: 0x4}, + 605: {cur: 0x51, idx: 0x2ef}, + 606: {cur: 0x85, idx: 0x2f3}, + 607: {cur: 0x87, idx: 0x67}, + 608: {cur: 0xe9, idx: 0xbc}, + 609: {cur: 0xfa, idx: 0x4}, + 610: {cur: 0xe9, idx: 0xbc}, + 611: {cur: 0xfa, idx: 0x4}, + 612: {cur: 0x13, idx: 0xf4}, + 613: {cur: 0xf5, idx: 0x22e}, + 614: {cur: 0x13, idx: 0x0}, + 615: {cur: 0x2e, idx: 0x0}, + 616: {cur: 0x3a, idx: 0x0}, + 617: {cur: 0x62, idx: 0x0}, + 618: {cur: 0x71, idx: 0x0}, + 619: {cur: 0x7b, idx: 0x0}, + 620: {cur: 0x7c, idx: 0x0}, + 621: {cur: 0x86, idx: 0x49f}, + 622: {cur: 0x8c, idx: 0x0}, + 623: {cur: 0xb1, idx: 0x0}, + 624: {cur: 0xbf, idx: 0x0}, + 625: {cur: 0xe9, idx: 0xbc}, + 626: {cur: 0xf4, idx: 0x0}, + 627: {cur: 0xfa, idx: 0x0}, + 628: {cur: 0x10e, idx: 0x0}, + 629: {cur: 0xf5, idx: 0x22e}, + 630: {cur: 0x12, idx: 0x2f7}, + 631: {cur: 0x13, idx: 0xf4}, + 632: {cur: 0x84, idx: 0x25}, + 633: {cur: 0xe9, idx: 0xbc}, + 634: {cur: 0xfa, idx: 0x4}, + 635: {cur: 0xf9, idx: 0x2df}, + 636: {cur: 0xfa, idx: 0x4}, + 637: {cur: 0x3b, idx: 0x315}, + 638: {cur: 0x9, idx: 0x1}, + 639: {cur: 0x90, idx: 0x76}, + 640: {cur: 0xe9, idx: 0xbc}, + 641: {cur: 0x13, idx: 0x0}, + 642: {cur: 0x2e, idx: 0x0}, + 643: {cur: 0x3a, idx: 0x0}, + 644: {cur: 0x43, idx: 0x0}, + 645: {cur: 0x62, idx: 0x0}, + 646: {cur: 0x71, idx: 0x0}, + 647: {cur: 0x7b, idx: 0x0}, + 648: {cur: 0x7c, idx: 0x0}, + 649: {cur: 0x84, idx: 0x0}, + 650: {cur: 0x8c, idx: 0x0}, + 651: {cur: 0xb1, idx: 0x0}, + 652: {cur: 0xbf, idx: 0x0}, + 653: {cur: 0xf4, idx: 0x0}, + 654: {cur: 0xfa, idx: 0x0}, + 655: {cur: 0x103, idx: 0x0}, + 656: {cur: 0x107, idx: 0x0}, + 657: {cur: 0x10e, idx: 0x0}, + 658: {cur: 0x113, idx: 0x0}, + 659: {cur: 0x115, idx: 0x0}, + 660: {cur: 0x3b, idx: 0x315}, + 661: {cur: 0x85, idx: 0x2f3}, + 662: {cur: 0x85, idx: 0x2f3}, + 663: {cur: 0x13, idx: 0xf4}, + 664: {cur: 0x84, idx: 0x25}, + 665: {cur: 0x9a, idx: 0x84}, + 666: {cur: 0xe9, idx: 0xbc}, + 667: {cur: 0xfa, idx: 0x4}, + 668: {cur: 0x85, idx: 0x2f3}, + 669: {cur: 0xf5, idx: 0x22e}, + 670: {cur: 0x85, idx: 0x2f3}, + 671: {cur: 0xad, idx: 0x7e}, + 672: {cur: 0xa2, idx: 0x87}, + 673: {cur: 0xb7, idx: 0x4ac}, + 674: {cur: 0x13, idx: 0x0}, + 675: {cur: 0x43, idx: 0x0}, + 676: {cur: 0x62, idx: 0x0}, + 677: {cur: 0x71, idx: 0x0}, + 678: {cur: 0x7b, idx: 0x0}, + 679: {cur: 0x7c, idx: 0x0}, + 680: {cur: 0x84, idx: 0x0}, + 681: {cur: 0x8c, idx: 0x0}, + 682: {cur: 0xa4, idx: 0x4b0}, + 683: {cur: 0xbf, idx: 0x0}, + 684: {cur: 0xf4, idx: 0x0}, + 685: {cur: 0x103, idx: 0x0}, + 686: {cur: 0x84, idx: 0x25}, + 687: {cur: 0xe9, idx: 0xbc}, + 688: {cur: 0xfa, idx: 0x4}, + 689: {cur: 0xa8, idx: 0x8c}, + 690: {cur: 0xe9, idx: 0xbc}, + 691: {cur: 0xfa, idx: 0x4}, + 692: {cur: 0xe9, idx: 0xbc}, + 693: {cur: 0xfa, idx: 0x4}, + 694: {cur: 0x3a, idx: 0x0}, + 695: {cur: 0xb1, idx: 0x0}, + 696: {cur: 0xb4, idx: 0x94}, + 697: {cur: 0xfa, idx: 0x0}, + 698: {cur: 0x26, idx: 0x4}, + 699: {cur: 0xdb, idx: 0x4}, + 700: {cur: 0x8, idx: 0x4bc}, + 701: {cur: 0x14, idx: 0x4c0}, + 702: {cur: 0x75, idx: 0x45a}, + 703: {cur: 0xa7, idx: 0x8a}, + 704: {cur: 0xc1, idx: 0x37c}, + 705: {cur: 0xe9, idx: 0xbc}, + 706: {cur: 0xf3, idx: 0x20d}, + 707: {cur: 0xfa, idx: 0x4}, + 708: {cur: 0xb8, idx: 0x4}, + 709: {cur: 0x13, idx: 0x0}, + 710: {cur: 0x2e, idx: 0x0}, + 711: {cur: 0x3a, idx: 0x0}, + 712: {cur: 0x43, idx: 0x0}, + 713: {cur: 0x71, idx: 0x0}, + 714: {cur: 0x7b, idx: 0x0}, + 715: {cur: 0x7c, idx: 0x0}, + 716: {cur: 0x84, idx: 0x0}, + 717: {cur: 0x8c, idx: 0x0}, + 718: {cur: 0xb1, idx: 0x0}, + 719: {cur: 0xbd, idx: 0x30}, + 720: {cur: 0xbf, idx: 0x0}, + 721: {cur: 0xf4, idx: 0x0}, + 722: {cur: 0xfa, idx: 0x0}, + 723: {cur: 0x103, idx: 0x0}, + 724: {cur: 0x107, idx: 0x0}, + 725: {cur: 0x10e, idx: 0x0}, + 726: {cur: 0x115, idx: 0x0}, + 727: {cur: 0xbe, idx: 0x4c4}, + 728: {cur: 0xe9, idx: 0xbc}, + 729: {cur: 0x13, idx: 0xf4}, + 730: {cur: 0x3a, idx: 0x9b}, + 731: {cur: 0x5f, idx: 0x153}, + 732: {cur: 0xd5, idx: 0x27c}, + 733: {cur: 0xe9, idx: 0xbc}, + 734: {cur: 0x115, idx: 0x0}, + 735: {cur: 0x14, idx: 0x374}, + 736: {cur: 0xfa, idx: 0x4}, + 737: {cur: 0x8, idx: 0x358}, + 738: {cur: 0xe1, idx: 0x4}, + 739: {cur: 0x8, idx: 0x358}, + 740: {cur: 0xbd, idx: 0x30}, + 741: {cur: 0x62, idx: 0x229}, + 742: {cur: 0xe3, idx: 0x3f}, + 743: {cur: 0xf9, idx: 0x2df}, + 744: {cur: 0x5c, idx: 0x24a}, + 745: {cur: 0x85, idx: 0x2f3}, + 746: {cur: 0x64, idx: 0x42}, + 747: {cur: 0xfa, idx: 0x4}, + 748: {cur: 0x64, idx: 0x0}, + 749: {cur: 0xd1, idx: 0xb2}, + 750: {cur: 0xe9, idx: 0xbc}, + 751: {cur: 0xc7, idx: 0x4d8}, + 752: {cur: 0x13, idx: 0x0}, + 753: {cur: 0x3a, idx: 0x0}, + 754: {cur: 0x43, idx: 0x0}, + 755: {cur: 0x62, idx: 0x0}, + 756: {cur: 0x71, idx: 0x0}, + 757: {cur: 0x7b, idx: 0x0}, + 758: {cur: 0x7c, idx: 0x0}, + 759: {cur: 0x84, idx: 0x0}, + 760: {cur: 0x8c, idx: 0x0}, + 761: {cur: 0xb1, idx: 0x0}, + 762: {cur: 0xbf, idx: 0x0}, + 763: {cur: 0xc8, idx: 0xa6}, + 764: {cur: 0xf4, idx: 0x0}, + 765: {cur: 0xfa, idx: 0x0}, + 766: {cur: 0x103, idx: 0x0}, + 767: {cur: 0x4, idx: 0x38b}, + 768: {cur: 0x13, idx: 0xf4}, + 769: {cur: 0xca, idx: 0x4db}, + 770: {cur: 0xe9, idx: 0xbc}, + 771: {cur: 0x9, idx: 0x1}, + 772: {cur: 0x4b, idx: 0x495}, + 773: {cur: 0xca, idx: 0x4e0}, + 774: {cur: 0x98, idx: 0x2dd}, + 775: {cur: 0xa9, idx: 0x34a}, + 776: {cur: 0xb7, idx: 0x4ac}, + 777: {cur: 0xca, idx: 0x495}, + 778: {cur: 0xe4, idx: 0xb9}, + 779: {cur: 0xc3, idx: 0x380}, + 780: {cur: 0x27, idx: 0x10}, + 781: {cur: 0xc3, idx: 0x0}, + 782: {cur: 0xc3, idx: 0x0}, + 783: {cur: 0xfa, idx: 0x4}, + 784: {cur: 0x24, idx: 0x344}, + 785: {cur: 0x13, idx: 0x0}, + 786: {cur: 0x2e, idx: 0x0}, + 787: {cur: 0x3a, idx: 0x0}, + 788: {cur: 0x43, idx: 0x0}, + 789: {cur: 0x5d, idx: 0x0}, + 790: {cur: 0x62, idx: 0x0}, + 791: {cur: 0x71, idx: 0x0}, + 792: {cur: 0x7b, idx: 0x0}, + 793: {cur: 0x7c, idx: 0x0}, + 794: {cur: 0x84, idx: 0x0}, + 795: {cur: 0x8c, idx: 0x0}, + 796: {cur: 0xb1, idx: 0x0}, + 797: {cur: 0xbf, idx: 0x0}, + 798: {cur: 0xf4, idx: 0x0}, + 799: {cur: 0xfa, idx: 0x0}, + 800: {cur: 0x103, idx: 0x0}, + 801: {cur: 0x10e, idx: 0x0}, + 802: {cur: 0xa1, idx: 0x4f}, + 803: {cur: 0xf5, idx: 0x22e}, + 804: {cur: 0x0, idx: 0x4e7}, + 805: {cur: 0x84, idx: 0x25}, + 806: {cur: 0xd1, idx: 0xb2}, + 807: {cur: 0xd2, idx: 0x18}, + 808: {cur: 0xe9, idx: 0xbc}, + 809: {cur: 0xed, idx: 0x4f0}, + 810: {cur: 0xf6, idx: 0xcb}, + 811: {cur: 0xfa, idx: 0x4}, + 812: {cur: 0x37, idx: 0x24a}, + 813: {cur: 0xd2, idx: 0x0}, + 814: {cur: 0x86, idx: 0x49f}, + 815: {cur: 0x8f, idx: 0x72}, + 816: {cur: 0xa1, idx: 0x4f}, + 817: {cur: 0xd3, idx: 0xb6}, + 818: {cur: 0xf5, idx: 0x22e}, + 819: {cur: 0xd1, idx: 0xb2}, + 820: {cur: 0x85, idx: 0x2f3}, + 821: {cur: 0xf5, idx: 0x22e}, + 822: {cur: 0x51, idx: 0x4f7}, + 823: {cur: 0xbd, idx: 0x30}, + 824: {cur: 0xda, idx: 0x4fb}, + 825: {cur: 0xe9, idx: 0xbc}, + 826: {cur: 0xbd, idx: 0x4ff}, + 827: {cur: 0xda, idx: 0x30}, + 828: {cur: 0xb7, idx: 0x4ac}, + 829: {cur: 0x92, idx: 0x503}, + 830: {cur: 0xe9, idx: 0xbc}, + 831: {cur: 0x113, idx: 0x50b}, + 832: {cur: 0x13, idx: 0x0}, + 833: {cur: 0x2e, idx: 0x0}, + 834: {cur: 0x3a, idx: 0x0}, + 835: {cur: 0x43, idx: 0x0}, + 836: {cur: 0x62, idx: 0x0}, + 837: {cur: 0x71, idx: 0x0}, + 838: {cur: 0x7b, idx: 0x51b}, + 839: {cur: 0x7c, idx: 0x0}, + 840: {cur: 0x84, idx: 0x0}, + 841: {cur: 0x8c, idx: 0x0}, + 842: {cur: 0xbf, idx: 0x0}, + 843: {cur: 0xf4, idx: 0x0}, + 844: {cur: 0xfa, idx: 0x0}, + 845: {cur: 0x103, idx: 0x0}, + 846: {cur: 0x3a, idx: 0x0}, + 847: {cur: 0x84, idx: 0x25}, + 848: {cur: 0xe9, idx: 0xbc}, + 849: {cur: 0xfa, idx: 0x4}, + 850: {cur: 0xe0, idx: 0x227}, + 851: {cur: 0x50, idx: 0x21f}, + 852: {cur: 0x5c, idx: 0x24a}, + 853: {cur: 0x85, idx: 0x2f3}, + 854: {cur: 0x6, idx: 0x51f}, + 855: {cur: 0xe9, idx: 0xbc}, + 856: {cur: 0xa4, idx: 0x525}, + 857: {cur: 0x13, idx: 0x0}, + 858: {cur: 0x18, idx: 0x2c1}, + 859: {cur: 0x84, idx: 0x25}, + 860: {cur: 0x8c, idx: 0x0}, + 861: {cur: 0xbf, idx: 0x0}, + 862: {cur: 0x103, idx: 0x0}, + 863: {cur: 0x13, idx: 0x0}, + 864: {cur: 0x18, idx: 0x9}, + 865: {cur: 0x84, idx: 0x25}, + 866: {cur: 0x8c, idx: 0x0}, + 867: {cur: 0xbf, idx: 0x0}, + 868: {cur: 0x103, idx: 0x0}, + 869: {cur: 0x13, idx: 0x0}, + 870: {cur: 0x1a, idx: 0x23e}, + 871: {cur: 0x25, idx: 0x11f}, + 872: {cur: 0x2e, idx: 0x52c}, + 873: {cur: 0x32, idx: 0x127}, + 874: {cur: 0x39, idx: 0x12b}, + 875: {cur: 0x43, idx: 0x0}, + 876: {cur: 0x51, idx: 0x4f7}, + 877: {cur: 0x52, idx: 0x256}, + 878: {cur: 0x56, idx: 0x530}, + 879: {cur: 0x57, idx: 0x534}, + 880: {cur: 0x62, idx: 0x0}, + 881: {cur: 0x71, idx: 0x0}, + 882: {cur: 0x78, idx: 0x539}, + 883: {cur: 0x7c, idx: 0x0}, + 884: {cur: 0x80, idx: 0x53e}, + 885: {cur: 0x82, idx: 0x171}, + 886: {cur: 0x84, idx: 0x0}, + 887: {cur: 0x8c, idx: 0x0}, + 888: {cur: 0xbd, idx: 0x4ff}, + 889: {cur: 0xbf, idx: 0x0}, + 890: {cur: 0xda, idx: 0x30}, + 891: {cur: 0xf4, idx: 0x0}, + 892: {cur: 0x103, idx: 0x0}, + 893: {cur: 0x85, idx: 0x2f3}, + 894: {cur: 0xe9, idx: 0xbc}, + 895: {cur: 0xf5, idx: 0x22e}, + 896: {cur: 0x3b, idx: 0x315}, + 897: {cur: 0xf9, idx: 0x2df}, + 898: {cur: 0x84, idx: 0x25}, + 899: {cur: 0xe9, idx: 0xbc}, + 900: {cur: 0xfa, idx: 0x4}, + 901: {cur: 0x92, idx: 0x542}, + 902: {cur: 0xb4, idx: 0x94}, + 903: {cur: 0xdb, idx: 0x280}, + 904: {cur: 0xb4, idx: 0x94}, + 905: {cur: 0xdb, idx: 0x4}, + 906: {cur: 0xfa, idx: 0xcf}, + 907: {cur: 0xe9, idx: 0xbc}, + 908: {cur: 0xfa, idx: 0x4}, + 909: {cur: 0xf9, idx: 0x2df}, + 910: {cur: 0x85, idx: 0x2f3}, + 911: {cur: 0x13, idx: 0xf4}, + 912: {cur: 0x84, idx: 0x25}, + 913: {cur: 0x5c, idx: 0x24a}, + 914: {cur: 0x58, idx: 0x223}, + 915: {cur: 0x5d, idx: 0x0}, + 916: {cur: 0x62, idx: 0x0}, + 917: {cur: 0x13, idx: 0x546}, + 918: {cur: 0xbf, idx: 0x54b}, + 919: {cur: 0xef, idx: 0xc0}, + 920: {cur: 0x13, idx: 0xf4}, + 921: {cur: 0x84, idx: 0x25}, + 922: {cur: 0xe9, idx: 0xbc}, + 923: {cur: 0xf2, idx: 0xc3}, + 924: {cur: 0xfa, idx: 0x4}, + 925: {cur: 0x43, idx: 0x491}, + 926: {cur: 0xfa, idx: 0x4}, + 927: {cur: 0x13, idx: 0x0}, + 928: {cur: 0x2e, idx: 0x0}, + 929: {cur: 0x3a, idx: 0x0}, + 930: {cur: 0x43, idx: 0x0}, + 931: {cur: 0x5d, idx: 0x0}, + 932: {cur: 0x62, idx: 0x0}, + 933: {cur: 0x71, idx: 0x0}, + 934: {cur: 0x7b, idx: 0x0}, + 935: {cur: 0x7c, idx: 0x0}, + 936: {cur: 0x84, idx: 0x25}, + 937: {cur: 0x8c, idx: 0x0}, + 938: {cur: 0xb1, idx: 0x0}, + 939: {cur: 0xbf, idx: 0x0}, + 940: {cur: 0xf4, idx: 0x0}, + 941: {cur: 0xf6, idx: 0xcb}, + 942: {cur: 0xf7, idx: 0x550}, + 943: {cur: 0xfa, idx: 0x0}, + 944: {cur: 0x103, idx: 0x0}, + 945: {cur: 0x10e, idx: 0x0}, + 946: {cur: 0xc7, idx: 0x7e}, + 947: {cur: 0xe9, idx: 0xbc}, + 948: {cur: 0xfa, idx: 0x4}, + 949: {cur: 0xc7, idx: 0x0}, + 950: {cur: 0x100, idx: 0x558}, + 951: {cur: 0x4, idx: 0x38b}, + 952: {cur: 0xe9, idx: 0xbc}, + 953: {cur: 0x100, idx: 0x55e}, + 954: {cur: 0x93, idx: 0x4}, + 955: {cur: 0x93, idx: 0x4}, + 956: {cur: 0x13, idx: 0xf4}, + 957: {cur: 0xe9, idx: 0xbc}, + 958: {cur: 0xf5, idx: 0x22e}, + 959: {cur: 0x84, idx: 0x25}, + 960: {cur: 0xfa, idx: 0x4}, + 961: {cur: 0xf9, idx: 0x2df}, + 962: {cur: 0xb9, idx: 0x97}, + 963: {cur: 0x13, idx: 0xf4}, + 964: {cur: 0x84, idx: 0x25}, + 965: {cur: 0x8c, idx: 0x565}, + 966: {cur: 0x13, idx: 0xf4}, + 967: {cur: 0x43, idx: 0x491}, + 968: {cur: 0x7a, idx: 0x569}, + 969: {cur: 0x8c, idx: 0x565}, + 970: {cur: 0x43, idx: 0x20}, + 971: {cur: 0x43, idx: 0x20}, + 972: {cur: 0xa9, idx: 0x34a}, + 973: {cur: 0x43, idx: 0x20}, + 974: {cur: 0xdb, idx: 0x4}, + 975: {cur: 0x13, idx: 0xf4}, + 976: {cur: 0x84, idx: 0x25}, + 977: {cur: 0x8c, idx: 0x565}, + 978: {cur: 0xf4, idx: 0x4}, + 979: {cur: 0x8c, idx: 0x6e}, + 980: {cur: 0xf4, idx: 0xc7}, + 981: {cur: 0xa9, idx: 0x34a}, + 982: {cur: 0xe9, idx: 0xbc}, + 983: {cur: 0x123, idx: 0xe9}, +} // Size: 3960 bytes + +var narrowLangIndex = []uint16{ // 753 elements + // Entry 0 - 3F + 0x0000, 0x0062, 0x0062, 0x0062, 0x0063, 0x0063, 0x0063, 0x0063, + 0x0063, 0x0063, 0x0063, 0x0064, 0x0064, 0x0080, 0x0080, 0x0081, + 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, + 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, + 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, + 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x0081, 0x008a, + 0x008a, 0x008d, 0x008d, 0x008d, 0x008d, 0x008d, 0x008d, 0x008d, + 0x00a7, 0x00a7, 0x00a7, 0x00a7, 0x00a7, 0x00a7, 0x00d6, 0x00d6, + // Entry 40 - 7F + 0x00d6, 0x00d6, 0x00d6, 0x00d7, 0x00d7, 0x00d7, 0x00d7, 0x00d7, + 0x00d7, 0x00da, 0x00da, 0x00da, 0x00da, 0x00db, 0x00db, 0x00db, + 0x00db, 0x00db, 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, + 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, 0x00dc, + 0x00de, 0x00de, 0x00de, 0x00de, 0x00e4, 0x00e4, 0x00ea, 0x00ea, + 0x00ea, 0x00ea, 0x00ea, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, + 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, + 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, + // Entry 80 - BF + 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, + 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00f3, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + // Entry C0 - FF + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, 0x00fb, + 0x00fb, 0x00fe, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, + 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, + // Entry 100 - 13F + 0x0100, 0x0100, 0x0105, 0x0105, 0x0105, 0x0105, 0x0105, 0x0105, + 0x0105, 0x0105, 0x0106, 0x0106, 0x0107, 0x0108, 0x0108, 0x0109, + 0x0109, 0x0109, 0x0109, 0x0109, 0x0109, 0x0109, 0x0109, 0x0109, + 0x0109, 0x0109, 0x0109, 0x0165, 0x0165, 0x0166, 0x0166, 0x0166, + 0x0166, 0x0166, 0x016e, 0x016e, 0x016e, 0x016e, 0x016e, 0x016e, + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, + // Entry 140 - 17F + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, + 0x0172, 0x0172, 0x0172, 0x0172, 0x0172, 0x0173, 0x0173, 0x0174, + 0x0174, 0x0178, 0x0178, 0x0178, 0x0178, 0x0178, 0x0178, 0x017a, + 0x017a, 0x017a, 0x017a, 0x017a, 0x017a, 0x017a, 0x017a, 0x017a, + 0x017a, 0x017a, 0x017a, 0x017a, 0x017b, 0x017b, 0x017c, 0x017c, + 0x017d, 0x017d, 0x017d, 0x017d, 0x017d, 0x017e, 0x017e, 0x017f, + 0x017f, 0x0180, 0x0180, 0x0180, 0x0180, 0x0180, 0x0180, 0x0181, + // Entry 180 - 1BF + 0x0181, 0x0186, 0x0186, 0x0186, 0x0186, 0x0186, 0x0188, 0x0188, + 0x0188, 0x0188, 0x0188, 0x0188, 0x0188, 0x0188, 0x0189, 0x0189, + 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, + 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, 0x0189, 0x018a, 0x018a, + 0x018a, 0x018a, 0x018a, 0x018a, 0x018a, 0x018a, 0x018b, 0x018b, + 0x018c, 0x018c, 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, + 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, 0x018e, + 0x018e, 0x018e, 0x0199, 0x0199, 0x0199, 0x0199, 0x019a, 0x019a, + // Entry 1C0 - 1FF + 0x019a, 0x019a, 0x019a, 0x019a, 0x019a, 0x019a, 0x019a, 0x019a, + 0x019a, 0x019b, 0x019b, 0x019b, 0x019b, 0x019b, 0x01a6, 0x01a6, + 0x01a6, 0x01a6, 0x01a6, 0x01a6, 0x01a6, 0x01a6, 0x01a7, 0x01a7, + 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a7, + 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a7, 0x01a8, 0x01a8, 0x01a9, + 0x01a9, 0x01ab, 0x01ab, 0x01ac, 0x01ac, 0x01ad, 0x01ad, 0x01ad, + 0x01ad, 0x01ad, 0x01ad, 0x01ad, 0x01ad, 0x01af, 0x01af, 0x01af, + 0x01af, 0x01af, 0x01af, 0x01af, 0x01b1, 0x01b1, 0x01b1, 0x01b1, + // Entry 200 - 23F + 0x01b1, 0x01b1, 0x01b1, 0x01b1, 0x01b2, 0x01b2, 0x01b2, 0x01b3, + 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, + 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, + 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, + 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b3, 0x01b4, 0x01b4, + 0x01b4, 0x01b4, 0x01b4, 0x01b4, 0x01b5, 0x01b5, 0x01b5, 0x01b5, + 0x01b5, 0x01b5, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, + 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, + // Entry 240 - 27F + 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b7, 0x01b8, + 0x01b8, 0x01b8, 0x01b8, 0x01b8, 0x01bb, 0x01bc, 0x01bc, 0x01bc, + 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, + 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, + 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, + 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01bc, 0x01be, 0x01be, 0x01bf, + 0x01bf, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, + 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c0, + // Entry 280 - 2BF + 0x01c0, 0x01c0, 0x01c0, 0x01c0, 0x01c2, 0x01c2, 0x01c2, 0x01c2, + 0x01c2, 0x01c2, 0x01c5, 0x01c5, 0x01c5, 0x01c5, 0x01c5, 0x01c5, + 0x01c5, 0x01c5, 0x01c8, 0x01c8, 0x01c8, 0x01c8, 0x01c9, 0x01c9, + 0x01c9, 0x01c9, 0x01c9, 0x01c9, 0x01ca, 0x01ca, 0x01ca, 0x01ca, + 0x01ca, 0x01cb, 0x01cb, 0x01cb, 0x01cb, 0x01cb, 0x01cc, 0x01cc, + 0x01cc, 0x01cc, 0x01cc, 0x01cc, 0x01cc, 0x01cc, 0x01cc, 0x01cc, + 0x01cc, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01ce, 0x01ce, + 0x01ce, 0x01ce, 0x01ce, 0x01cf, 0x01cf, 0x01d0, 0x01d0, 0x01d0, + // Entry 2C0 - 2FF + 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d0, + 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d0, 0x01d1, 0x01d1, 0x01d1, + 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, + 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, + 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d1, 0x01d3, 0x01d3, 0x01d3, + 0x01d3, 0x01d3, 0x01d3, 0x01d4, 0x01d4, 0x01d4, 0x01d4, 0x01dc, + 0x01dc, +} // Size: 1530 bytes + +var narrowSymIndex = []curToIndex{ // 476 elements + 0: {cur: 0x9, idx: 0x1}, + 1: {cur: 0x11, idx: 0x4}, + 2: {cur: 0x13, idx: 0x4}, + 3: {cur: 0x18, idx: 0x9}, + 4: {cur: 0x1a, idx: 0x4}, + 5: {cur: 0x1b, idx: 0xc}, + 6: {cur: 0x25, idx: 0x4}, + 7: {cur: 0x26, idx: 0x4}, + 8: {cur: 0x27, idx: 0x10}, + 9: {cur: 0x2e, idx: 0x13}, + 10: {cur: 0x32, idx: 0x4}, + 11: {cur: 0x35, idx: 0x16}, + 12: {cur: 0x37, idx: 0x18}, + 13: {cur: 0x39, idx: 0x4}, + 14: {cur: 0x3a, idx: 0x4}, + 15: {cur: 0x41, idx: 0x4}, + 16: {cur: 0x43, idx: 0x25}, + 17: {cur: 0x44, idx: 0x4}, + 18: {cur: 0x46, idx: 0x28}, + 19: {cur: 0x49, idx: 0x4}, + 20: {cur: 0x4a, idx: 0x4}, + 21: {cur: 0x4d, idx: 0x2c}, + 22: {cur: 0x51, idx: 0x30}, + 23: {cur: 0x52, idx: 0x4}, + 24: {cur: 0x57, idx: 0x33}, + 25: {cur: 0x5b, idx: 0x37}, + 26: {cur: 0x5d, idx: 0x3b}, + 27: {cur: 0x5f, idx: 0x4}, + 28: {cur: 0x60, idx: 0x3f}, + 29: {cur: 0x62, idx: 0x3f}, + 30: {cur: 0x64, idx: 0x42}, + 31: {cur: 0x67, idx: 0x3f}, + 32: {cur: 0x69, idx: 0x46}, + 33: {cur: 0x6d, idx: 0x49}, + 34: {cur: 0x70, idx: 0x4}, + 35: {cur: 0x71, idx: 0x4}, + 36: {cur: 0x72, idx: 0x4f}, + 37: {cur: 0x74, idx: 0x51}, + 38: {cur: 0x76, idx: 0x54}, + 39: {cur: 0x77, idx: 0x57}, + 40: {cur: 0x7b, idx: 0x5a}, + 41: {cur: 0x7c, idx: 0x5e}, + 42: {cur: 0x80, idx: 0x30}, + 43: {cur: 0x82, idx: 0x4}, + 44: {cur: 0x84, idx: 0x25}, + 45: {cur: 0x87, idx: 0x67}, + 46: {cur: 0x88, idx: 0x6b}, + 47: {cur: 0x89, idx: 0x6e}, + 48: {cur: 0x8c, idx: 0x6e}, + 49: {cur: 0x8e, idx: 0x4}, + 50: {cur: 0x8f, idx: 0x72}, + 51: {cur: 0x90, idx: 0x76}, + 52: {cur: 0x91, idx: 0x7a}, + 53: {cur: 0x92, idx: 0x7e}, + 54: {cur: 0x93, idx: 0x4}, + 55: {cur: 0x95, idx: 0x81}, + 56: {cur: 0x9a, idx: 0x84}, + 57: {cur: 0xa2, idx: 0x87}, + 58: {cur: 0xa7, idx: 0x8a}, + 59: {cur: 0xa8, idx: 0x8c}, + 60: {cur: 0xad, idx: 0x7e}, + 61: {cur: 0xb1, idx: 0x4}, + 62: {cur: 0xb4, idx: 0x94}, + 63: {cur: 0xb8, idx: 0x4}, + 64: {cur: 0xb9, idx: 0x97}, + 65: {cur: 0xbb, idx: 0x9b}, + 66: {cur: 0xbd, idx: 0x30}, + 67: {cur: 0xbe, idx: 0x7e}, + 68: {cur: 0xbf, idx: 0x4}, + 69: {cur: 0xc6, idx: 0xa2}, + 70: {cur: 0xc7, idx: 0x7e}, + 71: {cur: 0xc8, idx: 0xa6}, + 72: {cur: 0xcb, idx: 0xaa}, + 73: {cur: 0xcf, idx: 0xae}, + 74: {cur: 0xd1, idx: 0xb2}, + 75: {cur: 0xd2, idx: 0x18}, + 76: {cur: 0xd3, idx: 0xb6}, + 77: {cur: 0xd5, idx: 0x4}, + 78: {cur: 0xda, idx: 0x30}, + 79: {cur: 0xdb, idx: 0x4}, + 80: {cur: 0xdc, idx: 0x3f}, + 81: {cur: 0xe1, idx: 0x4}, + 82: {cur: 0xe3, idx: 0x3f}, + 83: {cur: 0xe4, idx: 0xb9}, + 84: {cur: 0xe7, idx: 0x3f}, + 85: {cur: 0xe9, idx: 0xbc}, + 86: {cur: 0xef, idx: 0xc0}, + 87: {cur: 0xf2, idx: 0xc3}, + 88: {cur: 0xf3, idx: 0x4}, + 89: {cur: 0xf4, idx: 0x4}, + 90: {cur: 0xf6, idx: 0xcb}, + 91: {cur: 0xfa, idx: 0x4}, + 92: {cur: 0xff, idx: 0x4}, + 93: {cur: 0x102, idx: 0x10}, + 94: {cur: 0x103, idx: 0xd3}, + 95: {cur: 0x10e, idx: 0x4}, + 96: {cur: 0x123, idx: 0xe9}, + 97: {cur: 0x125, idx: 0xeb}, + 98: {cur: 0xf4, idx: 0xc7}, + 99: {cur: 0xf4, idx: 0xc7}, + 100: {cur: 0x11, idx: 0x10d}, + 101: {cur: 0x13, idx: 0xf4}, + 102: {cur: 0x1a, idx: 0x111}, + 103: {cur: 0x25, idx: 0x11f}, + 104: {cur: 0x26, idx: 0x123}, + 105: {cur: 0x32, idx: 0x127}, + 106: {cur: 0x39, idx: 0x12b}, + 107: {cur: 0x3a, idx: 0x1c}, + 108: {cur: 0x41, idx: 0x12f}, + 109: {cur: 0x43, idx: 0x20}, + 110: {cur: 0x44, idx: 0x133}, + 111: {cur: 0x4a, idx: 0x137}, + 112: {cur: 0x52, idx: 0x13b}, + 113: {cur: 0x5f, idx: 0x153}, + 114: {cur: 0x62, idx: 0x157}, + 115: {cur: 0x70, idx: 0x15c}, + 116: {cur: 0x71, idx: 0x4b}, + 117: {cur: 0x82, idx: 0x171}, + 118: {cur: 0x84, idx: 0x62}, + 119: {cur: 0x8e, idx: 0x196}, + 120: {cur: 0xb1, idx: 0x90}, + 121: {cur: 0xbf, idx: 0x9e}, + 122: {cur: 0xd5, idx: 0x1e0}, + 123: {cur: 0xe1, idx: 0x1f5}, + 124: {cur: 0xf3, idx: 0x20d}, + 125: {cur: 0xf4, idx: 0xc7}, + 126: {cur: 0xfa, idx: 0xcf}, + 127: {cur: 0xff, idx: 0x211}, + 128: {cur: 0x26, idx: 0x4}, + 129: {cur: 0x37, idx: 0x0}, + 130: {cur: 0x51, idx: 0x0}, + 131: {cur: 0x74, idx: 0x0}, + 132: {cur: 0x80, idx: 0x0}, + 133: {cur: 0xbd, idx: 0x0}, + 134: {cur: 0xc8, idx: 0x0}, + 135: {cur: 0xd2, idx: 0x0}, + 136: {cur: 0xda, idx: 0x0}, + 137: {cur: 0xf4, idx: 0xc7}, + 138: {cur: 0xcf, idx: 0x236}, + 139: {cur: 0xe7, idx: 0x23a}, + 140: {cur: 0xf4, idx: 0xc7}, + 141: {cur: 0x13, idx: 0x6}, + 142: {cur: 0x1a, idx: 0x23e}, + 143: {cur: 0x25, idx: 0x243}, + 144: {cur: 0x32, idx: 0x247}, + 145: {cur: 0x37, idx: 0x24a}, + 146: {cur: 0x39, idx: 0x12b}, + 147: {cur: 0x3a, idx: 0x1c}, + 148: {cur: 0x49, idx: 0x24d}, + 149: {cur: 0x4a, idx: 0x252}, + 150: {cur: 0x52, idx: 0x256}, + 151: {cur: 0x5f, idx: 0x153}, + 152: {cur: 0x60, idx: 0x25a}, + 153: {cur: 0x70, idx: 0x25f}, + 154: {cur: 0x80, idx: 0x262}, + 155: {cur: 0x82, idx: 0x267}, + 156: {cur: 0x8e, idx: 0x26a}, + 157: {cur: 0x93, idx: 0x26e}, + 158: {cur: 0xb1, idx: 0x90}, + 159: {cur: 0xb8, idx: 0x271}, + 160: {cur: 0xbf, idx: 0x9e}, + 161: {cur: 0xd1, idx: 0x274}, + 162: {cur: 0xd5, idx: 0x27c}, + 163: {cur: 0xdb, idx: 0x280}, + 164: {cur: 0xf3, idx: 0x20d}, + 165: {cur: 0xff, idx: 0x283}, + 166: {cur: 0x10e, idx: 0xdc}, + 167: {cur: 0x11, idx: 0x0}, + 168: {cur: 0x13, idx: 0x0}, + 169: {cur: 0x1a, idx: 0x0}, + 170: {cur: 0x1b, idx: 0x0}, + 171: {cur: 0x25, idx: 0x0}, + 172: {cur: 0x26, idx: 0x0}, + 173: {cur: 0x2e, idx: 0x0}, + 174: {cur: 0x32, idx: 0x0}, + 175: {cur: 0x37, idx: 0x0}, + 176: {cur: 0x39, idx: 0x0}, + 177: {cur: 0x3a, idx: 0x0}, + 178: {cur: 0x41, idx: 0x0}, + 179: {cur: 0x43, idx: 0x0}, + 180: {cur: 0x44, idx: 0x0}, + 181: {cur: 0x46, idx: 0x0}, + 182: {cur: 0x4a, idx: 0x0}, + 183: {cur: 0x52, idx: 0x0}, + 184: {cur: 0x5f, idx: 0x0}, + 185: {cur: 0x67, idx: 0x0}, + 186: {cur: 0x70, idx: 0x0}, + 187: {cur: 0x71, idx: 0x0}, + 188: {cur: 0x7b, idx: 0x0}, + 189: {cur: 0x7c, idx: 0x0}, + 190: {cur: 0x82, idx: 0x0}, + 191: {cur: 0x87, idx: 0x0}, + 192: {cur: 0x8c, idx: 0x0}, + 193: {cur: 0x8e, idx: 0x0}, + 194: {cur: 0x8f, idx: 0x0}, + 195: {cur: 0x90, idx: 0x0}, + 196: {cur: 0x93, idx: 0x0}, + 197: {cur: 0xa8, idx: 0x0}, + 198: {cur: 0xb1, idx: 0x0}, + 199: {cur: 0xb8, idx: 0x0}, + 200: {cur: 0xb9, idx: 0x0}, + 201: {cur: 0xbf, idx: 0x0}, + 202: {cur: 0xc6, idx: 0x0}, + 203: {cur: 0xcb, idx: 0x0}, + 204: {cur: 0xd5, idx: 0x0}, + 205: {cur: 0xdb, idx: 0x0}, + 206: {cur: 0xe1, idx: 0x0}, + 207: {cur: 0xe3, idx: 0x0}, + 208: {cur: 0xf2, idx: 0x0}, + 209: {cur: 0xf3, idx: 0x0}, + 210: {cur: 0xf4, idx: 0x0}, + 211: {cur: 0xf6, idx: 0x0}, + 212: {cur: 0xff, idx: 0x0}, + 213: {cur: 0x103, idx: 0x0}, + 214: {cur: 0xf4, idx: 0xc7}, + 215: {cur: 0x57, idx: 0x29a}, + 216: {cur: 0x91, idx: 0x2aa}, + 217: {cur: 0xef, idx: 0x2b3}, + 218: {cur: 0xf4, idx: 0xc7}, + 219: {cur: 0x102, idx: 0x0}, + 220: {cur: 0xcf, idx: 0x4f}, + 221: {cur: 0xf4, idx: 0xc7}, + 222: {cur: 0x1b, idx: 0x2ec}, + 223: {cur: 0x35, idx: 0x0}, + 224: {cur: 0x71, idx: 0x4b}, + 225: {cur: 0xf4, idx: 0xc7}, + 226: {cur: 0x123, idx: 0x0}, + 227: {cur: 0x125, idx: 0x0}, + 228: {cur: 0x51, idx: 0x2ef}, + 229: {cur: 0x80, idx: 0x2ef}, + 230: {cur: 0xbd, idx: 0x2ef}, + 231: {cur: 0xcf, idx: 0x4f}, + 232: {cur: 0xda, idx: 0x2ef}, + 233: {cur: 0xf4, idx: 0xc7}, + 234: {cur: 0x49, idx: 0x303}, + 235: {cur: 0x60, idx: 0x30b}, + 236: {cur: 0x69, idx: 0x310}, + 237: {cur: 0x88, idx: 0x315}, + 238: {cur: 0xcf, idx: 0x4f}, + 239: {cur: 0xd3, idx: 0x318}, + 240: {cur: 0xe7, idx: 0x0}, + 241: {cur: 0xf4, idx: 0xc7}, + 242: {cur: 0x125, idx: 0x8a}, + 243: {cur: 0x1b, idx: 0x334}, + 244: {cur: 0x27, idx: 0x337}, + 245: {cur: 0x4a, idx: 0xa2}, + 246: {cur: 0x57, idx: 0x3f}, + 247: {cur: 0x80, idx: 0x33a}, + 248: {cur: 0xcb, idx: 0x33d}, + 249: {cur: 0xda, idx: 0x33a}, + 250: {cur: 0xff, idx: 0x283}, + 251: {cur: 0x57, idx: 0x0}, + 252: {cur: 0xcf, idx: 0x4f}, + 253: {cur: 0xf4, idx: 0xc7}, + 254: {cur: 0x57, idx: 0x33}, + 255: {cur: 0x102, idx: 0x366}, + 256: {cur: 0x11, idx: 0x371}, + 257: {cur: 0x37, idx: 0x24a}, + 258: {cur: 0x52, idx: 0x256}, + 259: {cur: 0xcf, idx: 0xae}, + 260: {cur: 0xf2, idx: 0x379}, + 261: {cur: 0xcf, idx: 0xae}, + 262: {cur: 0x102, idx: 0x387}, + 263: {cur: 0xf4, idx: 0xc7}, + 264: {cur: 0xf4, idx: 0xc7}, + 265: {cur: 0x9, idx: 0x0}, + 266: {cur: 0x11, idx: 0x0}, + 267: {cur: 0x13, idx: 0x0}, + 268: {cur: 0x1a, idx: 0x0}, + 269: {cur: 0x1b, idx: 0x0}, + 270: {cur: 0x25, idx: 0x0}, + 271: {cur: 0x26, idx: 0x0}, + 272: {cur: 0x27, idx: 0x0}, + 273: {cur: 0x2e, idx: 0x0}, + 274: {cur: 0x32, idx: 0x0}, + 275: {cur: 0x35, idx: 0x0}, + 276: {cur: 0x37, idx: 0x0}, + 277: {cur: 0x39, idx: 0x0}, + 278: {cur: 0x3a, idx: 0x0}, + 279: {cur: 0x41, idx: 0x0}, + 280: {cur: 0x43, idx: 0x0}, + 281: {cur: 0x44, idx: 0x0}, + 282: {cur: 0x46, idx: 0x0}, + 283: {cur: 0x49, idx: 0x0}, + 284: {cur: 0x4a, idx: 0x0}, + 285: {cur: 0x4d, idx: 0x0}, + 286: {cur: 0x51, idx: 0x0}, + 287: {cur: 0x52, idx: 0x0}, + 288: {cur: 0x57, idx: 0x0}, + 289: {cur: 0x5b, idx: 0x0}, + 290: {cur: 0x5f, idx: 0x0}, + 291: {cur: 0x60, idx: 0x0}, + 292: {cur: 0x64, idx: 0x0}, + 293: {cur: 0x67, idx: 0x0}, + 294: {cur: 0x69, idx: 0x0}, + 295: {cur: 0x6d, idx: 0x0}, + 296: {cur: 0x70, idx: 0x0}, + 297: {cur: 0x71, idx: 0x0}, + 298: {cur: 0x72, idx: 0x0}, + 299: {cur: 0x74, idx: 0x0}, + 300: {cur: 0x76, idx: 0x0}, + 301: {cur: 0x77, idx: 0x0}, + 302: {cur: 0x7b, idx: 0x0}, + 303: {cur: 0x7c, idx: 0x0}, + 304: {cur: 0x80, idx: 0x0}, + 305: {cur: 0x82, idx: 0x0}, + 306: {cur: 0x87, idx: 0x0}, + 307: {cur: 0x88, idx: 0x0}, + 308: {cur: 0x89, idx: 0x0}, + 309: {cur: 0x8c, idx: 0x0}, + 310: {cur: 0x8e, idx: 0x0}, + 311: {cur: 0x8f, idx: 0x0}, + 312: {cur: 0x90, idx: 0x0}, + 313: {cur: 0x91, idx: 0x0}, + 314: {cur: 0x92, idx: 0x0}, + 315: {cur: 0x93, idx: 0x0}, + 316: {cur: 0x95, idx: 0x0}, + 317: {cur: 0x9a, idx: 0x0}, + 318: {cur: 0xa2, idx: 0x0}, + 319: {cur: 0xa7, idx: 0x0}, + 320: {cur: 0xa8, idx: 0x0}, + 321: {cur: 0xad, idx: 0x0}, + 322: {cur: 0xb1, idx: 0x0}, + 323: {cur: 0xb4, idx: 0x0}, + 324: {cur: 0xb8, idx: 0x0}, + 325: {cur: 0xb9, idx: 0x0}, + 326: {cur: 0xbb, idx: 0x0}, + 327: {cur: 0xbd, idx: 0x0}, + 328: {cur: 0xbe, idx: 0x0}, + 329: {cur: 0xbf, idx: 0x0}, + 330: {cur: 0xc6, idx: 0x0}, + 331: {cur: 0xc7, idx: 0x0}, + 332: {cur: 0xc8, idx: 0x0}, + 333: {cur: 0xcb, idx: 0x0}, + 334: {cur: 0xcf, idx: 0x0}, + 335: {cur: 0xd2, idx: 0x0}, + 336: {cur: 0xd3, idx: 0x0}, + 337: {cur: 0xd5, idx: 0x0}, + 338: {cur: 0xda, idx: 0x0}, + 339: {cur: 0xdb, idx: 0x0}, + 340: {cur: 0xdc, idx: 0x0}, + 341: {cur: 0xe1, idx: 0x0}, + 342: {cur: 0xe3, idx: 0x0}, + 343: {cur: 0xe4, idx: 0x0}, + 344: {cur: 0xe7, idx: 0x0}, + 345: {cur: 0xe9, idx: 0x0}, + 346: {cur: 0xef, idx: 0x0}, + 347: {cur: 0xf2, idx: 0x0}, + 348: {cur: 0xf3, idx: 0x0}, + 349: {cur: 0xf4, idx: 0x0}, + 350: {cur: 0xf6, idx: 0x0}, + 351: {cur: 0xff, idx: 0x0}, + 352: {cur: 0x102, idx: 0x0}, + 353: {cur: 0x103, idx: 0x0}, + 354: {cur: 0x10e, idx: 0x0}, + 355: {cur: 0x123, idx: 0x0}, + 356: {cur: 0x125, idx: 0x0}, + 357: {cur: 0xf4, idx: 0xc7}, + 358: {cur: 0x57, idx: 0x3da}, + 359: {cur: 0x88, idx: 0x315}, + 360: {cur: 0x91, idx: 0x2aa}, + 361: {cur: 0xbb, idx: 0x40f}, + 362: {cur: 0xcf, idx: 0x4f}, + 363: {cur: 0xd3, idx: 0x416}, + 364: {cur: 0xf4, idx: 0xc7}, + 365: {cur: 0x125, idx: 0x436}, + 366: {cur: 0x64, idx: 0x0}, + 367: {cur: 0x88, idx: 0x6b}, + 368: {cur: 0xbb, idx: 0x9b}, + 369: {cur: 0x125, idx: 0xeb}, + 370: {cur: 0xf4, idx: 0xc7}, + 371: {cur: 0xf4, idx: 0xc7}, + 372: {cur: 0x2e, idx: 0x462}, + 373: {cur: 0x88, idx: 0x315}, + 374: {cur: 0xd1, idx: 0x465}, + 375: {cur: 0xf4, idx: 0xc7}, + 376: {cur: 0xad, idx: 0x46c}, + 377: {cur: 0xf4, idx: 0xc7}, + 378: {cur: 0xf4, idx: 0xc7}, + 379: {cur: 0xf4, idx: 0xc7}, + 380: {cur: 0xf4, idx: 0xc7}, + 381: {cur: 0xf4, idx: 0xc7}, + 382: {cur: 0xf4, idx: 0xc7}, + 383: {cur: 0xf4, idx: 0xc7}, + 384: {cur: 0xf4, idx: 0xc7}, + 385: {cur: 0x37, idx: 0x24a}, + 386: {cur: 0x57, idx: 0x3da}, + 387: {cur: 0xbd, idx: 0x489}, + 388: {cur: 0xcf, idx: 0x4f}, + 389: {cur: 0xf4, idx: 0xc7}, + 390: {cur: 0x43, idx: 0x491}, + 391: {cur: 0x84, idx: 0x491}, + 392: {cur: 0xf4, idx: 0xc7}, + 393: {cur: 0xf4, idx: 0xc7}, + 394: {cur: 0xf4, idx: 0xc7}, + 395: {cur: 0xf4, idx: 0xc7}, + 396: {cur: 0xcf, idx: 0x4f}, + 397: {cur: 0xf4, idx: 0xc7}, + 398: {cur: 0x25, idx: 0x243}, + 399: {cur: 0x32, idx: 0x247}, + 400: {cur: 0x39, idx: 0x12b}, + 401: {cur: 0x3a, idx: 0x9b}, + 402: {cur: 0x52, idx: 0x256}, + 403: {cur: 0x57, idx: 0x499}, + 404: {cur: 0x71, idx: 0x4b}, + 405: {cur: 0x74, idx: 0x49c}, + 406: {cur: 0x82, idx: 0x267}, + 407: {cur: 0xf3, idx: 0x20d}, + 408: {cur: 0xf4, idx: 0xc7}, + 409: {cur: 0xf4, idx: 0xc7}, + 410: {cur: 0xf4, idx: 0xc7}, + 411: {cur: 0x1b, idx: 0x0}, + 412: {cur: 0x37, idx: 0x24a}, + 413: {cur: 0x7b, idx: 0x0}, + 414: {cur: 0x7c, idx: 0x0}, + 415: {cur: 0x87, idx: 0x0}, + 416: {cur: 0x90, idx: 0x0}, + 417: {cur: 0xa8, idx: 0x0}, + 418: {cur: 0xc8, idx: 0x4a6}, + 419: {cur: 0xcb, idx: 0x33d}, + 420: {cur: 0xd1, idx: 0x4a9}, + 421: {cur: 0x103, idx: 0x0}, + 422: {cur: 0xf4, idx: 0xc7}, + 423: {cur: 0xf4, idx: 0xc7}, + 424: {cur: 0xf4, idx: 0xc7}, + 425: {cur: 0xda, idx: 0x4b7}, + 426: {cur: 0xf4, idx: 0xc7}, + 427: {cur: 0xf4, idx: 0xc7}, + 428: {cur: 0xf4, idx: 0xc7}, + 429: {cur: 0x1a, idx: 0x23e}, + 430: {cur: 0x32, idx: 0x247}, + 431: {cur: 0xcf, idx: 0x4f}, + 432: {cur: 0xf4, idx: 0xc7}, + 433: {cur: 0xbe, idx: 0x4d1}, + 434: {cur: 0xf4, idx: 0xc7}, + 435: {cur: 0xf4, idx: 0xc7}, + 436: {cur: 0xf4, idx: 0xc7}, + 437: {cur: 0xcf, idx: 0x4f}, + 438: {cur: 0xf4, idx: 0xc7}, + 439: {cur: 0xf4, idx: 0xc7}, + 440: {cur: 0x64, idx: 0x4ec}, + 441: {cur: 0xcf, idx: 0x4f}, + 442: {cur: 0xf4, idx: 0xc7}, + 443: {cur: 0x37, idx: 0x24a}, + 444: {cur: 0x92, idx: 0x503}, + 445: {cur: 0xf4, idx: 0xc7}, + 446: {cur: 0xf4, idx: 0xc7}, + 447: {cur: 0xf4, idx: 0xc7}, + 448: {cur: 0x64, idx: 0x4ec}, + 449: {cur: 0xf4, idx: 0xc7}, + 450: {cur: 0x37, idx: 0x529}, + 451: {cur: 0x64, idx: 0x4ec}, + 452: {cur: 0xf4, idx: 0xc7}, + 453: {cur: 0x5b, idx: 0x0}, + 454: {cur: 0xcf, idx: 0x4f}, + 455: {cur: 0xf4, idx: 0xc7}, + 456: {cur: 0xf4, idx: 0xc7}, + 457: {cur: 0xf4, idx: 0xc7}, + 458: {cur: 0xf4, idx: 0xc7}, + 459: {cur: 0xf4, idx: 0xc7}, + 460: {cur: 0xcf, idx: 0x4f}, + 461: {cur: 0xf4, idx: 0xc7}, + 462: {cur: 0xf4, idx: 0xc7}, + 463: {cur: 0xf4, idx: 0xc7}, + 464: {cur: 0xf4, idx: 0xc7}, + 465: {cur: 0xcf, idx: 0x4f}, + 466: {cur: 0xf4, idx: 0xc7}, + 467: {cur: 0xcf, idx: 0x4f}, + 468: {cur: 0x37, idx: 0x56d}, + 469: {cur: 0x51, idx: 0x33a}, + 470: {cur: 0x74, idx: 0x49c}, + 471: {cur: 0x80, idx: 0x33a}, + 472: {cur: 0xbd, idx: 0x33a}, + 473: {cur: 0xc8, idx: 0x570}, + 474: {cur: 0xda, idx: 0x33a}, + 475: {cur: 0xf4, idx: 0xc7}, +} // Size: 1928 bytes + +// Total table size 18528 bytes (18KiB); checksum: 463A94A0 diff --git a/vendor/golang.org/x/text/currency/tables_test.go b/vendor/golang.org/x/text/currency/tables_test.go new file mode 100644 index 000000000..779f5001d --- /dev/null +++ b/vendor/golang.org/x/text/currency/tables_test.go @@ -0,0 +1,93 @@ +package currency + +import ( + "flag" + "strings" + "testing" + "time" + + "golang.org/x/text/internal/gen" + "golang.org/x/text/internal/testtext" + "golang.org/x/text/language" + "golang.org/x/text/message" + "golang.org/x/text/unicode/cldr" +) + +var draft = flag.String("draft", + "contributed", + `Minimal draft requirements (approved, contributed, provisional, unconfirmed).`) + +func TestTables(t *testing.T) { + testtext.SkipIfNotLong(t) + + // Read the CLDR zip file. + r := gen.OpenCLDRCoreZip() + defer r.Close() + + d := &cldr.Decoder{} + d.SetDirFilter("supplemental", "main") + d.SetSectionFilter("numbers") + data, err := d.DecodeZip(r) + if err != nil { + t.Fatalf("DecodeZip: %v", err) + } + + dr, err := cldr.ParseDraft(*draft) + if err != nil { + t.Fatalf("filter: %v", err) + } + + for _, lang := range data.Locales() { + p := message.NewPrinter(language.MustParse(lang)) + + ldml := data.RawLDML(lang) + if ldml.Numbers == nil || ldml.Numbers.Currencies == nil { + continue + } + for _, c := range ldml.Numbers.Currencies.Currency { + syms := cldr.MakeSlice(&c.Symbol) + syms.SelectDraft(dr) + + for _, sym := range c.Symbol { + cur, err := ParseISO(c.Type) + if err != nil { + continue + } + formatter := Symbol + switch sym.Alt { + case "": + case "narrow": + formatter = NarrowSymbol + default: + continue + } + want := sym.Data() + if got := p.Sprint(formatter(cur)); got != want { + t.Errorf("%s:%sSymbol(%s) = %s; want %s", lang, strings.Title(sym.Alt), c.Type, got, want) + } + } + } + } + + for _, reg := range data.Supplemental().CurrencyData.Region { + i := 0 + for ; regionData[i].Region().String() != reg.Iso3166; i++ { + } + it := Query(Historical, NonTender, Region(language.MustParseRegion(reg.Iso3166))) + for _, cur := range reg.Currency { + from, _ := time.Parse("2006-01-02", cur.From) + to, _ := time.Parse("2006-01-02", cur.To) + + it.Next() + for j, r := range []QueryIter{&iter{regionInfo: ®ionData[i]}, it} { + if got, _ := r.From(); from != got { + t.Errorf("%d:%s:%s:from: got %v; want %v", j, reg.Iso3166, cur.Iso4217, got, from) + } + if got, _ := r.To(); to != got { + t.Errorf("%d:%s:%s:to: got %v; want %v", j, reg.Iso3166, cur.Iso4217, got, to) + } + } + i++ + } + } +} -- cgit v1.2.3-1-g7c22